# [JAVA3D] Schattenstrich durch die Szene



## evilion (23. Jun 2010)

Hallo alle miteinander

Ich bin hier neu und suche nach eurer Hilfe.

Mein Problem ist das:






Eine Linie, welche nicht da sein soll und wie die umgekehrte Schattierung aussieht, verläuft von der oberen linken Ecke über den Mittelpunkt in die untere rechte Ecke.

Wenn ich das Licht drehe, dann passiert folgendes:





Mein Code zum erstellen von dem ganzen poste ich auch hier hier. Alle Einstellungen für die Szene und die Erscheinung werden da gesetzt.


```
public Land(boolean start)
   {
      //Die Minimap wird aufgerufen
      //Minimap canvas = new Minimap();
      
      /*double xMin = 624376;
      double xMax = 628748;
      double yMax = 257996;
      double yMin = 257124;*/

      //abstand muss grösser als 900 sein
      double xMin = 622500;
      double xMax = 623500;
      double yMax = 259000;
      double yMin = 258000;

      //Für die Koordinaten, die aus der Minimap kommen würden
      /*int absoluteXBotLeftCorner = 590000;
      int absoluteYBotLeftCorner = 240000;
      int absoluteXBotRightCorner = 640000;
      int absoluteYTopLeftCorner = 275000;

      int minX = (absoluteXBotLeftCorner + ((int) (canvas.rect.getX() + 25) * (absoluteXBotRightCorner - absoluteXBotLeftCorner) / 326)) - 450;
      int maxX = (absoluteXBotLeftCorner + ((int) (canvas.rect.getX() + 25) * (absoluteXBotRightCorner - absoluteXBotLeftCorner) / 326)) + 450;
      int maxY = (absoluteYBotLeftCorner + ((int) (canvas.rect.getY() + 25) * (absoluteYBotLeftCorner - absoluteYTopLeftCorner) / 326)) - 450;
      int minY = (absoluteYBotLeftCorner + ((int) (canvas.rect.getY() + 25) * (absoluteYBotLeftCorner - absoluteYTopLeftCorner) / 326)) + 450;

      System.out.println(
            "Rectangle X:" + canvas.rect.getX() + " Rectangle Y:" + canvas.rect.getY());*/


      int yMaxup = 0;
      int xMaxup = 0;
      //int ny = 0;

      //Wenn yMax und Ymin / 2 grösser als das Limit ist, also ungerade für Float Zahlen
      if (((yMax + yMin) / 2.0) % STEP > LIMIT) {
         yMax += STEP;
         yMaxup = 1;
      }
      if (((xMax + xMin) / 2.0) % STEP > LIMIT) {
         xMax += STEP;
         xMaxup = 1;
      }
      /*int nx = (int) Math.rint((xMax - xMin) / STEP + 1);
      //Wenn es vorher ungerade war, sollte das
      if (yMaxup == 1) {
         ny = (int) Math.rint((yMax - yMin) / STEP);
      }
      else {
         ny = (int) Math.rint((yMax - yMin) / STEP + 1);
      }*/
      //Wenn es eine Abfrage von der Minimap ist, also kein erster Start
      if (start == false) {
         // grid = getCoord(xMaxup, yMaxup, maxX, maxY, minX, minY);
      }
      //Sonst zeige die Mitte der Karte
      else {
         //coord = getMoarCoord(yMaxup);
         //coord = getMoarCoordGebaeude(yMaxup);
         coord = getCoord(xMaxup, yMaxup, (int) xMax, (int) yMax, (int) xMin,
                          (int) yMin);
         start = false;
      }

      //Geometrie
      GeometryInfo gi = new GeometryInfo(GeometryInfo.QUAD_ARRAY);
      //Länge der Textur
      int texLen = FLOOR_LEN;
      //Texturkoordinaten
      TexCoord2f[] tCoords = createTexCoords(createCoords(), texLen);
      //Setze eine Lage der 2D Textur
      gi.setTextureCoordinateParams(1, 2);
      //Textur fängt bei 0 an und hat die Texturkoordinaten aus tCoords
      gi.setTextureCoordinates(0, tCoords);
      //Setze Geometriekoordinaten
      gi.setCoordinates(createCoords());
      
      //Bilde Streifen, damit die Berechnung schneller wird
      Stripifier sp = new Stripifier();
      sp.stripify(gi);

      System.out.println("GeometryInfo wurde gebaut. Ich mache mit Normalen Generator weiter.");
      //Mache die Normalen
      NormalGenerator ng = new NormalGenerator();
      //Abgerundete Kanten
      ng.setCreaseAngle((float) Math.toRadians(30));
      ng.generateNormals(gi);

      System.out.println("Normalen wurden gebaut. Ich mache mit Appearance weiter.");
      System.out.println("");

      //Erschaffe das Aussehen
      Appearance aper = new Appearance();
      //Und das Material
      Material mat = new Material();
      //Leuchten
      //mat.setShininess(1.0f);
      //Helligkeit
      mat.setDiffuseColor(0.8f, 0.8f, 0.8f);
      //Reflektion
      mat.setSpecularColor(0.0f, 0.0f, 0.0f);
      //Eine Fähigkeit wird gesetzt, damit man es während der Laufzeit ändern kann
      mat.setCapability(Material.ALLOW_COMPONENT_WRITE);
      //Setzte das Material in das Aussehen
      aper.setMaterial(mat);

      //Lade das Bild von dem Kartenausschnitt
      BufferedImage bufferedImage = null;
      try {
         //File file = new File("125.tif");
         File file = new File("ortho2004_10.tif");
         bufferedImage = ImageIO.read(file);
      }
      catch (IOException e) {
         System.out.println("Sorry boss I cant get any image loaded.");
      }


      int x = 0, y = 0, width = 0, height = 0;

      /* 0: X-Scale - wie viel meter pro pixel
       * 1: Rotation y
       * 2: Roration x
       * 3: Y-Scale - wie viel meter pro pixel (negativ)
       * 4: X-Reference (Top Left Corner Pixel)
       * 5: Y-Reference (Top Left Corner Pixel)
       * */
      double[] tfw = new double[6];

      //Lade den TFW Angaben Datei
      //Und schreibe es in den vorher definierten Array
      try {
         int i = 0;
         // Open the file that is the first
         // command line parameter
         //FileInputStream fstream = new FileInputStream("125.tfw");
         FileInputStream fstream = new FileInputStream("ortho2004_10.tfw");
         // Get the object of DataInputStream
         DataInputStream in = new DataInputStream(fstream);
         BufferedReader br = new BufferedReader(new InputStreamReader(in));
         String strLine;
         //Read File Line By Line
         while ((strLine = br.readLine()) != null) {
            tfw[i] = Double.valueOf(strLine).doubleValue();
            i++;

           //System.out.println(strLine);
         }
         //Close the input stream
         in.close();
      }
      catch (Exception e) {//Catch exception if any
         System.err.println("Error: " + e.getMessage());
      }

      //x der linken oberen ecke
      int xMap = (int) Math.round(tfw[4]);
      //y der linken oberen ecke
      int yMap = (int) Math.round(tfw[5]);
      //wie viel meter pro pixel auf x achse
      double xScale = tfw[0];
      //wie viel meter pro pixel auf y achse (negativ)
      double yScale = -tfw[3];

      //Angaben zu dem Platz, wo sich das auszuschneidende Bild befindet
      //X
      x = (int) ((xTopLeftCorner - xMap) / xScale);
      //Y
      y = (int) ((yMap - yTopLeftCorner) / yScale);
      //Breite
      width = (int) ((xBotRightCorner - xTopLeftCorner) / xScale);
      //Höhe
      height = (int) ((yTopLeftCorner - yBotRightCorner) / yScale);

      //Erstell ein ImageComponent2D aus dem geschnittenem Bild
      ImageComponent2D textImage = new ImageComponent2D(
            ImageComponent2D.FORMAT_RGB,
            cropImage(bufferedImage,
                      x, y, width, height));

      //Erstelle eine einlagige Textur mit RGB Farben und der Breite und Höhe des angegebenen Bildes
      Texture2D texture = new Texture2D(Texture2D.BASE_LEVEL, Texture.RGB,
                                        textImage.getWidth(),
                                        textImage.getHeight());
      //Setzte das geladene Bild als Textur auf den 0te Ebene
      texture.setImage(0, textImage);

      //Wie soll es aussehen, wenn Texel kleiner als Pixel sind
      texture.setMinFilter(Texture.NICEST);
      //Wie soll es aussehen, wenn Texel grösser als Pixel sind
      texture.setMagFilter(Texture.NICEST);
      //aktiviere die Textur
      texture.setEnable(true);

      //Texturenattribute.
      TextureAttributes texatt = new TextureAttributes(
            //Es vermischt das Licht mit den Farben der Textur
            TextureAttributes.MODULATE,
            //Textur kann gedreht und Skalliert werden
            new Transform3D(),
            //Rot, Grün, Blau, Alpha - Volle Helligkeit und Sichtbar
            new Color4f(1.0f,1.0f,1.0f,1.0f),
            //Es soll schön gemacht werden
            TextureAttributes.NICEST);
      //Setze sie Attribute ins Aussehen
      aper.setTextureAttributes(texatt);
      //Setze die Textur ins Aussehen
      aper.setTexture(texture);
      //Mache so, dass man das Material veraendern kann
      aper.setCapability(Appearance.ALLOW_MATERIAL_WRITE);
      //Setze die Geometrie
      this.setGeometry(gi.getGeometryArray());
      //Setze das Aussehen
      this.setAppearance(aper);
   }// end of Land()
```

Ich hoffe mir kann jemand helfen und dieser Thread wird nicht ignoriert, weil keiner ne Ahnung hat... so wie in einem anderen Forum...


----------



## Marco13 (23. Jun 2010)

Ich weiß zwar keine Antwort und habe keine Ahnung, aber ich wollte diesen Thread auch nicht ignorieren.

Also: Dein Thread wurde zur Kenntnis genommen 

:joke:

Mal im Ernst: Ich bin nicht (mehr?) so fit im Java3D, aber ... meine ersten Ansätze wären, die Sache mit dem Stripifier mal rausnehmen, um zu schauen, ob der Mist macht, und mal die Normalen von hand zu generieren (notfalls alle einfach (0,0,1) setzen). Wenn der Fehler dann nicht mehr auftritt, KÖNNTE es sein, dass der NormalGenerator irgendwie ins Stolpern kommt...


----------



## evilion (23. Jun 2010)

woah, du bist gut!

Der Stripifier war das Problem. Ohne den gibts keinen Streifen. Und ohne den gibts einen Tick schlechtere Schatten an den Abhängen. Aber das merkt man nicht, da die es heisst, dass die Schatten nicht realistisch sind.

Ist der Stripifier sehr wichtig? Den einzigen Nutzen, den ich bis jetzt gelesen hab, das die Berechnung schneller erfolgt aber die ist genau so schnell ohne den...

Danke Marco13


----------



## Marco13 (23. Jun 2010)

Wie gesagt, bin ein bißchen raus. Wilde Spekulationen, was genau der Stripifier macht, und wo da welche Indizes durcheinandergewürfelt werden, dass dann die Normalen nicht mehr stimmen, erspare ich uns jetzt mal. Aber wenn er ihnehin keinen Geschwindigkeitsvorteil bringt, kann man ihn auch weglassen. (Naja, eine halb-Spekulation: I.a. gilt es als "schneller", wenn man Dreiecke in OpenGL als GL_TRIANGLE_STIP zeichnet, und nicht als GL_TRIANGLES oder so... vermutlicht macht der Stripifier etwas in der Richtung, aber wie groß heutzutage der Geschwindgkeitsvorteil da wirklich ist, kann ich nicht sagen...)


----------



## evilion (23. Jun 2010)

thx für die info


----------

