Un breve tutorial

su
Java3D

Eugenio Polìto
 Copyright c 2003 Eugenio Polìto. All rights reserved.

This document is free; you can redistribute it and/or modify it under the terms of
the GNU General Public License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This document is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this
document; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA.

Sosteniamo la Cultura Libera:

sosteniamo il Free Software

Per la segnalazione di errori e suggerimenti, potete contattarmi ai seguenti

indirizzi:

Web: [Link]

E-Mail: eugeniopolito@[Link]
Indice
1 Cosa è Java3D 4

2 Installazione 4

3 Costruire gli oggetti 6

3.1 Modificare la posizione degli oggetti . . . . . . . . . . . . . . . . 8
3.2 Aggiungere la luce . . . . . . . . . . . . . . . . . . . . . . . . . 10
3.3 Materiali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

4 Texture 18

5 Spostamento nella scena 23

6 Interazione con AWT 29

Elenco delle figure
1 Esecuzione di Cubo . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Posizione degli assi cartesiani X,Y,Z. . . . . . . . . . . . . . . . . 8
3 Esecuzione di Cubo2 . . . . . . . . . . . . . . . . . . . . . . . . 10
4 Esecuzione di Sfera . . . . . . . . . . . . . . . . . . . . . . . . 14
5 Esecuzione di SferaMaterial . . . . . . . . . . . . . . . . . . . 17
6 Esecuzione di SferaTexture . . . . . . . . . . . . . . . . . . . 22
7 Esecuzione di Naviga. Usare i tasti freccia per spostarsi nel mondo. 28
8 Interazione fra Java3D ed AWT. . . . . . . . . . . . . . . . . . . 29
1 COSA È JAVA3D 4

1 Cosa è Java3D
Java3D è un pacchetto aggiuntivo per Java che consente di gestire la grafica 3D.
Le sue caratteristiche principali sono:

la capacità di operare su qualsiasi piattaforma hardware/software che abbia

una implementazione di Java3D: sono disponibili sia JDK (per sviluppare
programmi) sia JRE (per eseguire i programmi che fanno uso delle API
Java3D) per Linux, Windows, Solaris.

Java3D si basa sull’interfaccia software a disposizione sul sistema, infatti

fa uso sia di Direct3D che di OpenGL. Su Windows è possibile scegliere la
versione da installare che può far uso dell’una o dell’altra libreria. Su *nix,
ovviamente, è disponibile la versione che si basa sulle librerie OpenGL.

Questo breve tutorial introduce l’uso essenziale di alcune (minime) API che, co-
munque, possono essere utili per muovere i primi passi.
Si suppone ovviamente che il lettore sappia già programmare in Java.

2 Installazione
È necessario innanzitutto avere installato il JDK.
Se non si vuole programmare, basta eseguire il download del JRE, per poter es-
eguire i programmi scritti per Java3D sia a linea di comando, sia nel web browser.
Se invece si ha intenzione di programmare in Java3d è necessario scaricare l’SDK.
Bisogna quindi procurarsi il pacchetto, collegandosi al sito di Sun (l’URL è ripor-
tato in [3]).
Avendo i pacchetti, è sufficiente eseguirli (sono dei file binari su tutte le pi-
attaforme): la directory di destinazione dell’installazione sarà quella dove risiede
il nostro JDK o JRE.
Se si ha intenzione di installare Java3D su Linux, è consigliabile (per ragioni di
efficienza) configurare il kernel in modo da abilitare il supporto AGP e DRM:

spostarsi su Character devices;

selezionare y o m (a seconda se lo si vuole direttamente caricato nel kernel

o lo si vuole come modulo) su /dev/agpgart (AGP Support);

selezionare quindi il tipo di chipset che ha la motherboard;

selezionare la voce Direct Rendering Manager (XFree86 DRI Support);

scorrere giù e selezionare il tipo di chipset della scheda video;

2 INSTALLAZIONE 5

Ricompilare quindi il kernel.

Procuratevi le librerie Mesa3D da [Link].
Fatto ciò, è necessario abilitare il supporto per il rendering hardware di X Window:

aprire il file XF86Config (o XF86Config-4 nel caso di Xfree 4.1) che si

trova in /etc/X11;

aggiungere i moduli glx e dri in Section “Module”, scrivendo Load

“glx” e Load “dri”.

aggiungere le seguenti linee per abilitare dri ad ogni utente (diverso da

root):

Section ‘‘DRI’’
Mode 0666
EndSection

Avviate X Window.
Provate ad eseguire in xterm il programma glxinfo | head e guardate l’out-
put: se nella terza linea leggete direct rendering: Yes allora il supporto per
l’accelerazione 3D è abilitato, altrimenti consultate la Rete per avere maggiori
informazioni e date uno sguardo a [Link] .
3 COSTRUIRE GLI OGGETTI 6

3 Costruire gli oggetti

I passi per creare una scena sono molto semplici e li possiamo riassumere così:

creare l’universo virtuale che contiene la nostra scena;

posizionare la vista dell’osservatore in modo che veda l’oggetto;

creare la struttura che contiene il gruppo di oggetti;

aggiungere un oggetto;

compilare la scena (questo passo è opzionale, ma è bene eseguirlo per ren-

dere più efficiente, in termini di velocità di esecuzione, la gestione dell’uni-
verso);

aggiungere il gruppo di oggetti all’universo;

Vediamo allora come visualizzare un semplice cubo:
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].j3d.Canvas3D;
import [Link];
import [Link].*;

public class Cubo extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
group = creaCubo();
[Link]();
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link](group);
3 COSTRUIRE GLI OGGETTI 7

// crea un cubo e lo aggiunge al gruppo,

public BranchGroup creaCubo()
{
BranchGroup tmpgroup = new BranchGroup();
ColorCube cube = new ColorCube(0.5);
[Link](cube);
return tmpgroup;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
{
new MainFrame(new Cubo(),400,400);
}
}
Come potete notare, la classe estende la classe Applet in modo che possa essere
caricata in un web browser.
Comunque è possibile lanciare tale classe come applicazione da console: dopo
averla compilata javac [Link], lanciarla come applicazione java Cubo, si
otterrà così la seguente finestra:

Figura 1: Esecuzione di Cubo

Ovviamente la vista dell’osservatore è centrale e quindi vediamo solo la faccia

frontale rossa del cubo (cioé il cubo è posizionato nel centro dell’universo).
3 COSTRUIRE GLI OGGETTI 8

3.1 Modificare la posizione degli oggetti

Vediamo adesso come spostare gli oggetti dell’universo con le operazioni di traslazione
e rotazione.
Ogni oggetto nell’universo ha tre coordinate x,y,z; gli assi cartesiani X,Y,Z sono
così posti:
Y

sch
erm
o

Z X

Figura 2: Posizione degli assi cartesiani X,Y,Z.

La posizione degli assi è quella classica della “vite destrorsa”, inoltre l’unità
di misura usata nel riferimento è il metro.
A questo punto vediamo come è possibile modificare le posizioni di un oggetto,
attraverso la traslazione e la rotazione; è necessario usare le classi Transform3D
e TransformGroup nel seguente modo:

Transform3D transf = new Transform3D();

TransformGroup tg = new TransformGroup();

Vector3f posizioneFinale = new Vector3f(.0f,-.5f,.0f);

[Link](posizioneFinale);

[Link](transf);

[Link](oggetto);
In questo modo abbiamo traslato l’oggetto oggetto lungo l’asse Y in giù rispetto
allo schermo.
Per la rotazione possiamo usare i metodi rotX(...),rotY(...),rotZ(...) che vengono
richiamati su un oggetto di tipo Transform3D (nel nostro caso su transf).
Vediamo come traslare e ruotare il cubo dell’esempio precedente:
3 COSTRUIRE GLI OGGETTI 9

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link].j3d.Transform3D;
import [Link].j3d.Canvas3D;
import [Link].Vector3f;
import [Link];
import [Link].*;

public class Cubo2 extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
[Link](trasla());
[Link]();
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link](group);
}

// trasla il cubo
public TransformGroup trasla()
{
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();
/* setta la rotazione di 45 intorno all’asse Y:


l’angolo è espresso in radianti (pi greco/4) */

[Link]([Link] / 4);

// setta la traslazione
Vector3f posizione = new Vector3f(.0f,-0.5f,.0f);
[Link](posizione);
3 COSTRUIRE GLI OGGETTI 10

[Link](transf);
[Link](cube);
return tg;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;
private ColorCube cube = new ColorCube(0.3);

// main
public static void main(String args[])
{
new MainFrame(new Cubo2(),400,400);
}
}

Il risultato è il seguente:

Figura 3: Esecuzione di Cubo2

3.2 Aggiungere la luce

Negli esempi precedenti si è usato un cubo colorato. Proviamo adesso ad usare
una sfera e a posizionarla nell’universo:

import [Link];
import [Link].*;
import [Link];
import [Link].j3d.*;
3 COSTRUIRE GLI OGGETTI 11

import [Link];
import [Link].*;

public class Sfera extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
group = creaCubo();
[Link]();
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link](group);
}

// crea un cubo e lo aggiunge al gruppo,

public BranchGroup creaCubo()
{
BranchGroup tmpgroup = new BranchGroup();
Sphere sfera = new Sphere(0.5f);
[Link](sfera);
return tmpgroup;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
{
new MainFrame(new Sfera(),400,400);
}
}
3 COSTRUIRE GLI OGGETTI 12

Se compiliamo ed eseguaimo questo programma, vedremo solo lo sfondo nero

senza alcun oggetto; abbiamo bisogno di aggiungere una luce all’ambiente: per
fare questo creiamo un oggetto istanza della classe DirectionalLight , il cui
costruttore richiede semplicemente il colore della luce e la direzione, inoltre sta-
biliamo il raggio di azione della luce:

import [Link];
import [Link].*;
import [Link];
import [Link].j3d.*;
import [Link].*;
import [Link];
import [Link].*;

public class Sfera extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
[Link](creaSfera());
[Link](luce());
[Link](luce2());
[Link]();
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link](group);
}

// crea una sfera

public Sphere creaSfera()
{
Sphere sfera = new Sphere(0.5f);
return sfera;
}
3 COSTRUIRE GLI OGGETTI 13

// aggiunge la luce all’ambiente

public DirectionalLight luce()
{
// colore ’’azzurretto’’
Color3f colore = new Color3f(.1f,.6f,.6f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(-1.0f,-2.5f,-5.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// aggiunge una seconda luce all’ambiente

public DirectionalLight luce2()
{
// colore rosso
Color3f colore = new Color3f(1.0f,.0f,.0f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(3.0f,-2.5f,-3.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
{
new MainFrame(new Sfera(),400,400);
}
}
3 COSTRUIRE GLI OGGETTI 14

Il risultato è il seguente:

Figura 4: Esecuzione di Sfera

3.3 Materiali
Nell’esempio precedente, come si può vedere dalla figura 4, la luce che viene
riflessa dall’oggetto è quella che viene proiettata su di esso: questo succede perché
il materiale di default è bianco.
Per cambiare il materiale all’oggetto è sufficiente definire una nuova apparenza
(creando un oggetto di tipo Appearance), applicare il materiale che si vuole (cioé
si crea un oggetto di tipo Material) e si setta la nuova apparenza così ottenuta
all’oggetto, ovvero:
import [Link];
import [Link].*;
import [Link];
import [Link].j3d.*;
import [Link].*;
import [Link];
import [Link].*;

public class SferaMaterial extends Applet

{
// crea l’universo
public void init()
3 COSTRUIRE GLI OGGETTI 15

{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
[Link](creaSfera());
[Link](luce());
[Link](luce2());
[Link]();
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link](group);
}

// crea una sfera e setta un materiale blu

public Sphere creaSfera()
{
Sphere sfera = new Sphere(0.5f);
// Settiamo un materiale blu
Color3f blu = new Color3f(.0f,.0f,1.0f);
Color3f black = new Color3f(.0f,.0f,.0f);
Color3f white = new Color3f(1.0f,1.0f,1.0f);
Material material = new Material(blu,black,blu,white,90.0f);
Appearance app = new Appearance();
[Link](material);
[Link](app);
return sfera;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce()
{
Color3f colore = new Color3f(.1f,.6f,.6f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(-1.0f,-2.5f,-5.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
3 COSTRUIRE GLI OGGETTI 16

return nuovaLuce;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce2()
{
Color3f colore = new Color3f(1.0f,.0f,.0f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(3.0f,-2.5f,-3.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
{
new MainFrame(new SferaMaterial(),400,400);
}
}
3 COSTRUIRE GLI OGGETTI 17

Compilando ed eseguendo il programma si ottiene questo risultato:

Figura 5: Esecuzione di SferaMaterial

Notare che le luci sono le stesse dell’altro esempio.

Come si può vedere dal listato, il costruttore di Material accetta 5 argomenti:

Ambient color: è il colore riflesso dall’oggetto;

Emissive color: è il colore emesso dall’oggetto;

Diffuse color: è il colore dell’oggetto quando è illuminato;

Specular color: è il colore riflesso dall’oggetto in una particolare direzione, quan-

do è colpito da un fascio di luce;

Shininess: è l’indice di brillantezza dell’oggetto;

4 TEXTURE 18

4 Texture
Oltre all’aggiunta di un materiale ad un oggetto, è possibile aggiungere una tex-
ture cioé una immagine che riveste l’oggetto stesso.
Per fare questo è necessario usare la classe TextureLoader ed impostare la risolu-
zione delle immagini ad un multiplo di 2 (ex. 128 128, 128 256, etc.). Vedi-
 

amo un semplice esempio in cui applichiamo una texture ad una sfera:

import [Link];
import [Link].*;
import [Link];
import [Link].j3d.*;
import [Link].*;
import [Link];
import [Link];
import [Link].*;
import [Link].*;
import [Link];

public class SferaTexture extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
[Link](creaSfondo());
[Link](creaSfera());
[Link](creaCilindro());
[Link](creaPavimento());
[Link](luce());
[Link](luce2());
universe = new SimpleUniverse(canvas);
add("Center",canvas);
[Link]().setNominalViewingTransform();
[Link]();
[Link](group);
}
4 TEXTURE 19

// crea una sfera e setta una texture

public TransformGroup creaSfera()
{
Appearance app = new Appearance();
// carica la texture
Texture texture = (new TextureLoader("[Link]",
this)).getTexture();
[Link](texture);
TextureAttributes tattr = new TextureAttributes();
[Link]([Link]);
[Link](tattr);

// crea la sfera ed applica la texture

Sphere sfera = new Sphere(0.3f,Sphere.GENERATE_TEXTURE_COORDS,app);
[Link](app);
// posizioniamola alle coord. (0,0.5,0)
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();
Vector3f posizione = new Vector3f(.0f,0.5f,.0f);
[Link](posizione);
[Link](transf);
[Link](sfera);
return tg;
}

// crea un cilindro trasparente

public TransformGroup creaCilindro()
{
Appearance app = new Appearance();
// setta la trasparenza del cubo
TransparencyAttributes trasp =
new TransparencyAttributes([Link],
0.5f,
TransparencyAttributes.BLEND_SRC_ALPHA,
TransparencyAttributes.BLEND_ONE);
[Link](trasp);
Cylinder cilindro = new Cylinder(0.3f,0.8f,app);
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();
4 TEXTURE 20

// setta la traslazione
Vector3f posizione = new Vector3f(.0f,-0.2f,.0f);
[Link](posizione);
[Link](transf);
[Link](cilindro);
return tg;
}

// crea il pavimento
public TransformGroup creaPavimento()
{
Appearance app = new Appearance();
// carica la texture
Texture texture = (new TextureLoader("[Link]",
this)).getTexture();
[Link](texture);
TextureAttributes tattr = new TextureAttributes();
[Link]([Link]);
[Link](tattr);

Cylinder cilindro = new Cylinder(30.f,

0.1f,
Cylinder.GENERATE_TEXTURE_COORDS,
app);
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();

// setta la traslazione
Vector3f posizione = new Vector3f(.0f,-0.9f,.0f);
[Link](posizione);
[Link](transf);
[Link](cilindro);
return tg;
}

// crea uno sfondo blu

public Background creaSfondo()
{
Color3f bgColor = new Color3f(.0f,.0f,1.0f);
4 TEXTURE 21

Background bg = new Background(bgColor);

[Link](new BoundingSphere(new
Point3d(.0f,.0f,.0f),100.0));
return bg;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce()
{
Color3f colore = new Color3f(.1f,.6f,.6f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(-1.0f,-2.5f,-5.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce2()
{
Color3f colore = new Color3f(1.0f,.0f,.0f);
// la fonte di luce illumina per 2 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),2.0);
Vector3f direzione = new Vector3f(3.0f,-2.5f,-3.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
4 TEXTURE 22

{
new MainFrame(new SferaTexture(),400,400);
}
}

Per avvolgere un oggetto con una texture è sufficiente creare una nuova istanza di
TexureLoader e leggere la texture col metodo getTexture() che restituisce un
oggetto di tipo Texture.
Viene creato quindi un oggetto istanza di Appearance che viene settato con la
texture appena caricata. A questo punto è sufficiente definire un nuovo ogget-
to (nel nostro caso sfera), abilitando il flag GENERATE_TEXTURE_COORDS per la
generazione delle coordinate della texture, ed applicargli l’apparenza definita nel-
l’oggetto app.
Nel codice viene inoltre abilitato uno sfondo blu, attraverso la classe Background
e vengono creati due cilindri: uno trasparente è situato al di sotto della sfera e
l’altro, con una texture, è usato come pavimento.
Il risultato a run-time è il seguente:

Figura 6: Esecuzione di SferaTexture

5 SPOSTAMENTO NELLA SCENA 23

5 Spostamento nella scena

Risulta utile spostarsi nella scena creata: in Java3D lo spostamento con i tasti
freccia è possibile attraverso l’uso della classe KeyNavigatorBehavior .
Vediamo allora come spostarsi nell’universo con le frecce:

import [Link];
import [Link].*;
import [Link];
import [Link].j3d.*;
import [Link].*;
import [Link];
import [Link];
import [Link];
import [Link].*;
import [Link].*;
import [Link];

public class Naviga extends Applet

{
// crea l’universo
public void init()
{
setLayout(new BorderLayout());
GraphicsConfiguration config =
[Link]();
canvas = new Canvas3D(config);
group = new BranchGroup();
[Link](creaSfondo());
[Link](creaPavimento(.0f,-.9f,.0f));
[Link](creaPavimento(.0f,3.0f,.0f));
[Link](luce());
[Link](luce2());
float x = -10.0f;
float y = 2.0f;
float z = .0f;
// crea 20 "colonne" (...cilindro con sfera...)
for (int i=0; i < 20; i++)
{
[Link](creaSfera(x,y,z));
[Link](creaSfera(x+20.0f,y,z));
5 SPOSTAMENTO NELLA SCENA 24

[Link](creaCilindro(x,y-1.5f,z));
[Link](creaCilindro(x+20.0f,y-1.5f,z));
z -= 10.0f;
}

universe = new SimpleUniverse(canvas);

add("Center",canvas);
[Link]().setNominalViewingTransform();

TransformGroup all = [Link]().

getViewPlatformTransform();

// abilita lo spostamento della telecamera (cioé di tutta la scena...)

KeyNavigatorBehavior keyNav = new KeyNavigatorBehavior(all);
[Link](new BoundingSphere(new Point3d(),1000.0));
[Link](keyNav);

[Link]();
[Link](group);
}

// crea una sfera e setta una texture

public TransformGroup creaSfera(float x,float y,float z)
{
Appearance app = new Appearance();
// carica la texture
Texture texture = (new TextureLoader("[Link]",
this)).getTexture();
[Link](texture);
TextureAttributes tattr = new TextureAttributes();
[Link]([Link]);
[Link](tattr);

// crea la sfera ed applica la texture

Sphere sfera = new Sphere(0.5f,Sphere.GENERATE_TEXTURE_COORDS,app);
[Link](app);
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();
Vector3f posizione = new Vector3f(x,y,z);
[Link](posizione);
5 SPOSTAMENTO NELLA SCENA 25

[Link](transf);
[Link](sfera);
return tg;
}

// crea un cilindro con texture

public TransformGroup creaCilindro(float x,float y,float z)
{
Appearance app = new Appearance();
// carica la texture
Texture texture = (new TextureLoader("[Link]",
this)).getTexture();
[Link](texture);
TextureAttributes tattr = new TextureAttributes();
[Link]([Link]);
[Link](tattr);

Cylinder cilindro = new Cylinder(0.3f,

2.5f,
Cylinder.GENERATE_TEXTURE_COORDS,
app);
[Link](app);
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();

// setta la traslazione
Vector3f posizione = new Vector3f(x,y,z);
[Link](posizione);
[Link](transf);
[Link](cilindro);
return tg;
}

// crea un cilindro con texture (...usato come pavimento e soffitto)

public TransformGroup creaPavimento(float x,float y,float z)
{
Appearance app = new Appearance();
// carica la texture
Texture texture = (new TextureLoader("[Link]",
5 SPOSTAMENTO NELLA SCENA 26

this)).getTexture();
[Link](texture);
TextureAttributes tattr = new TextureAttributes();
[Link]([Link]);
[Link](tattr);

Box pavimento = new Box(30.0f,

0.1f,
240.f,
Box.GENERATE_TEXTURE_COORDS,
app);
Transform3D transf = new Transform3D();
TransformGroup tg = new TransformGroup();

// setta la traslazione
Vector3f posizione = new Vector3f(x,y,z);
[Link](posizione);
[Link](transf);
[Link](pavimento);
return tg;
}

// crea uno sfondo nero

public Background creaSfondo()
{
Color3f bgColor = new Color3f(.0f,.0f,.0f);
Background bg = new Background(bgColor);
[Link](new BoundingSphere(new Point3d(.0f,
.0f,
.0f),100.0));
return bg;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce()
{
Color3f colore = new Color3f(.1f,.6f,.6f);
// la fonte di luce illumina per 200 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),200.0);
5 SPOSTAMENTO NELLA SCENA 27

Vector3f direzione = new Vector3f(-1.0f,-2.5f,-5.0f);

DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// aggiunge la luce all’ambiente

public DirectionalLight luce2()
{
Color3f colore = new Color3f(1.0f,.0f,.0f);
// la fonte di luce illumina per 200 metri dall’origine
BoundingSphere raggio =
new BoundingSphere(new Point3d(.0,.0,.0),200.0);
Vector3f direzione = new Vector3f(3.0f,-2.5f,-3.0f);
DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione);
[Link](raggio);
return nuovaLuce;
}

// attributi
private SimpleUniverse universe;
private BranchGroup group;
private Canvas3D canvas;

// main
public static void main(String args[])
{
new MainFrame(new Naviga(),400,400);
}
}

Quindi è sufficiente aggiungere un oggetto istanza di KeyNavigatorBehavior

e passargli il TransformGroup che si vuole spostare con le frecce. Nel nostro
caso, tutta la scena viene passata al costruttore di KeyNavigator che abilita lo
spostamento della telecamera.
5 SPOSTAMENTO NELLA SCENA 28

Il risultato dell’esecuzione è il seguente:

Figura 7: Esecuzione di Naviga. Usare i tasti freccia per spostarsi nel mondo.
6 INTERAZIONE CON AWT 29

6 Interazione con AWT

Ovviamente è possibile inserire nel frame dell’applicazione (o applet), dei widget
di AWT.
Di seguito riporto un semplice esempio (il codice sorgente lo potete trovare sul
mio sito web):

Figura 8: Interazione fra Java3D ed AWT.

RIFERIMENTI BIBLIOGRAFICI 30

Riferimenti bibliografici
[1] Sun Microsystems, [Link]

[2] Sun Microsystems,

[Link]

[3] Sun Microsystems,

[Link]