Um arquivo VRML, que consiste em uma descrição do "mundo" VRML, contém textos que podem ser criados em qualquer editor ou processador. Este arquivo, que é um arquivo ASCII, também pode ser criado através da utilização de aplicações que permitem a edição em três dimensões ou de utilitários que traduzem outros formatos de arquivos gráficos para VRML. O arquivo VRML, identificado pela extensão ".wrl", descreve como construir shapes (= figuras ou formas), onde colocá-las, que cores terão, e assim por diante. A expressão "mundo" VRML é usada para referenciar arquivos VRML, pois quando o navegador lê um arquivo VRML, ele constrói o "mundo" descrito no arquivo. Conforme o usuário move-se ao longo do "mundo", o navegador desenha, ou exibe, este "mundo".

Arquivos VRML podem conter quatro tipos principais de componentes:

• Header;
• Prototypes;
• Shapes, Interpolators, Sensors, Scripts;
• Routes;

• Comments;
• Nodes;
• Fields, field values;
• Defined node names;
• Used node names;

Antes de começar a descrever o conteúdo do arquivo deste primeiro exemplo, torna-se importante salientar que os navegadores pulam, ou ignoram, espaços, vírgulas, tabulações e linhas em branco, entretanto eles diferenciam letras minúsculas de maiúsculas. Sendo assim, é fundamental que a sintaxe dos comandos VRML seja memorizada.

A primeira linha do arquivo do exemplo anterior contém o cabeçalho (header) que é obrigatório em qualquer arquivo VRML e deve aparecer na primeira linha exatamente como mostrado no exemplo. Ele descreve que é um arquivo VRML, da versão 2.0 que usa o conjunto de caracteres internacional UTF-8, que é uma maneira padrão de digitar caracteres em muitas linguagens. Já os comentários permitem a inclusão de informação extra que não afeta a aparência do "mundo" VRML Eles iniciam com o caracter "#" e terminam no final da linha.

Os nós são os blocos básicos de construção de VRML, e o seu nome ou tipo indica o objeto que ele descreve, que são basicamente shapes e suas propriedades. Nós individuais descrevem shapes, cores, luzes, como posicionar e orientar shapes, etc. Um nó geralmente contém:

• O tipo do nó (obrigatório), como Shape, PointLight, Box, etc.
• Um par de chaves (obrigatório).
• Campos (opcional), que definem os atributos dos nós e por sua vez possuem:
• Nome;
• Tipo, que define o tipo de valor permitido;
• Valor default, que é utilizado caso não sejam especificados outros valores.

Exemplos de nós:

Cylinder          # tipo do nó 
{                 # abre chave
      height 2.0  # campo:  
      radius 2.0  # campo:  
}                 # fecha chave

Sphere {
     radius 2 
}

Box { }

É importante salientar que o valor de um campo define atributos como cor, tamanho ou posição, e cada valor é de um tipo específico, que descreve o tipo de valor permitido naquele campo. Estes tipos possuem nomes tais como "SFColor" e "SFImage". A maioria dos tipos dos campos são: tipos de um único valor (por exemplo, só uma cor ou um número), cujos nomes começam por "SF"; e tipos com múltiplos valores (por exemplo uma lista de cores ou números), cujos nomes começam por "MF". Os tipos de campos VRML são: SFBool, SFColor, MFColor, SFFloat, MFFloat, SFImage, SFInt32, MFInt32, SFNode, MFNode, SFRotation, MFRotation, SFString, MFString, SFTime, SFVec2f, MFVec2f, SFVec3f, MFVec3f.

Também é possível definir um nome, que consiste numa seqüência de letras, números e sublinhas, para qualquer nó. Uma vez que um nó tem um nome, este nó pode ser usado posteriormente no arquivo. Por exemplo, pode-se especificar o nome "cadeira" para um nó ou grupo de nós usados na construção de uma cadeira. Depois, para colocar quatro ao redor de uma mesa, é possível simplesmente reutilizar este nó, sem tem que descrever toda cadeira novamente. O nó com o nome definido é chamado "nó original" e cada reutilização deste nó é chamada "instância". Para definir um nó para ser instanciado, basta colocar a palavra "DEF" antes do nome escolhido. E para usar este nó novamente dentro do arquivo basta colocar a palavra "USE" na frente do nome. A sintaxe destes comandos é a seguinte:

	DEF    nome_do_nó   tipo_do_nó   { ... }
	USE   nome_do_nó

2.2. Construção de Shapes em um Arquivo VRML

Em VRML, os blocos básicos de construção são shapes, descritos através de nós e seus campos. Um shape descreve a forma, ou geometria, da estrutura 3D do objeto, e a sua aparência, com base no material a partir do qual é feito e na sua textura, tal com madeira. Estes dois atributos, geometria e aparência, são especificados por campos dentro do nó Shape. Sua sintaxe está descrita a seguir.

Shape {
	appearance   ...
	geometry       ...
}

No exemplo da figura 2.1, são criados dois shapes, o primeiro é um cilindro e o segundo é um cone. Ambos definem a geometria do shape e compartilham uma aparência comum. VRML suporta vários tipos de geometrias primitivas, que são pré-definidas, incluindo Sphere, Cylinder, Box, Cone, bem como vários outros shapes avançados, tais como "extruded shapes" e "elevation grids". Além da geometria, um Shape também possui propriedades, como material e textura, que definem seu aspecto. Estas propriedades são descritas no campo appearance.

Shapes podem ser agrupados para construção de formas mais complexas. O cilindro e o cone do exemplo da figura 2.1 são agrupados através do nó Group para criar uma cabana, que por sua vez pode ser agrupada para criar uma cidade. O nó que agrupa shapes é chamado parent. Os shapes que fazem parte do grupo são chamados children. Um grupo pode ter qualquer número de nós children, assim como podem ter outros grupos como children. Neste caso se diz que um grupo está aninhado (nested) em outro.

2.3. Espaço VRML

Os nós e campos em um arquivo VRML fornecem instruções de construção para criação de características de um mundo virtual. Tais instruções devem incluir distâncias e tamanhos precisos para controlar o tamanho e posicionamento dos shapes construídos no espaço 3D. Entretanto, torna-se importante atentar para o fato de que as unidades em VRML não são equivalentes a alguma unidade de medida do mundo real, tais como polegadas ou centímetros. Elas descrevem um tamanho ou uma distância dentro do contexto do mundo VRML.

Inicialmente, deve-se relembrar que um sistema de coordenadas é composto por dois eixos, X e Y, e pela origem (0.0, 0.0). Uma coordenada é formada pelo valor de X e de Y, que correspondem aos números ao longo dos eixos X e Y, respectivamente. Sendo assim, desenhar uma figura em duas dimensões torna-se bastante simples, basta dar a seqüência de coordenadas necessárias, e então imaginar que uma "caneta" irá ligar estes pontos para formar a figura final. Porém, a linguagem VRML é utilizada para desenhar figuras em três dimensões. Neste caso, é acrescentado um terceiro eixo ao sistema de coordenadas, o eixo Z. Os eixos X, Y e Z formam o sistema de coordenadas 3D, cuja origem consiste na coordenada espacial (0.0, 0.0, 0.0). Agora, uma "caneta virtual" pode ser movida para esquerda e para direita, para cima e para baixo e para frente e para trás.

Para facilmente identificar como o eixo Z é posicionado em relação a X e Y pode-se utilizar a regra da mão direita para os eixos 3D. Nesta regra a mão direita deve ficar reta com o indicador apontando para direção positiva de Y (para cima), o polegar apontando para a direção positiva de X (para o lado) e com o dedo do meio apontando para a direção positiva de Z (para frente). A figura 2.2 mostra o "funcionamento" da regra da mão direita.

Figura 2.2 – Regra da mão direita para os eixos 3D

2.4. Eventos e Rotas

Eventos e rotas possibilitam a criação de instruções que permitem a interatividade e o dinamismo no "mundo VRML". Através da criação de uma rota entre dois nós, onde o primeiro envia eventos (mensagens) para o segundo, é possível, por exemplo, clicar num objeto e fazer com que uma luz acenda ou uma música toque. Esta ligação em VRML envolve:

• Um par de nós, que serão ligados;
• Uma rota (route ou path) entre os dois nós.

Uma vez que a rota é construída entre dois nós, o primeiro nó pode enviar mensagens ao segundo nó ao longo desta rota. Tal mensagem, chamada de evento (event), contém um valor similar ao valor de campos dentro dos nós. Valores típicos de eventos incluem ponto flutuante, cor ou coordenada 3D. Quando um nó recebe um evento, ele reage ligando a luz, tocando uma música, iniciando uma animação, etc., dependendo das características do nó. Ligando múltiplos nós é possível criar circuitos complexos para tornar o "mundo VRML" dinâmico.

A maioria dos nós podem ser ligados a um circuito. Cada nó possui pinos de entrada e de saída aos quais podem ser feitas ligações. Por exemplo, nós que produzem luz possuem um pino de entrada para ligá-la ou desligá-la. Um nó pode ter vários pinos de entrada e saída disponíveis. No caso da luz, ainda pode-se ter pinos de entrada para trocar sua cor, sua intensidade, etc. Alguns tipos de nós possuem pinos de entrada e saída, enquanto outros têm apenas um dos dois tipos.

Um pino de entrada de um nó é chamado de eventIn. Um eventIn recebe eventos quando é conectado a uma rota e quando um evento é enviado para ele. Similarmente, um pino de saída é chamado de eventOut. Um eventOut envia eventos quando é conectado a uma rota. Da mesma maneira que o campo de um nó, cada eventIn e eventOut para um nó também tem um tipo. Um eventOut do tipo SFFloat, por exemplo, produz como saída um valor de ponto flutuante quando conectado a um circuito. Um eventOut do tipo SFColor envia cores. Similarmente, um eventIn do tipo SFFloat pode receber valores de ponto flutuante, e SFColor pode receber cores. Torna-se importante salientar que no momento de especificar uma rota, através do comando ROUTE, os tipos dos eventIn e eventOut devem ser iguais.

Um circuito VRML é construído descrevendo-se a rota a partir do eventOut de um nó para o eventIn de outro nó. A rota do circuito permanece "parada" até que um evento é enviado do primeiro nó para o segundo ao longo da rota. Quando o primeiro nó ativa a rota enviando um evento, este "viaja" até o segundo nó que reage. O tipo de reação depende:

• Do tipo do nó que recebe o evento;
• Do pino de entrada ao qual foi feita a ligação;
• Dos valores contidos no evento;
• Das atividades correntes do nó.

Por exemplo, quando um evento contendo um valor SFBool TRUE é enviado para o eventIn "on" de um nó de luz, a luz é ligada. Da mesma forma, quando um evento contendo um valor de ponto flutuante é enviado para o eventIn "intesidade" de um nó de luz, o brilho da luz é alterado.

Resumindo: circuitos podem ser construídos através da construção de rotas entre nós; uma rota conecta o eventOut de um nó ao eventIn de outro nó; o primeiro nó pode então enviar eventos ao segundo, fazendo com que segundo nó reaja.

Para ilustrar, o exemplo a seguir descreve um cubo que gira em torno do seu próprio eixo quando o usuário move o cursor sobre ele. Neste caso, o eventOut isOver do nó TouchSensor é enviado para o nó TimeSensor. O nó TimeSensor é enviado para o nó OrientationInterpolator que direciona a rota para o nó Transform. Quando o cursor move-se sobre o cubo. O nó TouchSensor envia TRUE usando o eventOut isOver que permite que o nó TimeSensor direcione o nó OrientationInterpolator e gire o cubo. Quando o cursor sai de cima do cubo, FALSE é enviado usando o eventOut isOver do nó TouchSensor, desabilitando o nó TimeSensor e parando a animação.

#VRML V2.0 utf8
# The VRML 2.0 Sourcebook
# Copyright (c) 1997
# Andrea L. Ames, David R. Nadeau, and John L. Moreland
# A cube that spins when the viewer's cursor moves over it

Group{
	children [
		# Cubo que gira quando o usuário clica sobre ele
		DEF Cube Transform {
			children Shape {
				appearance Appearance {
					material Material { }
				}
				geometry Box { }
			}
		},

		# Sensor, detecta quando o usuário clica em um objeto
		DEF Touch TouchSensor { }, 

		# relógio para controlar a animação
		DEF Clock TimeSensor {
			enabled FALSE
			cycleInterval 4.0
			loop TRUE
		},

		# Caminho da animação (movimento)
		DEF CubePath OrientationInterpolator {
			key [0.0, 0.50, 1.0]
			keyValue [
				0.0 1.0 0.0 0.0,
				0.0 1.0 0.0 3.14,
				0.0 1.0 0.0 6.28
			]
		}
	]
}

# Rotas
ROUTE Touch.isOver           TO Clock.set_enabled
ROUTE Clock.fraction_changed TO CubePath.set_fraction
ROUTE CubePath.value_changed TO Cube.set_rotation