MokaByte Numero 17 - Marzo 1998
		Interazione Java-Vrml
	di Ignazio Locatelli	Esempio complesso di programmazione Java-Vrml: controllo di un umano vrml

Premessa

 Negli ultimi sei mesi abbiamo discusso diffusamente sui diversi aspetti riguardanti l'interfacciamento tra Java e Vrml, ponendo l'attenzione soprattutto sull'utilizzo dell'interfaccia EAI (External Authoring Interface).
Abbiamo inizialmente visto come sia semplice fare interagire una applet Java con un mondo vrml. In particolare come sia possibile modificare alcune caratteristiche degli oggetti all'interno di una scena virtuale oppure recepire eventi generati dall'utente.
Nel corso delle nostre discussioni abbiamo anche analizzato diversi esempi, alcuni decisamente semplici, altri un po' più complicati. Avendo esaurito gli aspetti più importanti riguardanti l'interfacciamento Java-Vrml ho pensato di proseguire questo 'corso' fornendo degli esempi di utilizzo decisamente più complicati e interessanti.
Nella trattazione di tali esempi darò per scontate le nozioni spiegate nei precedenti articoli. Tenderò quindi a sorvolare su aspetti secondari e di dettaglio, cercando piuttosto di focalizzare l'attenzione sui particolari tecnici più rilevanti. Difficilmente commenterò il codice in tutte le sue parti, sia perchè gli esempi che seguiranno sono abbastanza corposi, sia perchè i dettagli implementativi più semplici dovrebbero già esservi noti.
Corrispondentemente mi aspetto pertanto un maggiore feedback da parte vostra per richieste di chiarimenti e delucidazioni (il che penso sia ovvio considerando progetti di dimensioni non piccole).
 

Simulazione di un umano all'interno di un ambiente virtuale vrml

 Questo titolo l'ho scritto parecchie volte negli ultimi mesi. Perchè? Semplice: è il titolo della tesi con la quale mi sono laureato meno di una settimana fa ;).

La spiegazione che seguirà non sarà minimamente esaustiva del progetto che ho implementato in sede di tesi, ma vuole essere solo uno spunto per mostrare come sia possibile inserire oggetti di forma umana in un mondo vrml.

L'inserimento di un oggetto di questo tipo richiede il superamento di una enorme quantità di problemi. In primo luogo si deve creare l'oggetto che rappresenta l'umano: questa è senz'altro la fase più semplice.
Una volta creato l'oggetto 3D che rappresenta il nostro umano, lo si deve animare. E qui cominciano i dolori! Non avete mai provato a far camminare un ometto 3D? Con movimenti creati a 'occhio' manualmente il risultato che otterrete non sarà certo quello di avere un umano che si muove in modo fluido e realistico. Tenete poi presente che un oggetto di forma umana è dotato di una grande quantità di giunti rotatori e che molti di essi presentano ben 3 gradi di libertà (possono cioè ruotare secondo 3 assi diversi: tornerò più tardi su questo aspetto). Quello che voglio dire è che è quasi impossibile creare a mano dei movimenti da associare ad un umano (ne ho fatti alcuni in questo modo, ma erano semplicissimi). Soprattutto, i risultati ottenuti seguendo questo procedimento sono il più delle volte poco realistici e forniscono all'utente un senso di innaturalezza.
Come fare allora? La soluzione ottima si chiama motion capture.
Per coloro che non hanno ben presente cosa sia uno strumento di motion capture, basti dire che si tratta di uno strumento che consente di catturare il movimento esgeuito da un performer reale all'interno di un volume sottoposto a controllo (attraverso tecniche magnetiche o ottiche). Personalmente ho utilizzato un sistema di tipo ottico (ELITE) reso disponibile dal centro di Bioingegneria, Fondazione Pro Joventute Don C. Gnocchi Milano e Politecnico di Milano.

Detto questo, il problema rimane. Non penso che molte delle persone che stanno leggendo in questo momento abbiano in camera una strumentazione per effettuare motion capture (attendo smentite ;) ).
Anche in considerazione di questo fatto, nel corso del progetto di tesi ho creato una opportuna libreria di movimenti da associare ad un umano. Tale libreria viene poi controllata da una libreria software scritta in Java che consente di controllare l'umano ad un alto livello di astrazione. L'utilizzatore dell'oggetto implementato può quindi controllare l'umano in modo del tutto trasparente, sfruttando i movimenti predefiniti.

Tornando a noi, l'esempio di oggi sfrutterà un semplice movimento che ho acquisito con uno strumento di motion capture: una semplice fase di cammino a regime (non considero cioè le problematiche relative al primo passo e al passo terminale: l'umano se si muove parte subito a regime). Le limitazioni che ho imposto sono mirate essenzialmente a mantenere semplice l'esempio (impresa alquanto ardua).

Quello che si vuole ottenere è pertanto un semplice oggetto di forma umana (sarà moooolto semplice) che si muove all'interno di un ambiente. I movimenti saranno controllati dall'utente attraverso un'applet Java. Per complicare un po' le cose cercheremo di implementare un minimo di collision detection in modo da evitare che l'umano attraversi eventuali ostacoli. Anche la collision detection dovrà essere risolta via Java in quanto Vrml prevede il calcolo delle collisioni solo tra gli oggetti e l'utente navigatore.

Sembra difficile? tutto sommato non così tanto.
 

Costruzione del modello 3D

 Come dicevo prima, questa risulta senz'altro la parte più semplice, anche se presenta alcuni aspetti di estrema importanza.

La costruzione del modello infatti non può prescindere dall'utilizzo che se ne farà successivamente. Dato che l'umano deve essere animato, risulta indispensabile strutturare il modello 3D in modo da rendere semplice questa operazione.

Un primo modo per costruire un oggetto di forma umana può essere quello di costruirlo come una unica lunga sequenza di poligoni.
Nulla di più sbagliato! Come imporre per esempio una rotazione al gomito? Andando a modificare direttamente le coordinate dei poligoni? In questo modo ci si complicherebbe estremamente la vita (anche se in realtà esistono opportune tecniche di animazione che sfruttano procedimenti simili, soprattutto per implementare animazione facciale).
La soluzione seguita è quella di definire l'oggetto come un insieme di segmenti rigidi connessi tra di loro attraverso dei giunti rotatori. Date un'occhiata alla seguente figura per capire meglio il discorso (anche se penso che la maggior parte di voi abbia già afferrato il concetto)

Osservando la figura qui sopra riportata, si può vedere come l'umano sia composto da un insieme di links (segmenti). Le connessioni tra i link avvengono attraverso opportuni giunti rotatori (idealmente di dimensione nulla). Il particolare modo con il quale i segmenti sono connessi definiscono una struttura ad albero, dove la radice è piazzata all'altezza del bacino dell'umano, mentre per esempio piedi, testa e mani sono nodi terminali. Una rotazione applicata ad un giunto si ripercuote su tutti i segmenti connessi a valle. Quindi ruotando il giunto al gomito si ottiene di far ruotare il segmento braccio, il giunto al polso e la mano. Una successiva rotazione al polso non modificherà l'orientamento del braccio, ma solo quello della mano. Se provate a fare qualche gesto davanti al monitor capirete perfettamente il funzionamento (ho effettuato questa operazione molte volte nell'ultimo anno, con gravi preoccupazioni per i genitori ;) ).

A questo punto si può capire perfettamente cosa intendevo quando parlavo di strutturare l'umano in modo da rendere semplice la successiva fase di animazione. Infatti, se si vuole portare l'intero arto superiore in una certa posizione basta semplicemente impostare i corretti valori di rotazione ai giunti relativi alla spalla, al gomito e al polso. Tali valori possono essere impostati a mano o, meglio, sfruttando dati provenienti da tecniche di motion capture.
Una animazione non è altro che un susseguirsi di diverse configurazioni e quindi basta applicare diversi valori nel tempo ai vari giunti di cui l'umano è fornito.

Cio' che è appena stato descritto è quello che viene comunemente chiamato catena cinematica aperta (chi di voi ha fatto qualcosina di robotica conosce perfettamente l'argomento; non escludo che venga affrontato anche in altri corsi comunque).
Come definire una catena cinematica in vrml? Risulta necessario un nodo che abbiamo imparato ad usare sin dal primo articolo: il nodo Transform.
Ricordo che tale nodo consente di traslare, ruotare o scalare tutto quanto è definito all'interno del proprio campo children.

Una catena cinematica può quindi essere ottenuta sfruttando l'innestamento di nodi Transform. Vediamo di dedicare un po' di tempo su questo argomento; senza capire a fondo il funzionamento della catena sarà impossibile comprendere la restante parte dell'articolo.

Supponiamo di avere il presente, banale, codice Vrml:
 
 

 

#VRML V2.0 utf8
 
 

Transform {

 translation 10 0 0

 rotation 1 0 0 1.57

 children [

  Shape {

   appearance Appearance {

    material Material { diffuseColor 1 0 0 }

   }

   geometry Cylinder {

    radius 1

    height 10

   }

  }

 ]

}
 

Vediamo velocemente cosa succede innestando nodi Transform.
 
 

 

#VRML V2.0 utf8
 
 

DEF GiuntoSpalla Transform {

 rotation 1 0 0 .5

 children [

  DEF Giunto Shape {

   appearance Appearance {

    material Material { diffuseColor 1 0 0 }

   }

   geometry Sphere { radius 1 }

  }

  DEF braccio1 Transform {

   translation 0 -.3 0

   children [

    Shape {

     appearance Appearance {

      material Material { diffuseColor 0 1 1 }

     }

     geometry Cylinder {

      radius .1

      height .6

     }

    }

    DEF GiuntoGomito Transform {

     translation 0 -.3 0

     rotation 1 0 0 .4

     children [

      USE Giunto

      DEF braccio2 Transform {

      # qui definisco la restante parte del braccio e proseguo con

      # polso e mano
 
 
 

A questo punto, supponiamo di impartire una rotazione al nodo Transform denominato GiuntoGomito. Questa rotazione non influenza il nodo 'braccio1' in quanto è al di fuori del campo children di GiuntoGomito. Ne segue che la rotazione si ripercuote soltanto sulla parte terminale del braccio (dal gomito alla mano). La figura seguente mostra con esattezza la situazione.

La costruzione del modello dovrebbe essere a questo punto estremamente chiara e semplice.
Si parte dal giunto alla lombare (posizionato all'altezza del bacino) e lo si prende come radice della catena cinematica. Dalla radice partono 3 diverse sotto-catene:

• quella verso la spina dorsale, la quale presenterà ulteriori sotto-catene verso gli arti superiori
• quella verso l'arto inferiore sinistro
• quella verso l'arto inferiore destro

Prima di abbandonare la trattazione relativa alla creazione del modello, dobbiamo fare attenzione ad un particolare. Non tutti i giunti sono identici. Prendiamo per esempio il giunto alla spalla e quelo al gomito. La spalla può ruotare attorno a 3 diversi assi, mentre il gomito sostanzialmente può ruotare soltanto in un modo.
La spalla è dotata di 3 gradi di libertà, mentre il gomito ne ha soltanto uno. Questo si ripercuote sulla struttura del modello. Il giunto alla spalla si trasforma pertanto nel seguente modo:
 
 

 

DEF GiuntoSpalla_x Transform {

  rotation ...

  children [

    DEF GiuntoSpalla_z Transform {

      rotation ...

      children [

        DEF GiuntoSpalla_y Transform {

          rotation ...

          children [

            # qui si mette l'oggetto che costituisce il giunto

            # e la catena prosegue normalmente
 

Infine, vorrei che fosse estremamente chiara una cosa: l'innestamento è fondamentale per gestire l'animazione in quanto tutte le parti del corpo risultano strettamente legate fra di loro. Vogliamo traslare l'umano? basterà traslare solo la radice della catena cinematica: tutto il resto la seguirà coerentemente. Ruotiamo il giunto alla spalla? Tutto il braccio si solleverà coerentemente, senza doverci occupare del posizionamento finale della mano; la sua posizione viene determinata precisamente dalle rotazioni imposte a monte (cinematica diretta).
 

Animiamo il tutto

 Definito il modello, non resta che animarlo. Il problema più grosso risiede nel ricavare i dati necessari all'animazione.
Tali dati ovviamente saranno i valori di rotazione da associare ai singoli giunti durante il moto. Si dovranno superare anche diversi problemi relativi alla compatibilità dei dati provenienti da sedute di motion capture con il modello delle rotazioni da noi seguito.

Ad ogni modo, nell'esempio che seguirà i dati presenti saranno già idonei ad essere applicati al semplice modello creato. Inoltre, se provate a creare dei movimenti ad hoc, per esempio sfruttando solo alcuni dei gradi di libertà implementati, non avrete problemi di elaborazione e vi limiterete essenzialmente alle sole rotazioni rispetto all'asse x (movimenti sagittali).

Avendo a disposizione le tabelle dei movimenti (per esempio, prima di acquisire movimenti attraverso strumenti di motion capture ho trovato la tabella dei movimenti relativi al cammino su un libro di biomeccanica del Winter) è possibile applicare i valori di rotazione attraverso dei semplici interpolatori.

Per quanto riguarda le basi di animazione in vrml vi rimando al terzo articolo di questa serie (che troverete sia sul sito mokabyte che presso il gruppo VRML DREAMERS: http://www.lucia.it/vrml sotto la categoria tutorials).
In quell'articolo analizzo il funzionamento dei sensori di tempo, degli interpolatori e del comando ROUTE. Questi aspetti vengono ora dati per scontati.

L'animazione dell'umano è abbastanza semplice, una volta che si ha a disposizione i dati di rotazione necessari. Basta inserire tali valori all'interno di opportuni interpolatori di orientamento e collegare i loro eventi in uscita con il corrispondente campo rotation del giunto. E' importante notare che sarà necessario definire un interpolatore di orientamento PER OGNI giunto di cui l'umano è dotato.
Tutti gli interpolatori saranno governati dal medesimo sensore di tempo (e quindi ricevono lo stesso evento fraction_changed) e tutti emetteranno nello stesso istante (teoricamente) i corretti valori di rotazione. In un certo istante i valori emessi dagli interpolatori definiscono pertanto una posizione intermedia attraverso la quale l'umano deve passare.

Qui di seguito riporto un esempio relativo ad un solo giunto.
 
 

 

#sensore di tempo che regola tutti gli interpolatori

DEF time_walk TimeSensor {

 cycleInterval 2

 enabled TRUE

 loop TRUE

 startTime 1

}
 
 

DEF Interp_Spalla_Destra_x OrientationInterpolator {

 key[0.00000 0.02564 0.05128 0.07692 0.10256

       0.12821 0.15385 0.17949 0.20513 0.23077

       0.25641 0.28205 0.30769 0.33333 0.35897

       0.38462 0.41026 0.43590 0.46154 0.48718

       0.51282 0.53846 0.56410 0.58974 0.61538

       0.64103 0.66667 0.69231 0.71795 0.74359

       0.76923 0.79487 0.82051 0.84615 0.87179

       0.89744 0.92308 0.94872 0.97436 1.00000

       ]

keyValue[

        1 0 0 0.47430, 1 0 0 0.49120,

1 0 0 0.49750, 1 0 0 0.49450, 1 0 0 0.48230,

1 0 0 0.46060, 1 0 0 0.42650, 1 0 0 0.37600,

1 0 0 0.30700, 1 0 0 0.22770, 1 0 0 0.14860,

1 0 0 0.07370, 1 0 0 -0.00320, 1 0 0 -0.08810,

1 0 0 -0.17630, 1 0 0 -0.25670, 1 0 0 -0.32050,

1 0 0 -0.37050, 1 0 0 -0.41220, 1 0 0 -0.44710,

        1 0 0 -0.47050, 1 0 0 -0.47780, 1 0 0 -0.47290,

        1 0 0 -0.42650, 1 0 0 -0.38750, 1 0 0 -0.34740, 1 0 0 -0.30510,

1 0 0 -0.26010, 1 0 0 -0.21240, 1 0 0 -0.16210,

1 0 0 -0.10930, 1 0 0 -0.05370, 1 0 0 0.00490,

1 0 0 0.06740, 1 0 0 0.13490, 1 0 0 0.20620,

1 0 0 0.27710, 1 0 0 0.34280, 1 0 0 0.39960,

        1 0 0 0.44420

]

}
 
 

ROUTE time_walk.fraction_changed TO Interp_Spalla_Destra_x.set_fraction

ROUTE Interp_Spalla_Destra_x.value_changed TO SpallaDestra_x.set_rotation
 

Il tutto sembra quindi relativamente abbastanza banale.

Qui di seguito riporto una semplice demo di Frank (Frank è il nome dell'umano che ho implementato in sede di tesi). Si tratta di una demo molto semplice e priva di interazione e controllo da parte di Java (quindi un Frank senza cervello ;) ). In questa demo l'umano esegue un perfetto calcio di rigore con tanto di palla sotto il sette (per attivare l'animazione basta cliccare su Frank). La struttura dell'umano e la tecnica di animazione segue il modello descritto in questo documento. E' stato inserito un po' di codice Javascript per coordinare il movimento della palla con quello dell'umano. Questa demo serve solo per dare una idea di quello che si può ottenere. Procederemo tra poco a realizzare un semplice mondo con un umano da controllare via Java.

Controllo di un semplice umano

 Abbiamo tutti gli strumenti per procedere alla creazione di un semplice mondo nel quale inserire un oggetto di forma umana controllabile da applet Java.
Cominciamo con il modello 3D. Le esigenze di spazio e semplicità mi hanno suggerito di creare un oggetto molto schematico. I segmenti vengono rappresentati con dei cilindri, mentre i giunti sono identificati da opportune sfere. Le leggere differenze tra questo modello e Frank portano a piccole imperfezioni nel movimento di cammino. Il risultato ottenuto è comunque più che accettabile.

Qui di seguito riporto il solo oggetto implementato (statico); come potrete notare ho seguito strettamente il modello implementativo suggerito nel corso del presente articolo. Per analizzare il codice basta selezionare l'opportuna opzione del vostro browser html a file vrml caricato.

Una volta definito il modello 3D, ho inserito nel sorgente vrml tutta la parte relativa agli interpolatori di orientamento dei giunti. Il modello è fornito di 22 gradi di libertà e quindi saranno necessari ben 22 interpolatori. In pratica non si fa altro che ripetere per 22 volte quanto visto in precedenza per la spalla. (è inutile che riporti qui il relativo sorgente: se vi interessa non fate altro che visualizzarlo dal browser html dopo avere caricato il file vrml).

A questo punto possiamo iniziare a considerare la parte di controllo, sicuramente la più interessante.

Come dicevo in precedenza, il movimento associato all'umano è un semplice cammino a regime. In un certo istante, o è fermo oppure sta camminando. Inizialmente il modello deve essere fermo.
L'utente avrà a disposizione i seguenti controlli:

• pulsante Walk per attivare la fase di cammino
• pulsante Rotate Right per far ruotare il modello verso destra
• pulsante Rotate Left per far ruotare il modello verso sinistra
• TextField per specificare la distanza da coprire per ogni azione di walk
• TextField per specificare l'ammontare di rotazione per ogni azione di Rotate

Ruotare l'umano

 La rotazione è molto semplice. Si tratta essenzialmente di un cambio di orientamento effettuato attorno ad un asse verticale. Basta quindi acquisire il riferimento al campo Transform più esterno (quello della radice in sostanza) per ruotare tutta la catena.

L'applet Java acquisisce tale riferimento e all'interno del metodo action provvede a settare la rotazione di questo campo. Questo direi che è estremamente banale.
 

Camminare

 Attivare un movimento di cammino è leggermente più complicato.

Serve un sensore di tempo per controllare gli interpolatori deputati a impostare i valori di rotazione dei singoli giunti.
Inoltre il movimento deve essere ciclato più volte (i dati di motion capture si riferiscono solo ad un doppio passo).
Dato che inizialmente l'umano è fermo, il sensore di tempo avrà il campo enabled impostato a FALSE; sarà l'applet Java ad impostare a TRUE tale campo quando è necessario.

All'interno del metodo action basterebbe quindi recepire l'evento della pressione del pulsante 'Walk' e settare a TRUE tale campo. In realtà esiste un altro aspetto fondamentale: solitamente un umano quando cammina vuole anche spostarsi ;). Si deve cioè gestire una traslazione dell'oggetto. Si è deciso di far camminare l'umano lungo la direzione verso la quale è correntemente rivolto (soluzione più naturale).

C'è però un problema. La direzione del moto dipende dall'orientamento imposto dall'utente (attraverso i pulsanti di rotazione) e quindi non è possibile cablare all'interno del sorgente vrml il percorso che l'umano deve seguire. Non possiamo quindi creare un interpolatore di posizione con i dati relativi al percorso da seguire.

Questo problema può essere risolto in diversi modi. La tecnica seguita è stata la seguente. Ho creato un nodo TimeSensor con il campo enabled impostato inizialmente a FALSE, il campo LOOP a FALSE e i restanti nodi non specificati.

Quando giunge un evento AWT in conseguenza della pressione del pulsante 'Walk' vengono effettuate le seguenti operazioni:

• Si pone a TRUE il campo enabled di un sensore di tempo utilizzato solo come generatore di eventi isActive (ricordo che un TimeSensor emette un evento isActive TRUE non appena inizia a funzionare). Il perchè si utilizza questo sensore di appoggio sarà chiaro tra un attimo
• Si sfrutta l'evento isActive generato dal sensore di tempo in modo da recepire il timestamp dell'evento. All'interno del metodo callback (vedere terzo articolo) si recepisce l'evento isActive e in risposta si settano i campi startTime del sensore di tempo che regola gli intepolatori dei giunti e quello relativo alla traslazione dell'umano (il valore da passare a tali campi è quello relativo al timestamp corrente). Successivamente si pongono a TRUE i campi enabled degli stessi sensori di tempo. Queste operazioni attivano di fatto il movimento di Walk.
• Si catturano gli eventi fraction_changed generati dal sensore di tempo relativo alla traslazione. All'interno del metodo callback si genera la nuova posizione da assegnare all'umano. Questa viene poi applicata al campo translation associato alla radice.

In sede di calcolo della nuova posizione si procede ad inserire un controllo sugli ostacoli presenti nella scena (semplici Box). Il procedimento seguito è molto semplice e consiste nel confrontare le coordinate x,z dell'umano con il contorno degli oggetti. Se vi sforzate appena un attimo troverete metodi più efficienti.

I restanti dettagli non vengono qui analizzati (sia perchè il lettore interessato dovrà provarli direttamente sul campo, sia perchè il discorso potrebbe diventare altamente noioso per coloro che non hanno la minima intenzione di piazzare un umano all'interno di un mondo vrml).

Il risultato finale direi che è più che decente, anche se la stilizzazione dell'umano pesa molto dal punto di vista del realismo. L'aspetto fisico è comunque la parte meno interessante dal punto di vista programmativo e certamente la più semplice da curare e migliorare.

Attenzione: tutto funziona correttamente con Cosmo Player 1.0. Come vi dicevo la scorsa volta, sarebbe bene utilizzare ora Cosmo Player 2.0. Per questo esempio (come per molti altri) presenta un problema che definire incomprensibile è poco. In conseguenza della pressione del pulsante Walk, l'umano sta fermo e si mette a camminare SOLO se l'utente effettua un piccolo movimento all'interno della scena. Non aggiorna cioè la scena vrml sino a quando l'utente non vi clicca sopra spostandosi leggermente. La cosa sembra (ed è) assurda (pensando appunto che forse sarebbe bene testare i prodotti prima di metterli in circolazione). Con Cosmo Player 1.0 funziona tutto correttamente (la versione 1.0 ha i suoi bei bachi da altre parti ;) ).

Per quanti di voi sono interessati al sorgente Java: Sorgente

Prima di chiudere questo articolo vi lascio un paio di avvisi da parte del gruppo Vrml Dreamers. E' in corso la seconda edizione della gara italiana di mondi vrml. E' il secondo esperimento di questo tipo che cerchiamo di condurre e siamo convinti che le varie edizioni andranno via via migliorando, sia a livello di partecipazione che di contenuti. Per questa seconda edizione sono attesi mondi molto interessanti. Vi invito tutti a partecipare (magari sperando che il presente corso vi abbia aiutato in sede di creazione del mondo che presentate); vi ricordo che non è necessario presentare opere spettacolari. Allo stato attuale il risultato principale della gara (che tra le altre cose non offre premi, se non un riconoscimento particolare al mondo all'interno del nostro sito) è quello di creare un punto di incontro tra quanti sviluppano vrml in Italia: e in tal senso qualunque contributo sarà accettato con estremo entusiasmo da parte nostra.
Il termine ultimo per la presentazione dei mondi vrml è il 30 aprile; seguiranno tre settimane di votazioni via email (per cui vi aspetto quantomeno come votanti). Per ulteriori informazioni potete rivolgervi al sito VRML DREAMERS (http://www.lucia.it/vrml) o inviare email a joust-drs@logicom.it
 

Osservazioni conclusive

 Concludendo, sono pienamento conscio del fatto che in più punti sono stato forse un po' conciso; del resto non era possibile appesantire oltre l'articolo. Spero comunque che rimanga quantomeno la metodologia da seguire per la creazione di oggetti vrml di questo tipo e la consapevolezza che sfruttando in modo opportuno java e vrml si possano ottenere risultati che vanno ben al di là di quattro muri che raffigurano un'opera architettonica virtuale (utilizzo principale di vrml in Italia allo stato attuale). Come avrete notato in tutti gli articoli sino ad ora riportati ho sempre posto l'accento sulle capacità di interazione con l'utente, di animazione e creazione di comportamenti. Un mondo vrml deve rendere veramente partecipe l'utente, lo deve affascinare e magari stupire con effetti imprevedibili. Realtà virtuale non significa ficcarsi un casco in testa e un guanto sulla mano; tantomeno significa convertire un modello da autocad a vrml e navigarlo. L'utente deve essere stimolato in continuazione dall'ambiente, deve poter interagire con esso e affinchè ciò avvenga è necessario che gli oggetti all'interno del mondo siano dotati di propri comportamenti più o meno intelligenti. In questo senso le potenzialità offerte da Java e Vrml sono ancora tutte da scoprire. Sicuramente non le scoprirete con questo mini-corso: ma da qualche parte si deve pur iniziare no?

Commenti e richieste di chiarimento a: ignazio@logicom.it
 
 

	MokaByte rivista web su Java MokaByte ricerca nuovi collaboratori Chi volesse mettersi in contatto con noi può farlo scrivendo a mokainfo@mokabyte.it