#VRML V2.0 utf8 # ---------------------------------------------------------------- # A primeira linha acima é obrigatória em qualquer arquivo VRML 2# # Nas demais linhas, quando a parecer um #, significa um comentário. # ---------------------------------------------------------------- #
Todos os arquivos VRML devem ter a extensão WRL.
Os objetos tridimensionais em VRML 2 são chamados de SHAPES.
#VRML V2.0 utf8
# --------------------------------------------------------
# Desenho de um paralelepípedo Amarelo
# --------------------------------------------------------
Shape { # define um bloco de um objeto (Shape)
} # fim do shape
|
Um SHAPE possui, em geral dois atributos, a aparência e a geometria.
A Aparência define a cor do objeto, entre outros atributos. A Geometria define que objeto deve ser exibido.
Para definir um cubo (na verdade um paralelepípedo) use a expressão BOX. O centro padrão de um BOX é (0,0,0).
Na figura 1 aparece um exemplo de um programa em VRML contendo um BOX.
#VRML V2.0 utf8
# --------------------------------------------------------
# Desenho de um paralelepípedo Amarelo
# --------------------------------------------------------
Shape { # define um bloco de um obejto (Shape)
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 1.0 1.0 0.0 # r g b
}
}
geometry Box { # define a geometria do Shape
size 2.5 2.5 5.0 # larg, altura, prof
}
} # fim do shape
|
Figura 7.1 - Exemplo de um BOX em VRML 2
OBS: Clique aqui para carregar o objeto do exemplo
Para definir uma esfera, deve ser especificado o raio. A expressão é: Sphere { radius r1}. Se o raio for omitido o Browser assumirá o valor 1. O centro padrão da esfera é (0,0,0).
Na figura 2 aparece um exemplo de um programa em
VRML contendo uma esfera.
#VRML V2.0 utf8 # -------------------------------------------------------- # Desenho de uma esfera # -------------------------------------------------------- Shape { # define um bloco de um obejto (Shape)
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 1.0 0.5 0.3 # r g b
}
}
geometry Sphere {
radius 4.0
}
} # fim do shape
|
Figura 2 - Exemplo de uma Esfera em VRML 2
OBS: Clique aqui para carregar o objeto do exemplo
Um cilindro em VRML 2 é criado através do comando Cylinder:
geometry Cylinder {
radius 2.0 # raio
height 1.0 # altura
side TRUE # tem a lateral ?
top TRUE # tem a parte de cima ?
bottom TRUE # tem a parte de baixo ?
}
|
Figura 3 - Exemplo de um Cilindo em VRML 2
Um cone em VRML 2 é definido pelo comando Cone:
geometry Cone {
bottomRadius 1.0 # raio da base
height 5.0 # altura
side TRUE # tem a lateral ?
bottom TRUE # tem a base ?
}
|
Figura 4 - Exemplo de um Cone em VRML 2
Este polígonos, usados, em geral, para definir objetos facetados, são definidos a partir de duas estruturas: uma tabela de faces e uma tabela de vértices.
Na tabela de vértices, são inseridas as coordenadas X,Y e Z de cada ponto, sendo que cada coordenada é separada por um espaço e cada ponto, por uma vírgula. Por exemplo:
coord Coordinate {
point [ # lista de Vértices
0 10 0, # vértice 0
-5 0 5, # vértice 1
5 0 5, # vértice 2
5 0 -5, # vértice 3
-5 0 -5, # vértice 4
]
|
Na tabela de faces é definida a forma como os vértices conectam-se para formar as faces (polígonos). Nesta tabela, cada vértice é especificado por um número, correspondente à sua posição(índice) na tabela de vértices. O primeiro vértice da tabela tem sempre índice 0(zero). A separação de cada vértice é feita por uma vírgula e o final da descrição de uma face é especificado por "-1". Por exemplo:
coordIndex [ # lista de Faces
4, 3, 2, 1 -1, # Base (formada pelos vértices
4, 3,2 e 1)
0, 1, 2, -1, # Frontal
0, 2, 3, -1, # Direita
0, 3, 4, -1, # Traseira
0, 4, 1, -1 # Esquerda
]
|
Para que a remoção das faces seja feita de forma correta, todas as faces devem ser definidas com seus vértices orientados no sentido horário.
A seguir são definidos os vértices e as faces necessárias para criar uma pirâmide de base quadrada, com o ápice em (0,10,0).
#VRML V2.0 utf8 # -------------------------------------------------------- # Desenho de um objeto formado por faces (uma pirâmide) # -------------------------------------------------------- Shape {
appearance Appearance {
material Material {
diffuseColor 0.7 0.5 0.0 # MARRON
}
}
geometry IndexedFaceSet {
coord Coordinate {
point [ # lista de Vértices
0 10 0, # vértice 0
-5 0 5, # vértice 1
5 0 5, # vértice 2
5 0 -5, # vértice 3
-5 0 -5, # vértice 4
]
}
coordIndex [ # lista de Faces
4, 3, 2, 1 -1, # Base
0, 1, 2, -1, # Frontal
0, 2, 3, -1, # Direita
0, 3, 4, -1, # Traseira
0, 4, 1, -1 # Esquerda
]
}
}
|
Figura 5 - Exemplo de uma Pirâmide de uma cor em VRML 2
OBS: Clique aqui para carregar o objeto do exemplo
Além de definir a geometria do objeto através de suas faces, é possível definir cores individuais para as faces. Para isto usa-se os comandos Color e ColorIndex. Veja a seguir um exemplo de uso destes comandos.
#VRML V2.0 utf8 # -------------------------------------------------------- # Desenho de um objeto formado por faces (uma pirâmide) # -------------------------------------------------------- Shape {
appearance Appearance {
material Material { }
}
geometry IndexedFaceSet {
coord Coordinate {
point [
0 10 0, # vértice 0
-5 0 5, # vértice 1
5 0 5, # vértice 2
5 0 -5, # vértice 3
-5 0 -5, # vértice 4
]
}
coordIndex [
4, 3, 2, 1 -1, # Base
0, 1, 2, -1, # Frontal
0, 2, 3, -1, # Direita
0, 3, 4, -1, # Traseira
0, 4, 1, -1 # Esquerda
]
color Color {
color [
1.0 0.0 0.0, # Cor 0 : Vermelho
0.0 1.0 0.0, # Cor 1 : Verde
0.0 0.0 1.0, # Cor 2 : Azul
1.0 1.0 0.0, # Cor 3 : Amarelo
1.0 0.0 1.0 # Cor 4 : Roxo
0.7 0.5 0.0 # Cor 5 : Marron
]
}
colorPerVertex FALSE
colorIndex [ # define a cor de cada face
4, 5, 1, 2, 3, -1
]
}
}
|
Figura - Exemplo de uma Pirâmide multicolorida em VRML
OBS: Clique aqui para carregar o objeto do exemplo
Para definir uma cor, o VRML possui o comando Material e o comando diffuseColor. Na realidade Material define um grupo de propriedades visuais das quais, cor é uma delas. A especificação da cor é feita definindo-se suas componentes R,G e B, que podem variar no intervalo entre [0..1].
Outras propriedades do comando Material são:
No exemplo a seguir pode-se observar o uso do specularColor e do diffuseColor juntos.
#VRML V2.0 utf8 # -------------------------------------------------------- # Desenho de um paralelepípedo com cor Especular # -------------------------------------------------------- Shape { # define um bloco de um objeto (Shape)
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 0.3 1.0 0.0 # r g b
specularColor 0.5 0.0 0.0 # r g b
transparency 0.9 # entre 0 e 1
shininess 0.0 # entre 0 e 1
}
}
geometry Box {
size 2.5 2.5 5.0 # larg, altura, prof
}
} # fim do shape
|
OBS: Clique aqui para carregar o objeto do exemplo
A sguir é aprensentada uma tabela com exemplos de cores de alguma materiais (extraído do livro "The VRML 2.0 Sourcebook" de Andrea L. Ames, David R. Nadeau, and John L. Moreland. 1997 ).
Para aplicar uma textura(imagem) sobre um objeto, basta colocar o comando Texture dentro do bloco Apperance . A sintaxe deste comando é apresentada a seguir, onde é mapeada uma figura sobre um cubo.
#VRML V2.0 utf8 # --------------------------------------------------------
# Desenho de um paralelepípedo com cor Especular
# --------------------------------------------------------
Shape { # define um bloco de um objeto (Shape)
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 0.3 1.0 0.0 # r g b
} # fim do Material
texture ImageTexture {
url ["imagem1.jpg"]
} # fim do Texture
} # fim do Appearance
geometry Box {
size 500.0 500.0 200.0 # larg, altura, prof
}
} # fim do shape
|
Figura - Exemplo de um Cubo com Mapeamento de Textura
OBS: Clique aqui para carregar o objeto do exemplo
Para inseri mais de um objeto em uma arquivo VRML basta colocar os blocos Shape um após o outro. No exemplo a seguir observa-se um Box e um Cone no mesmo arquivo.
#VRML V2.0 utf8
# --------------------------------------------------------
# Arquivo em VRML 2 com um Box e um Cone
# --------------------------------------------------------
Shape { # BOX
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 0.3 1.0 0.0 # r g b
specularColor 0.5 0.0 0.0 # r g b
transparency 0.5 # entre 0 e 1
shininess 0.0 # entre 0 e 1
}
}
geometry Box {
size 2.5 2.5 5.0 # larg, altura, prof
}
} # fim do BOX Shape { # CONE
appearance Appearance
{
material Material {diffuseColor 1 0.5 0} # cor laranja
}
geometry Cone {
bottomRadius 1.0
height 5.0
side TRUE
bottom TRUE
}
}
# Fim do Cone
|
OBS: Clique aqui para carregar o objeto do exemplo
Até
o momento apresentamos apenas objetos em sua posições originais.
Em VRML, para mudar a posição ou orientação
de um objeto aplica-se transformações geométricas.
Uma transformação geométrica é definida através de um comando Transform dentro do
qual é possível especificar a rotação, a posição
e a escala a serem aplicadas aos objetos e quais os "objetos-filhos"
da transformação.
A seguir pode-se observar um modelo do comando de transformação.
Transform {
# comandos de transformação
...............
children [ # "Filhos" da Transformação
# aqui vão os Shapes que sofrerão as transformações
# definidas acima
# Entre os Shapes, coloque uma vírgula
]
} # fim do Transform
|
Os comandos de transformação são os seguintes:
É importante lembrar que as transformações geométricas, assim como as propriedades visuais, tem efeito apenas dentro do bloco Transform { ... } onde estão definidos. Além disto, estas transformações vale a partir da posição onde aparecem.
As transformações em VRML são sempre aplicadas na seguinte ordem: Rotação, Escala e Translação. Isto acontece mesmo que no fonte estas as transformações apareçam em outra ordem.
No exemplo a seguir pode-se observar a aplicação de transformações geométricas em 2 cubos
#VRML V2.0 utf8 # ------------------------------------------------------------- # Desenho de dois cubo com transformações geométricas # ------------------------------------------------------------- Transform {
translation 0 0 0
rotation 0 0 1 0.7853 # eixo e ângulo (em radianos) (1.57 = 90 graus)
scale 1 1 2
children [ # As transformações pode ter um ou mais "filhos"
Shape { # Estes "filhos" são Shapes ou outras transformações
appearance Appearance {
material Material { diffuseColor 1.0 0.0 0.0 }
}
geometry Box { size 5 5 5 }
}
]
}
Transform {
translation 10 0 0
scale 1 1 1
rotation 0 1 0 0.7 # eixo e ângulo (em radianos)
children [ # As transformações pode ter um ou mais "filhos"
Shape { # Estes "filhos" são Shapes ou outras transformações
appearance Appearance {
material Material { diffuseColor 0.0 1.0 0.0 }
}
geometry Box { size 5 5 5 }
}
]
}
|
Figura - Transformações Geométricas em Cubos
OBS: Clique aqui para carregar o objeto do exemplo
Para fazer uma transformação geométrica ser aplicada sobre outra já
existente deve-se colocar um bloco
Transform { } dentro do bloco children de outro Transform.
Note que em VRML o que muda em uma transformação geométrica é o sistema de
coordenadas, assim como em OpenGL.
No exemplo a seguir uma transformação de translação é aplicada sobre outra de rotação. Ao ser aplicada uma rotação de 90 gruas no eixo X, o eixo Z passa a apontar para baixo. Assim a translação aplicada a seguir no eixo Z faz o objeto descer.
#VRML V2.0 utf8 # ------------------------------------------------------------- # Desenho de dois cubos com transformações geométricas ANINHADAS # ------------------------------------------------------------- Transform {
scale 1 2 1
rotation 1 0 0 1.57079 # eixo e ângulo (em radianos) (1.57 = 90 graus)
children [ # >>>>>> CHILDREN 1
Transform {
translation 0 0 5 # Isto vai fazer o objeto BAIXAR !!!!
children [ # ****** CHILDREN 2
Shape {
appearance Appearance {
material Material { diffuseColor 1.0 0.0 0.0 }
}
geometry Box { size 5 5 5 }
} # Fim do Shape
] # ****** fim CHILDREN 2
} # fim do Transform
] # >>>>>>> fim do CHILDREN 1
}
Transform {
translation 10 0 0
scale 1 1 1
rotation 0 1 0 0.7 # eixo e ângulo (em radianos)
children [ # As transformações pode ter um ou mais "filhos"
Shape { # Estes "filhos" são Shapes ou outras transformações
appearance Appearance {
material Material { diffuseColor 0.0 1.0 0.0 }
}
geometry Box { size 5 5 5 }
}
]
}
|
OBS: Clique aqui para carregar o objeto do exemplo
Dentro do bloco Anchor coloque um objeto ou transformação e ainda a URL que será o destino do link.
O exemplo da figura a seguir cria um link para dois endereços diferentes, a partir de dois objetos distintos.
#VRML V2.0 utf8 # ------------------------------------------------------------- # Exemplo do uso de links # ------------------------------------------------------------- Anchor {
children [
Transform {
translation 0 0 0
children [ # As transformações pode ter um ou mais "filhos"
Shape { # Estes "filhos" são Shapes ou outras transformações
appearance Appearance {
material Material { diffuseColor 1.0 0.0 0.0 }
}
geometry Box { }
}
]
} # Fim do Transform
] # Fim do Children do Anchor
url ["Box.wrl"]
} # fim do Anchor
Anchor {
children [
Transform {
translation 5 0 0
scale 1 1 1
rotation 1 0 0 0.7853 # eixo e ângulo (em radianos)
children [ # As transformações pode ter um ou mais "filhos"
Shape { # Estes "filhos" são Shapes ou outras transformações
appearance Appearance {
material Material { diffuseColor 0.0 1.0 0.0 }
}
geometry Cylinder { }
}
]
} # Fim do Transform
] # Fim do Children do Anchor
url ["Cylinder.wrl"]
} # fim do Anchor
|
Figura - Exemplo de Link em VRML
OBS: Clique aqui para carregar o objeto do exemplo
#VRML V2.0 utf8 # ------------------------------------------------------------- # Exemplo de Inclusão de arquivos # ------------------------------------------------------------- Transform {
translation 0 0 0
rotation 0 0 1 0.7853 # eixo e ângulo (em radianos) (1.57 = 90 graus)
scale 1 1 2
children [ # As transformações pode ter um ou mais "filhos"
Inline {
url ["Box.wrl"]
}
]
}
Transform {
translation 10 0 0
scale 1 2 1
rotation 0 1 0 0.7 # eixo e ângulo (em radianos)
children [
Inline {
url ["Cylinder.wrl"]
}
]
}
|
Figura - Exemplo de INCLUDE em VRML
OBS: Clique aqui para carregar o objeto do exemplo
Em VRML 2 é possível posicionar o observador em alguma posição específica do espaço através do comando Viewpoint que possui os campos:
position x y z: que define a posição do observador;
orientation x y z ang: que define o eixo e o ângulo de rotação do observador;
fieldOfView ang: que define o ângulo de visão em radianos;
description " string": que define o nome deste ponto de visão. Este nome poderá ser usado na navegação com o browser.
Veja a seguir dois exemplos de pontos de vista.
#VRML V2.0 utf8 # -------------------------------------------------------- # Desenho de um paralelepípedo Amarelo # O Observador foi modificado para ficar ACIMA do objetos # Há duas posições definidas. Para nevegar entre elas use # o comando do Browser específico para navegação entre # Viewpoints # -------------------------------------------------------- Viewpoint {
position 0 3 15
orientation 0 0 1 0
fieldOfView 0.785398 # 90 graus em radianos
description "Ver de cima"
} # fim do Viewpoint
Viewpoint {
position 0 -3 15
orientation 0 0 1 0
fieldOfView 0.785398 # 90 graus em radianos
description "Ver de baixo"
} # fim do Viewpoint
Shape {
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 1.0 1.0 0.0 # r g b
}
}
geometry Box { }
} # fim do shape
|
OBS: Clique aqui para carregar o objeto do exemplo
Para colocar uma luz no cenário VRML usa-se o comando PointLight que permite especificar a localização, a cor da luz e a intensidade da luz. Em um mesmo arquivo VRML pode haver várias luzes.
A seguir observa-se um exemplo do uso de luzes
#VRML V2.0 utf8
# --------------------------------------------------------
# Exemplo de uso de luzes em VRML 2
# --------------------------------------------------------
PointLight {
location 0 10 0
color 1 0 0 # luz vermelha
intensity 1
}
PointLight {
location 10 0 0
color 0 1 0 # luz verde
intensity 1
}
Shape { # define um bloco de um obejto (Shape)
appearance Appearance { # define a aparência do Shape
material Material {
diffuseColor 0.5 0.5 0.0 # r g b
}
}
geometry Box { }
} # fim do shape
|
OBS: Clique aqui para carregar o objeto do exemplo
Um texto em VRML é um Shape, assim como um Box ou um Cone.
O comando para exibir textos é o Text. O comando Text possui campos para definir o texto em si, o comprimento e o estilo dos caracteres (fonte). Veja o o exemplo a seguir.
#VRML V2.0 utf8
# Exemplo de utilização do nó Text
Shape {
appearance Appearance {
material Material {
diffuseColor 1.0 0.0 0.3
}
}
geometry Text {
string [ "Isto eh um", # várias linhas de texto
"Exemplo de",
"texto em",
"VRML 2.0" ]
length [ 15, 15, 8, 10 ] # tamanho de cada linha
fontStyle FontStyle {
family "SERIF" # pode ser também SERIF e TYPEWRITER
style "ITALIC" # pode ser também BOLD
spacing 1.0 # espaço entre as linhas
size 2.0 # tamanho do fonte
justify "BEGIN" # pode ser também END e MIDDLE
} # fim do fontStyle
} # fim do geometry
}
Shape {
appearance Appearance {
material Material {
diffuseColor 0.0 1.0 0.0
}
}
geometry Box { }
}
|
OBS: Clique aqui para carregar o objeto do exemplo
--------------FIM--------------