# Java3D - Textur aufs innere einer Sphere mappen



## Hikku (31. Mai 2012)

Hallo liebe Javafreunde,

ich bin Frischling bezüglich der Java3D-Materie und erhoffe mir einige Denkanstöße hier zu erhalten.
Mein Ziel besteht darin, eine Textur auf das innere einer Sphere zu mappen. Mein Gedankengang war es, ein eigenes Universum zu erzeugen, bei welchem ich die Position des Beobachters genau in den Mittelpunkt der Sphere setze. Von dort aus, sollte der Beobachter die innere Schicht der Sphere sehen können. Wie schaffe ich es nun eine Textur auf diese innere Wand zu mappen? Habe genug Tutorials und Beispiele gesehen bezüglich Mapping, doch halt nur auf die Äussere Schicht von Geometrien.

Danke im voraus!


----------



## Marco13 (31. Mai 2012)

Es gibt erstmal nicht direkt eine "innere Schicht" - es gibt nur EINE, und das ist sowohl die innere als auch die äußere  Was es aber gibt, sind zwei _Seiten_ dieser Schicht. Und wenn man IN einer Kugel steht, kann es gut sein, dass man die Kugel gar nicht sieht - als wäre sie nicht da. Da muss man doppelseitiges Rendern einschalten. Du kannst mal mit den Stichworten aus diesem Snippet weitersuchen / probieren:

```
PolygonAttributes polyAttrib = new PolygonAttributes();
polyAttrib.setCullFace(PolygonAttributes.CULL_NONE);
polyAttrib.setBackFaceNormalFlip(true);
appearanceForSphere.setPolygonAttributes(polyAttrib);
```

BTW: Ich bin mir nicht sicher, ob die Strategie die "übliche" ist - normalerweise verwendet man für sowas eine Cube Map, und da gibt's teilweise recht spezielle Funktionen dafür, aber bezüglich Java3D bin ich da nicht so auf dem neuesten Stand ... habe auf die Schnelle nur sowas wie TextureCubeMap (Java 3D 1.3.2) gefunden, kann es gerade aber nicht einordnen und weiß nicht auswendig, wie man es verwendet, aber... ist vielleicht nicht so wichtig, wenn du mit der Sphere den gewünschten Effekt erreichst.


----------



## vanny (31. Mai 2012)

Ich hab noch nie mit JAVA3D gearbeitet, komme aber aus der 3D-Modlerecke und kann dein Problem daher nachvollziehen.
Wie Marco schon richtig gesagt hat, gibt es verschiedene Arten mit Texturen zu arbeiten.
Ich würde aber von der Strategie, beide seiten zu mappen abraten, schlichtweg aus performance Gründen.
Mapst du nur eine Seite, so ist immer nur die im Renderresultat sichtbar, in die die Normale zeigt.
Die rudimentärste Lösung deines Problems ist es also, die Normalen deiner Polygone zu flippen.
(Soweit ich das ersehen kann, wird das in Marcos Beispiel sogar gemacht *ist nur geraten also nich haun ^^*).
Welches Mapping du dann verwendest, sollte jedoch keine Rolle für die Sichtbarkeit spielen sondern nur für die Art und Weise, wie die Textur auf deinem "Objekt" angeordnet wird.
Bei einer Sphere ist ist das QubeMapping vielleicht nicht die beste Wahl, wobei Java3D-abhängig und da hab ich keinen Schimmer ^^.
Es bietet sich halt immer an, ein Mapping zu nutzen, welches möglichst nah an der Geometrie des Objektes ist. Sollte es in Java3D eine Art KugelMapping geben, nimmste natürlich das und im Zweifel geht UVW-Mapping immer :toll:

Gruß Vanny


----------



## Hikku (13. Jun 2012)

moin jungs,

verzeiht die verspätete Antwort, doch muss die Benachrichtigungsmail im Junk Ordner gelandet sein 


@Marco13: dein Tipp hat irgendwie hingehauen.












Habe nun das Problem, dass auf jeder Seite, die geladene Texture 8x geladen wird. Woran könnt das liegen?




```
package examples;

import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.behaviors.mouse.MouseBehavior;
import com.sun.j3d.utils.behaviors.vp.*;
import com.sun.j3d.utils.image.*;
import javax.swing.JFrame;


public class TextureExample extends JFrame
{


  //Der Canvas, auf den gezeichnet wird.
  public Canvas3D myCanvas3D;



  public TextureExample()
  {
    //Mechanismus zum Schliessen des Fensters und beenden des Programms
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);


    //Standardeinstellung fuer das Betrachteruniversum
    myCanvas3D = new Canvas3D(SimpleUniverse.getPreferredConfiguration());


    //Aufbau des SimpleUniverse:
    //Zuerst Erzeugen zusammen mit dem Canvas
    SimpleUniverse simpUniv = new SimpleUniverse(myCanvas3D);


    //Standardpositionierung des Betrachters
    simpUniv.getViewingPlatform().setNominalViewingTransform();


    //Die Szene wird in dieser Methode erzeugt.
    createSceneGraph(simpUniv);


    //Hinzufuegen von Licht
    addLight(simpUniv);


    //Hierdurch kann man mit der Maus den Betrachterstandpunkt veraendern
    OrbitBehavior ob = new OrbitBehavior(myCanvas3D);
    ob.setSchedulingBounds(new BoundingSphere(new Point3d(0.0,0.0,0.0),Double.MAX_VALUE));
    simpUniv.getViewingPlatform().setViewPlatformBehavior(ob);
    
  

    //Darstellung des Canvas/Fensters:
    setTitle("Textur auf Sphere");
    setSize(1000,1000);
    getContentPane().add("Center", myCanvas3D);
    setVisible(true);


  }




  public static void main(String[] args)
  {
     TextureExample texam = new TextureExample();
  }





  //In dieser Methode werden die Objekte der Szene aufgebaut und dem
  //SimpleUniverse su hinzugefuegt.
  public void createSceneGraph(SimpleUniverse su)
  {

    //Laden der Textur
    Texture textureLoad = new TextureLoader("C:/Workspace/SphereSim/bin/examples/myPicture.gif",null).getTexture();
    textureLoad.setBoundaryModeT(Texture.WRAP);
    //textureLoad.setBoundaryModeS(Texture.CLAMP_TO_EDGE);
    //Erzeugung eines skalierten Bildes aus der Textur. Hoehe und Breite
    //muessen Zweierpotenzen sein.
    //ImageComponent2D textureIm = textureLoad.getScaledImage(64,512);

    //Erzeugung der Textur
    //Texture2D aTexture = new Texture2D(Texture2D.BASE_LEVEL,Texture2D.RGB,
    //                                        textureIm.getWidth(),
    //                                        textureIm.getHeight());
    //aTexture.setImage(0,textureIm);

    //Eine Appearance, die die Textur verwendet.
    Appearance textureApp = new Appearance();
    textureApp.setTexture(textureLoad);
    
    TextureAttributes textureAttr = new TextureAttributes();
    textureAttr.setTextureMode(TextureAttributes.REPLACE); // MODULATE, DECAL, BLEND, REPLACE, or COMBINE 
    textureApp.setTextureAttributes(textureAttr);
    Material mat = new Material();
    mat.setShininess(40.0f);
    textureApp.setMaterial(mat);
    TexCoordGeneration tcg = new TexCoordGeneration(TexCoordGeneration.OBJECT_LINEAR,
                                                    TexCoordGeneration.TEXTURE_COORDINATE_2);

    textureApp.setTexCoordGeneration(tcg);


    //Ein Objekt (Kugel), das die Appearance, d.h. die Texture verwendet.
    Sphere tSphere = new Sphere(1.0f, Sphere.GENERATE_NORMALS |
            Sphere.GENERATE_NORMALS_INWARD |
            Sphere.GENERATE_TEXTURE_COORDS |
            Sphere.GENERATE_TEXTURE_COORDS_Y_UP, 45,textureApp);
    
    
    //stolen from http://www.java.net/node/689498
    PolygonAttributes pa = new PolygonAttributes( PolygonAttributes.POLYGON_FILL,
    		PolygonAttributes.CULL_FRONT, 0.01f );
    pa.setCullFace(PolygonAttributes.CULL_NONE);
    pa.setBackFaceNormalFlip(true);
    		Color3f c = new Color3f(new Color3f( 0.0f, 0.0f, 0.8f ));
    		Material m = new Material(c, c, c, c, 64.0f);
   textureApp.setPolygonAttributes(pa);
    //Die TRansformationsgruppe fuer die Kugel
    Transform3D t3d = new Transform3D();
    t3d.setScale(1.0f);
    
    //t3d.
    TransformGroup tgSphere = new TransformGroup(t3d);
    tgSphere.addChild(tSphere);

    //Fuege alles zur Szene hinzu.
    BranchGroup theScene = new BranchGroup();
    theScene.addChild(tgSphere);

    
    theScene.compile();

    //Hinzufuegen der Szene
    su.addBranchGraph(theScene);
    
   

  }
  
  //Hier wird etwas Licht zu der Szene hinzugefuegt.
  public void addLight(SimpleUniverse su)
  {

    BranchGroup bgLight = new BranchGroup();

    BoundingSphere bounds = new BoundingSphere(new Point3d(0.0,0.0,0.0), Double.MAX_VALUE);
    Color3f lightColour1 = new Color3f(1.0f,1.0f,1.0f);
    Vector3f lightDir1  = new Vector3f(0.2f,-0.1f,-1.0f);
    DirectionalLight light1 = new DirectionalLight(lightColour1, lightDir1);
    light1.setInfluencingBounds(bounds);

    bgLight.addChild(light1);


    su.addBranchGraph(bgLight);

  }


}
```


----------



## Marco13 (13. Jun 2012)

Hilft die allgemeine Information, dass da die Texturkoordinaten nicht passen? 

Man kann versuchen, die TexCoordGeneration anzupassen, aber wie man die verwendet bzw. was man da bei den Plane equations übergeben müßte, müßte ich auch erst durch Rumprobieren erschließen.

Etwas einfacher aber ggf. auch hakeliker könnte sein, sich von der Sphere die Shape3D und von der Shape3D die Geometry zu holen, dann zu schauen, welchen Typ die hat, und ggf. die Texturkoordinaten darin direkt verändern (einfach skalieren) ...


----------



## Hikku (13. Jun 2012)

Das mit den Texturkoordinaten läuft auf Tessellation hinaus oder?
Wollte halt schauen ob mir Java3d die Arbeit ersparen kann. Möchte ungern einen Algorithmus schreiben bei dem jedes einzelne Dreieck aus dem Bild auf die Sphere gemappt wird.

Habe tagelang Google verwendet und bin einfach auf nichts brauchbares gestoßen :/


----------



## Marco13 (13. Jun 2012)

Neee... das hat mit Tesselation eigentlich nichts zu tun... 

Da wird ja irgendwo die TexCoordGeneration erstellt, mit OBJECT_LINEAR, und bei der Sphere steht noch so ein lapidares GENERATE_TEXTURE_COORDS_Y_UP ... ich gehe davon aus, dass du nicht weißt, was diese Sachen alle bedeuten... vielleicht schließe ich da auch nur von mir auf andere  Aber eine TexCoordGeneration hat ja irgendwelche Parameter und Optionen, ... sowas wie SPHERE_MAP klingt ja erstmal interessant, haut dann aber vermutlich wegen der Eye coordinates nicht hin ... aber ... nebenbei, und ganz allgemein: Man kann eine 2D-Textur nicht auf eine Kugel mappen, ohne dass es irgendwo Sch**** aussieht (im Zweifelsfall am Nord- oder Südpol) ... da haben sich schon viele Leute viel krampfiges Zeux ausgedacht ( xkcd: Map Projections )

Ich würde da jetzt auch nur ein bißchen rumspielen, und mal schauen ob man da mit einer Mischung aus rumprobieren, Websuche und TexCoordGeneration class to automatically define the texture coordinates : Texture3DJava , oder notfalls einem manuellen Skalieren der Texturkoordinaten (wie schon oben angedeutet) was brauchbares rausbekommt... (im Moment ist's bei mir aber zeitlich nicht sooo locker... ich brauch Urlaub, ein paar Jahre...)


----------



## Hikku (14. Jun 2012)

so hi,

vielleicht magst du recht haben, so langsam sehe ich den Wald vor lauter Bäumen nicht mehr..
Dass ich eine 2D Textur nicht perfekt auf eine Sphere gemappt bekomme war mir schon vorher bewusst. Solang die Textur am nord und südpol zusammenläuft ist das in Ordnung. Möchte halt das Bild so gut wie möglich dargestellt bekommen, nur besteht weiterhin das Problem der Wiederholungen der Textur..

ich habe mal folgendes versucht: 


```
System.out.println(tSphere.getShape().getGeometry());
```

Antwort:


```
javax.media.j3d.TriangleStripArray@1181c24
```

tiefer komm ich net ran.


Zu deinem Zitat: 


```
Ich würde da jetzt auch nur ein bißchen rumspielen, und mal schauen ob man da mit einer Mischung aus rumprobieren, Websuche und TexCoordGeneration class to automatically define the texture coordinates : Texture3DJava , oder notfalls einem manuellen Skalieren der Texturkoordinaten (wie schon oben angedeutet) was brauchbares rausbekommt... (im Moment ist's bei mir aber zeitlich nicht sooo locker... ich brauch Urlaub, ein paar Jahre...)
```

ich schau mal wie weit ich damit komme


----------



## Marco13 (14. Jun 2012)

Hikku hat gesagt.:


> ich habe mal folgendes versucht:
> 
> 
> ```
> ...



Ja, kannst mal schauen mit sowas wie

```
Geometry geometry = tSphere.getShape().getGeometry()
GeometryArray ga = (GeometryArray)geometry; // "Gefährlich", aber zum Testen OK
int vertexCount = ga.getVertexCount();
TexCoord2f texCoords[] = new TexCoord2f[vertexCount];
for (int i=0; i<vertexCount; i++)
{
    texCoords[i] = new TexCoord2f(); 
}
ga.getTextureCoordinates(0, 0, texCoords);

for (int i=0; i<vertexCount; i++)
{
    texCoords[i].x *= scaleX;
    texCoords[i].y *= scaleY;
}
ga.setTextureCoordinates(0, 0, texCoords);
```

Das ist nur ungetestet blind hingeschrieben, und ich vermute, dass es auch vieeel elegantere Möglichkeiten gibt, wenn man sich lange, lange mit API-lesen beschäftigt. Aber falls durch den obigen Code (z.B. mit mit scaleX=10 und scaleY=10) die Textur skaliert wird, kann man damit vielleicht zumindest erstmal das gewünschte erreichen - eine "schöne" Lösung kann man dann ggf immernoch suchen.


----------



## Hikku (19. Jun 2012)

Hab das Problem ganz einfach lösen können:



```
TextureLoader loader = new TextureLoader("foobar.jpg",this);
    ImageComponent2D image = loader.getImage();
    
    Texture2D texture = new Texture2D(Texture.BASE_LEVEL,Texture.RGB,image.getWidth(),image.getHeight());
    texture.setImage(0, image);
```


Hatte vergessen ein Texture2D Objekt zu verwenden. Sieht alles nun prächtig aus =)

danke für die Hilfe!


----------

