[java] Problema con sfere (3d api)

[Skary]

Come da titolo mi son dedicato a spaciugare un pò con le java 3D api per capirne meglio il funzionamento.

Per ora ho fatto riferimento a questa guida http://www.redbaron85.com/corso-guida-java3d?start=30 e alla documentazione
Java 3D 1.4.0.

Come prova ho voluto prendere un esempio e modificarlo un pò , in particolare ho trovato quest'esempio che mi è piaciuto
http://www.redksr.com/~talos/JAVA/JA...l%20Java3D.pdf
(il link punta ad un tutorial al cui interno è presente il codice)
e l'ho modificato di modo che visualizzasse una texture come sfondo con una singola sfera al centro.

(Chiarisco che mi ha intrigato proprio quell'esempio perchè mostra come disegnare delle sfere e muovercisi intorno , settando opportunamente le luci , ed io volevo realizzare un modello del sistema solare)

Per i miei scopi ho costruito una classe (non del tutto completa , dato che manca la parte che regola le luci ... ma a quello ci penso dopo) per disegnare sfere in modo più semplice (raggruppa la calsse Sphere , Transform3D , texture , apparence e a breve anche la gestione delle luci (di modo da avere delle sfere adatte al mio obbiettivo e di facile costruzione)

Questo è il mio codice :

Classe principale con l'universo

import java.applet.Applet ;
import  com.sun.j3d.utils.universe.* ;
import  com.sun.j3d.utils.applet.MainFrame ;
import javax.media.j3d.* ;
import  javax.vecmath.* ;
import java.awt.* ;
import  com.sun.j3d.utils.behaviors.keyboard.KeyNavigatorBehavior ;

public  class Naviga extends Applet
{
    /**
     *
     */
     private static final long serialVersionUID = 1L;

    // crea  l’universo
    public void init()
    {
        
         setLayout(new BorderLayout()) ;
        GraphicsConfiguration config =  SimpleUniverse.getPreferredConfiguration() ;
        
         canvas = new Canvas3D(config) ;
        group = new BranchGroup() ;

         group.addChild(luce()) ;
        group.addChild(luce2()) ;
        
        Sfera mioSfondo = new Sfera(0.0f,0.0f,0.0f,1000,100,  "C:\\m45.jpg") ;
        mioSfondo.setTextured(true) ;
         mioSfondo.setNormalOriented(false) ;
        group.addChild(  mioSfondo.getSfera(TextureAttributes.MODULATE) ) ;
        
        
        universe = new SimpleUniverse(canvas) ;
         add("Center",canvas) ;
         universe.getViewingPlatform().setNominalViewingTransform() ;
        
         TransformGroup all =  universe.getViewingPlatform().getViewPlatformTransform() ;
        
         // abilita lo spostamento della telecamera (cioé di tutta la  scena...)
        KeyNavigatorBehavior keyNav = new  KeyNavigatorBehavior(all) ;
        keyNav.setSchedulingBounds(new  BoundingSphere(new Point3d(),1000.0)) ;

        
         group.addChild(keyNav) ;
        group.compile() ;
         universe.addBranchGraph(group) ;
        
    }
    
    //  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),1000.0)  ;
        Vector3f direzione = new Vector3f(-1.0f,-2.5f,-5.0f) ;
         DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione)  ;
        
        nuovaLuce.setInfluencingBounds(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),1000.0)  ;
        Vector3f direzione = new Vector3f(3.0f,-2.5f,-3.0f) ;
         DirectionalLight nuovaLuce = new DirectionalLight(colore,direzione)  ;
        
        nuovaLuce.setInfluencingBounds(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) ;
    }
}

Classe ausiliarla usata per creare sfere (chiamata appunto Sfera)

import java.applet.Applet ;
import javax.media.j3d.* ;
import javax.vecmath.* ;
import com.sun.j3d.utils.geometry.Sphere ;
import com.sun.j3d.utils.image.* ;


public class Sfera extends  Applet
{
    
    public final static int LUCE_DIREZIONALE = 0 ;
    public final static int LUCE_OMNIDIREZIONALE = 1 ;
    public final  static int LUCE_AMBIENTALE = 2 ;
    public final static int  LUCE_CONEIFORME = 4 ;
    public final static int LUCE_ASSENTE = 5 ;
    
    private float x = 0 ;
    private float y = 0 ;
    private float z = 0 ;
    
    private int r = 10 ;
    private  int sezioni = 4 ;
    private int luce = LUCE_ASSENTE ;
    
    private String nome = "Default_Name" ;
    
    private boolean  isTextured = false ;
    private boolean isMaterial = false ;
    private boolean isNormalOriented = true ;
    private String  texturePath ;
    
    private Material materiale = null ;
    

    
    private static final long serialVersionUID = 1L;
    
    public float getMyX() {
        return x;
    }

    public  void setX(float x) {
        this.x = x;
    }
    
     public float getMyY() {
        return y;
    }

    public  void setY(float y) {
        this.y = y;
    }

    public  float getMyZ() {
        return z;
    }

    public void  setZ(float z) {
        this.z = z;
    }

    public int  getR() {
        return r;
    }

    public void setR(int  r) {
        this.r = r;
    }

    public int getSezioni() {
         return sezioni;
    }
    
    public void setSezioni(int  sezioni) {
        this.sezioni = sezioni;
    }

    public  String getNome() {
        return nome;
    }

    public  void setNome(String nome) {
        this.nome = nome;
    }

     public boolean isTextured() {
        return isTextured;
    }

     public void setTextured(boolean isTextured) {
         this.isTextured = isTextured;
    }

    public String  getTexturePath() {
        return texturePath;
    }

     public void setTexturePath(String texturePath) {
         this.texturePath = texturePath;
    }

    public int getLuce()  {
        return luce;
    }

    public void setLuce(int  luce) {
        this.luce = luce;
    }

    public Material  getMateriale() {
        return materiale;
    }

     public void setMateriale(Material materiale) {
        this.materiale  = materiale;
    }

    public boolean isNormalOriented() {
         return isNormalOriented;
    }

    public void  setNormalOriented(boolean isNormalOriented) {
         this.isNormalOriented = isNormalOriented;
    }

    public  boolean isMaterial() {
        return isMaterial;
    }

     public void setMaterial(boolean isMaterial) {
         this.isMaterial = isMaterial;
    }

    public Sfera ( float  _x , float _y , float _z)
    {
        x = _x ;
        y = _y  ;
        z = _z ;
    }
    
    public Sfera ( float _x ,  float _y , float _z , int _r, int _sezioni)
    {
        x = _x ;
        y = _y ;
        z = _z ;
        r = _r ;
        sezioni  = _sezioni ;
    }
    
    public Sfera ( float _x , float _y  , float _z , int _r, int _sezioni, String _texturePath)
    {
        x = _x ;
        y = _y ;
        z = _z ;
        r = _r ;
        sezioni = _sezioni ;
        
        isTextured = true ;
        texturePath = _texturePath ;
    }
    
    public Sfera (  float _x , float _y , float _z , int _r, int _sezioni, Material  _materiale)
    {
        x = _x ;
        y = _y ;
        z  = _z ;
        r = _r ;
        sezioni = _sezioni ;
        
        isMaterial = true ;
        materiale = _materiale ;
    }
    
    public TransformGroup getSfera(int _textureAttr)
    {
        
        Sphere sfera = null ;
        Appearance apparenza =  new Appearance() ;
        
        if (isMaterial)
        {
             apparenza.setMaterial( materiale ) ;
        }
        
         if (isTextured)
        {
            
            Texture  texture = (new TextureLoader( texturePath ,this)).getTexture() ;
            apparenza.setTexture(texture) ;
            
             TextureAttributes tattr = new TextureAttributes() ;
             tattr.setTextureMode(_textureAttr) ;
             apparenza.setTextureAttributes(tattr) ;
            
             if (isNormalOriented)
            {
                sfera = new  Sphere( r ,Sphere.GENERATE_TEXTURE_COORDS, sezioni , apparenza) ;
                sfera.setAppearance(apparenza) ;
            }
             else
            {
                sfera = new Sphere( r  ,Sphere.GENERATE_TEXTURE_COORDS | Sphere.GENERATE_NORMALS_INWARD,  sezioni , apparenza) ;
                sfera.setAppearance(apparenza)  ;
            }
        }
        else
        {
             sfera = new Sphere( r , sezioni , apparenza) ;
             sfera.setAppearance( apparenza ) ;
        }
        
        Transform3D transf = new Transform3D() ;
        TransformGroup tg =  new TransformGroup() ;
        Vector3f posizione = new Vector3f( x ,  y , z ) ;
        transf.setTranslation(posizione) ;
        tg.setTransform(transf) ;
        tg.addChild(sfera) ;
        
         return tg ;
    }

}

Ora , al momento mi aspetterei almeno di vedere il mio sfondo nella prima guida che citavo e che uso come riferimento c'è scritto che è possibile usare come sfondo una sfera enorme , con una texture rivolta verso l'interno e che per rivolgere la texture all'interno bisogna usare l'attributo GENERATE_NORMALS_INWARD che è esattamente quello che uso io ... eppure io non vedo assolutamente nulla (solo lo sfondo nero ovunque) ... dunque che cosa stò sbagliando ?

Ps :
Io con Java non sono molto pratico , e proprio per questo che mi stò impratichendo , quindi se notate errori concettuali che esulano dal problema specifico non eistate a farmelo presente.

Grazie anticipatamente