import java.awt.BorderLayout;
import java.awt.GraphicsConfiguration;
import javax.media.j3d.Alpha;
import javax.media.j3d.Appearance;
import javax.media.j3d.BoundingSphere;
import javax.media.j3d.BranchGroup;
import javax.media.j3d.Canvas3D;
import javax.media.j3d.GeometryArray;
import javax.media.j3d.PolygonAttributes;
import javax.media.j3d.RotationInterpolator;
import javax.media.j3d.Shape3D;
import javax.media.j3d.Transform3D;
import javax.media.j3d.TransformGroup;
import javax.media.j3d.TriangleStripArray;
import javax.swing.JFrame;
import javax.vecmath.Color3f;
import javax.vecmath.Point3d;
import javax.vecmath.Vector3f;
import com.sun.j3d.utils.universe.SimpleUniverse;
/**
* Klasse zur Darstellung einer virtuell erzeugten Landschaft mittels
* mathematischer Funktion.
*
* @author Florian Kalisch */
public class Terrain {
static GraphicsConfiguration gc;
static Canvas3D film;
static SimpleUniverse universe;
static JFrame theWindow;
public static void main(String[] args)
{
gc = SimpleUniverse.getPreferredConfiguration();
film = new Canvas3D(gc);
universe = new SimpleUniverse(film);
// Content Branch mit Inhalt füllen
BranchGroup scene = createLandscape(false, 20, 20);
scene.compile();
// Die ViewPlatform um 15 Einheiten zurücksetzen
Transform3D viewTransform = new Transform3D(translation(0f, 0, 15f));
universe.getViewingPlatform().getViewPlatformTransform().setTransform(viewTransform);
// Content Branch live machen
universe.addBranchGraph(scene);
// Code um das Fenster aufzubauen
theWindow = new JFrame();
setWindowStyle(theWindow, 1024, 768);
theWindow.add(film,"Center");
theWindow.setVisible(true); // muss letzter Befehl sein !!
}
/**
*
* @param theWindow Repräsentiert das Fenster
* @param screenWidth Breite des Fensters
* @param screenHeight Höhe des Fensters
*/
public static void setWindowStyle(JFrame theWindow, int screenWidth, int screenHeight)
{
// Default ist HIDE_ON_CLOSE, daher hier extra setzen
theWindow.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
theWindow.setResizable(false);
theWindow.setSize(screenWidth,screenHeight);
theWindow.setLayout(new BorderLayout());
}
/**
* Erstellt die Landschaft mit Hügeln und Tälern
*
* @param wireFrame Gibt an, ob ein Drahtgittermodell gezeichnet werden soll! True:Drahtgittermodell, False: gefüllt
* @param landscapeWidth Breite der Landschaft
* @param landscapeHeight Höhe der Landschaft
* @return Branchgroup, die beispielsweise an (universe.addBranchGraph(scene)) gehangen werden kann
*/
public static BranchGroup createLandscape(boolean wireFrame, int landscapeWidth, int landscapeHeight)
{
BranchGroup root = new BranchGroup();
TransformGroup tg = new TransformGroup();
Transform3D newTransform3D = translation(0f,0f,0f);
tg.setTransform(newTransform3D);
root.addChild(tg);
TransformGroup tRotate = new TransformGroup();
// Erzeugen des Rotation-Interpolators
tRotate.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
tg.addChild(tRotate);
Alpha rotationAlpha = new Alpha(-1, 15000);
RotationInterpolator iRotation = new RotationInterpolator(rotationAlpha,tRotate);
BoundingSphere bounds = new BoundingSphere();
iRotation.setSchedulingBounds(bounds);
tRotate.addChild(iRotation);
int format = 0;
if(wireFrame == true)
format = GeometryArray.COORDINATES;
else
format = GeometryArray.COORDINATES | GeometryArray.COLOR_3;
// Anzahl Vertices (ohne doppelte Zählungen)
int vertexCount = landscapeWidth * landscapeHeight;
// Anzahl Streifen
int stripes = landscapeHeight - 1;
// Anzahl an Vertices (mit den - TriangleStripArray bedingten - doppelten Vertices)
int verticesNum = vertexCount + (stripes-1) * landscapeWidth;
// Array für Vertices
Point3d[] vertices = new Point3d[verticesNum];
int vertarray_counter = 0;
// Generierung der Dreiecke für die Ebene
// Zuerst im Uhrzeigersinn, dann gegen den Uhrzeigersinn
for(int y=0; y<(landscapeHeight-1); y++)
{
for(int x=0; x<landscapeWidth; x++)
{
vertices[vertarray_counter++] = scaleValue(x,y+1);
vertices[vertarray_counter++] = scaleValue(x,y);
}
}
// Definieren der Stripes
int[] strip_counts = new int[stripes];
for (int i=0; i<stripes; i++)
{
// Streifen sind immer doppelt so breit wie die Breite der Landschaft
strip_counts[i] = landscapeWidth*2;
}
// Die Farbe muss für alle Vertices (auch doppelte) definiert werden!
// Alle Vertices, welche man hier nicht angibt, werden schwarz gezeichnet!
Color3f[] colors = new Color3f[verticesNum];
for(int i=0; i<verticesNum; i++)
{
// Der Color-Wert ist experimental.
colors[i] = new Color3f((float)( 0.9f-vertices[i].getZ() ), 0.9f-(float)( vertices[i].getZ() ), 0.9f-(float)( vertices[i].getZ())*1.5f );
}
// Definieren der Geometrie der Landschaft
TriangleStripArray tsa = new TriangleStripArray(verticesNum, format, strip_counts);
tsa.setCoordinates(0, vertices);
// Die Farben nur dann setzten, wenn kein Drahtgittermodell angezeigt werden soll
if(wireFrame == false)
tsa.setColors(0, colors);
Shape3D landScape = createLandscapeShape(wireFrame, tsa);
tRotate.addChild(landScape);
return root;
}
/**
*
* @param wireFrame Angabe ob nur Drahtgitter (true) oder gefüllt (false)
* @param tsa Erzeugtes TriangleStripArray (Geometrie) der Landschaft
* @return Fertige Landschaft als Shape3D
*/
static Shape3D createLandscapeShape(boolean wireFrame, TriangleStripArray tsa)
{
Shape3D landscapeShape = new Shape3D();
Appearance tsaAppearance = new Appearance();
PolygonAttributes pattrib = new PolygonAttributes();
tsaAppearance.setPolygonAttributes(pattrib);
// Darstellung:
// PolygonAttributes.POLYGON_LINE: nur Drahtgitter
// PolygonAttributes.POLYGON_FILL: gefüllt
if(wireFrame == true)
pattrib.setPolygonMode(PolygonAttributes.POLYGON_LINE);
else
pattrib.setPolygonMode(PolygonAttributes.POLYGON_FILL);
tsaAppearance.setPolygonAttributes(pattrib);
landscapeShape.setGeometry(tsa);
landscapeShape.setAppearance(tsaAppearance);
return landscapeShape;
}
/**
* Diese Funktion erzeugt ein Point3d-Object
* sValue : Skaliert die Landschaft (Werte > 1: Stauchung, Werte < 1: Streckung)
* tLeft : Bewirkt eine Verschiebung nach Links
* tUp : Bewirkt eine Verschiebung nach oben
* tFront : Bewirkt eine Verschiebung in Richtung View-Platform
*
* @param x X-Wert
* @param y Y-Wert
*/
static Point3d scaleValue(int x, int y)
{
float sValue = 3f;
int tLeft = 3;
float tUp = -3;
float tFront = 0;
return new Point3d((x/sValue)-tLeft,(y/sValue)+tUp, (getZValue(x,y)/sValue)+tFront);
}
/**
* Diese Funktion berechnet den Z-Wert, abhängig von den Werten x und y
*
* @param x X-Wert
* @param y Y-Wert
* @return Z-Wert (Tiefenwert)
*/
static float getZValue(int x, int y)
{
float nMaxWert = 3f;
//return (float) (nMaxWert * (Math.cos(Math.sqrt((x)*(x)+(y+1)*(y+1)))));
return (float) (nMaxWert * Math.cos(1.5f * y * Math.sin(x)));
}
/**
* Funktion erzeugt ein Transform3D (entsprechend den übergebenen Werten)
*
* @param x X-Wert
* @param y Y-Wert
* @param z Z-Wert (Tiefenwert)
* @return Transform3D
*/
static Transform3D translation(float x, float y, float z)
{
Transform3D transform3D = new Transform3D();
transform3D.setTranslation(new Vector3f(x,y,z));
return transform3D;
}
}
