Hallo!
Ich habe in Java 3D eine kleine Animation geschrieben und wollte die zum laufen bringen.
Bei erstellen der jar-Datei(in Eclipse) kommt ein Fehler. Die jar-Datei ist zwar erstellt aber lässt sich nicht öffnen(keine Fehlermeldung, läuft auch nicht im hintergrund).
Hier der Fehler
Und hier der Quellcode:
Ich habe in Java 3D eine kleine Animation geschrieben und wollte die zum laufen bringen.
Bei erstellen der jar-Datei(in Eclipse) kommt ein Fehler. Die jar-Datei ist zwar erstellt aber lässt sich nicht öffnen(keine Fehlermeldung, läuft auch nicht im hintergrund).
Hier der Fehler
Und hier der Quellcode:
package main;
/**
* @author David K.
*
*/
import java.awt.GraphicsConfiguration;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.loaders.*;
import com.sun.j3d.loaders.objectfile.*;
import com.sun.j3d.utils.image.TextureLoader;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.behaviors.vp.*;
import javax.swing.JFrame;
public class Bildschirmschoner extends JFrame {
// Der Canvas, auf den gezeichnet wird.
public Canvas3D myCanvas3D;
public double translation;
public Bildschirmschoner() {
// Mechanismus zum Schliessen des Fensters und beenden des Programms
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Standardeinstellung fuer das Betrachteruniversum
GraphicsConfiguration config = SimpleUniverse
.getPreferredConfiguration();
myCanvas3D = new Canvas3D(config);
ViewingPlatform viewingPlatform = new ViewingPlatform();
viewingPlatform.getViewPlatform().setActivationRadius(300f);
TransformGroup viewTransform = viewingPlatform
.getViewPlatformTransform();
Transform3D t3d = new Transform3D();
// Note: Now the large value works
t3d.lookAt(new Point3d(5, 5, 25), new Point3d(0, 0, 0), new Vector3d(0,
2, 0));
t3d.invert();
viewTransform.setTransform(t3d);
Viewer viewer = new Viewer(myCanvas3D);
View view = viewer.getView();
view.setBackClipDistance(100);
// Aufbau des SimpleUniverse:
// Zuerst Erzeugen zusammen mit dem Canvas
SimpleUniverse simpUniv = new SimpleUniverse(viewingPlatform, viewer);
// 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("Bildschirmschoner");
setSize(1200, 800);
getContentPane().add("Center", myCanvas3D);
setVisible(true);
}
/*
* Die main wo alles reingeladen wird
*/
public static void main(String[] args) {
Bildschirmschoner bs = new Bildschirmschoner();
}
// In dieser Methode werden die Objekte der Szene aufgebaut, die Bewegungen
// definiert und dem SimpleUniverse su hinzugefuegt.
/**
* Konstruktor
*
* @param su
* bla
* @param f
* @param s
* Szene wird
* @param arg0
* ASDAS
*/
public void createSceneGraph(SimpleUniverse su) {
BoundingSphere bounds = new BoundingSphere(
new Point3d(0.0, 0.0, 100.0), Double.MAX_VALUE);
/*
* Reinladen des Objektes "Raumschiff" in das SimpleUniverse
*/
ObjectFile f = new ObjectFile(ObjectFile.RESIZE);
Scene s = null;
try {
s = f.load("Frigate.obj");
} catch (Exception e) {
System.out.println("File loading failed:" + e);
}
/*
* Branchgroup wo die Scene ablaufen soll. Alle TransformGroup, leafs etc sind Kinder der Branchgroup "the Scene"
*/
BranchGroup theScene = new BranchGroup();
/*
* TransformGruppe für die Skalierung des Raummschiffes
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* .setScale(wie groß möchte ich mein Raumschiff Skalieren)
* .addChild fügt die TransformGroup"RaumschiffSkalieren" der Branchgroup hinzu
*/
TransformGroup RaumschiffSkalieren = new TransformGroup();
Transform3D schiffeigenschaft = new Transform3D();
schiffeigenschaft.setScale(1);
RaumschiffSkalieren.setTransform(schiffeigenschaft);
theScene.addChild(RaumschiffSkalieren);
/*
* TransformGroup mit dem Befehl .Allow_Tranform_write erlaubt die änderung der Transformgroup"transformieren 1"
* .addChild fügt die TransformGroup"transformieren1" der Tranformgroup"RaumschiffSkalieren" hinzu
*/
TransformGroup transformieren1 = new TransformGroup();
transformieren1.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
RaumschiffSkalieren.addChild(transformieren1);
/*
* TransformGroup mit dem Befehl .Allow_Tranform_write erlaubt die änderung der Transformgroup"transformieren 2"
* .addChild fügt die TransformGroup"transformieren2" der Tranformgroup"transformieren1" hinzu
*/
TransformGroup transformieren2 = new TransformGroup();
transformieren2.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
transformieren1.addChild(transformieren2);
/*
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* Mit .set(1, new Vector3d(x,y,z)) verschieben wir unser Objekt vom Ursprung aus im 3D-Raum
* .addChild fügt die TransformGroup"transformieren2" der Tranformgroup"transformieren3" hinzu
* .addChild(s.getSceneGroup() an der stelle wird das Objekt in die Szene eingefügt und transformiert
*/
Transform3D schiffverschieben = new Transform3D();
schiffverschieben.set(1, new Vector3d(5.0, 0, 0.0));
TransformGroup transformieren3 = new TransformGroup(schiffverschieben);
transformieren2.addChild(transformieren3);
transformieren3.addChild(s.getSceneGroup());
/*
* Tranformgruppe der PositionInterpolators mit einer rotation des Objektes
*/
Transform3D position1 = new Transform3D();
position1.rotX(Math.PI);
/*
* Alpha(Wie oft der loop wiederholt werden soll(int),Alpha ansteigend(long),
* in wieviel Millisekunden es starten soll(long),verzögerung in ms,anstiegsdauer in ms(long),
* schnelligkeit der entverschiebung(long)
*
*/
Alpha p1Alpha = new Alpha(1, Alpha.INCREASING_ENABLE, 8000, 1000,1000,
0, 0, 0,0,0);
/*
* PositionInterpolator(Alpha, Transformgroup, Transform3D,von wo aus er starten soll, wie weit er verschieben soll)
*/
PositionInterpolator pi1 = new PositionInterpolator(p1Alpha,
transformieren2, position1, 0.0f, (float) -Math.PI);
/*
*
*/
pi1.setSchedulingBounds(bounds);
transformieren2.addChild(pi1);
/*
* Tranformgruppe der RotationsInterpolators mit einer rotation des Objekts
*/
Transform3D rotation = new Transform3D();
rotation.rotY(Math.PI);
/*
* Alpha für das Rotieren
*/
Alpha schiffrotation2 = new Alpha(-1, Alpha.INCREASING_ENABLE, 1, 100,
10000, 0, 0, 0, 0, 0);
/*
* Rotation des Raumschiffes
*/
/*
* RotationInterpolator(Alpha, Transformgroup, Transform3D, wie oft/schnell das Schiff rumfliegen soll bis die Interpolation stattfindets, parameter wie weit er verschieben soll)
*/
RotationInterpolator Rotation = new RotationInterpolator(
schiffrotation2, transformieren1, rotation, (float) Math.PI,
(float) -Math.PI);
Rotation.setSchedulingBounds(bounds);
transformieren2.addChild(Rotation);
/**
* Transform3D position2 = new Transform3D(); position1.rotX(Math.PI);
* Alpha fAlpha = new
* Alpha(1,Alpha.INCREASING_ENABLE,15000,200,20000,2000
* ,2000,2000,1000,0);
*
* PositionInterpolator pi2 = new
* PositionInterpolator(fAlpha,transformieren0,position2,0.0f,(float)
* Math.PI); pi2.setSchedulingBounds(bounds);
* transformieren2.addChild(pi2);
*/
/*
* Reinladen des Objektes "Erde" in das SimpleUniverse
*/
try {
s = f.load("Sphere.obj");
} catch (Exception e) {
System.out.println("File loading failed:" + e);
}
/*
* TransformGruppe für die Skalierung der Erde
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* .setScale(wie groß möchte ich meine Erde Skalieren)
* .addChild fügt die TransformGroup"ErdeSkalieren" der Branchgroup hinzu
*/
TransformGroup ErdeSkalieren = new TransformGroup();
Transform3D kugelgroesse = new Transform3D();
kugelgroesse.setScale(1.2);
ErdeSkalieren.setTransform(kugelgroesse);
theScene.addChild(ErdeSkalieren);
/*
* TransformGroup mit dem Befehl .Allow_Tranform_write erlaubt die änderung der Transformgroup"transformieren 5"
* .addChild fügt die TransformGroup"transformieren5" der Tranformgroup"ErdeSkalieren" hinzu
*/
TransformGroup transformieren5 = new TransformGroup();
transformieren5.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
ErdeSkalieren.addChild(transformieren5);
/*
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* Mit .set(1, new Vector3d(x,y,z)) verschieben wir unser Objekt vom Ursprung aus im 3D-Raum
* .addChild fügt die TransformGroup"transformieren5" der Tranformgroup"transformieren6" hinzu
* .addChild(s.getSceneGroup() an der stelle wird das Objekt in die Szene eingefügt und transformiert
*/
Transform3D Erdeverchieben = new Transform3D();
Erdeverchieben.set(1, new Vector3d(0.0, 0.0, 0.0));
TransformGroup transformieren6 = new TransformGroup(Erdeverchieben);
transformieren5.addChild(transformieren6);
transformieren6.addChild(s.getSceneGroup());
Transform3D rotation4 = new Transform3D();
Alpha rotationSphere = new Alpha(-1, Alpha.INCREASING_ENABLE, 1, 2,
80000, 0, 0, 0, 0, 0);
/*
* RotationInterpolator(Alpha, Transformgroup, Transform3D, wie oft/schnell die Erde rumfliegen soll bis die Interpolation stattfindets, parameter wie weit er verschieben soll)
*/
RotationInterpolator riE = new RotationInterpolator(rotationSphere,
transformieren5, rotation4, 4.0f, (float) Math.PI * 2);
riE.setSchedulingBounds(bounds);
transformieren5.addChild(riE);
/*
* Reinladen des Objektes "Moon" in das SimpleUniverse
*/
try {
s = f.load("Moon.obj");
} catch (Exception e) {
System.out.println("File loading failed:" + e);
}
/*
* TransformGruppe für die Skalierung des Mondes
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* .setScale(wie groß möchte ich mein Mond Skalieren)
* .addChild fügt die TransformGroup"MondSkalieren" der Branchgroup hinzu
*/
TransformGroup MondSkalieren = new TransformGroup();
Transform3D kugelgroesse2 = new Transform3D();
kugelgroesse2.setScale(0.3);
/*
* TransformGroup mit dem Befehl .Allow_Tranform_write erlaubt die änderung der Transformgroup"transformieren 1"
* .addChild fügt die TransformGroup"transformieren1" der Tranformgroup"RaumschiffSkalieren" hinzu
*/
TransformGroup transformieren7 = new TransformGroup();
transformieren7.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
MondSkalieren.addChild(transformieren7);
/*
* Transform3D für das ändern des Objektes(Matrixmultiplikation)
* Mit .set(1, new Vector3d(x,y,z)) verschieben wir unser Objekt vom Ursprung aus im 3D-Raum
* Mit .rotZ rotieren wir das Objekt um die Z-Achse
* Mit .mul() Multiplizieren wir die Matrix der Rotation mit der Matrix der Skalieren
* .setTransform elaubt es uns überhaupt die beiden Transformationsgruppen miteinander zu multiplizieren
* .addChild fügt die TransformGroup"transformieren7" der Tranformgroup"transformieren8" hinzu
* .addChild(s.getSceneGroup() an der stelle wird das Objekt in die Szene eingefügt und transformiert
*/
Transform3D Mondverschieben = new Transform3D();
Mondverschieben.set(1, new Vector3d(20, 0.0, 0.0));
Transform3D rotierenM = new Transform3D();
rotierenM.rotZ(Math.PI / 4);
kugelgroesse2.mul(rotierenM);
MondSkalieren.setTransform(kugelgroesse2);
theScene.addChild(MondSkalieren);
TransformGroup transformieren8 = new TransformGroup(Mondverschieben);
transformieren7.addChild(transformieren8);
transformieren8.addChild(s.getSceneGroup());
Transform3D rotation5 = new Transform3D();
Alpha rotationMond1 = new Alpha(-1, Alpha.INCREASING_ENABLE, 1, 0,
300000, 0, 0, 0, 0, 0);
/*
* RotationInterpolator(Alpha, Transformgroup, Transform3D, wie oft/schnell die Erde rumfliegen soll bis die Interpolation stattfindets, parameter wie weit er verschieben soll)
*/
RotationInterpolator riM = new RotationInterpolator(rotationMond1,
transformieren7, rotation5, 0.0f, (float) Math.PI * 50);
/*
*
*/
riM.setSchedulingBounds(bounds);
transformieren8.addChild(riM);
/*
*Der Konstruktor "TextureLoader" nutzt ein Bild mit der Standarteinstellung RGBA
*Mit dem Kosntruktur"Background(.getImage()) wird das Bild als Hintergundbild konfiguriert
*Das hintergundbild .setApplicationBounds bekommt die Grenze
*
*/
TextureLoader bildladen = new TextureLoader("weltall.jpg", null);
Background hintergund = new Background(bildladen.getImage());
hintergund.setApplicationBounds(bounds);
theScene.addChild(hintergund);
/*
* Die Methode compile() assoziiert die Daten der Branchgroup und kompiliert die neue Szene
*/
theScene.compile();
/*
* Die Knotenpunkte werden der Geometrie von der Szene-Graphen hinzugefügt
*/
su.addBranchGraph(theScene);
}
/*
* In dieser Methode wird Licht dem Simple Universe hinzugefügt. Das Licht
* wird immer der Branchgroup hinzugefügt. Dazu brauchen wir zuerst die
* BoundingSphere, dieses Ermöglicht uns den Aufbau einer Szene im Simple
* Universe. Der Aufruf von Branchgroup überführt den gesamten
* darunterliegenden Teilbaum des Szenengraphen in eine interne
* Repräsentation für Java 3D. Color3f ist für die Farbe des Lichts
* zuständig(1,1,1 = weiß). Durch Vector3f wird angegeben, von wo das Licht
* kommt. DirectionalLight zeigt in eine Richtung und bleibt konstant. setInfluencingBounds() ist der
* Einflussbereich. Mit addBranchGraph(bgLight) fügen wir schließlich unseren SimpleUniverse das Licht hinzu
*
*/
public void addLight(SimpleUniverse su) {
BranchGroup bgLight = new BranchGroup();
BoundingSphere bounds = new BoundingSphere(new Point3d(0.0, 0.0, 0.0),
10.0);
Color3f lichtFarbe = new Color3f(0.3f, 0.3f, 0.3f);
Vector3f lichtRichtung = new Vector3f(-1.0f, 0.0f, -0.5f);
DirectionalLight light1 = new DirectionalLight(lichtFarbe,
lichtRichtung);
light1.setInfluencingBounds(bounds);
bgLight.addChild(light1);
su.addBranchGraph(bgLight);
}
}
Zuletzt bearbeitet:
