Hmm to takie małe coś co wspomaga budowanie aplikacji. Taki "make" w Java.
Spróbuj poniższy przykład
import java.applet.Applet;
import javax.media.j3d.*;
import javax.vecmath.*;
import com.sun.j3d.utils.geometry.*;
import com.sun.j3d.utils.universe.*;
import com.sun.j3d.utils.image.TextureLoader;
/*
* This example builds a simple Java 3D application using the
* Sun utility classes: MainFrame and SimpleUniverse.
* The example displays a moving sphere, in front of a
* background image. It uses a texture image and one light
* to increase the visual impact of the scene.
*/
public class A extends Applet
{
/*
* Create a simple Java 3D environment containing:
* a sphere (geometry), a light,background geometry
* with an applied texture, and a behavior that will
* move the sphere along the X-axis.
*/
public A()
{
// create the SimpleUniverse class that will
// encapsulate the scene that we are building.
// SimpleUniverse is a helper class (utility)
// from SUN that is included with the core Java 3D
// distribution.
SimpleUniverse u = new SimpleUniverse();
// create a BranchGroup. A BranchGroup is a node in
// a Tree data structure that can have child nodes
BranchGroup bgRoot = new BranchGroup();
// create the Background node and add it to the SimpleUniverse
u.addBranchGraph( createBackground() );
// create the behaviors to move the geometry along the X-axis.
// The behavior is added as a child of the bgRoot node.
// Anything added as a child of the tg node will be effected by the
// behavior (will be moved along the X-axis).
TransformGroup tg = createBehaviors( bgRoot );
// add the Sphere geometry as a child of the tg
// so that it will be moved along the X-axis.
tg.addChild( createSceneGraph() );
// because the sphere was added at the 0,0,0 coordinate
// and by default the viewer is also located at 0,0,0
// we have to move the viewer back a little so that
// she can see the scene.
u.getViewingPlatform().setNominalViewingTransform();
// add a light to the root BranchGroup to illuminate the scene
addLights( bgRoot );
// finally wire everything together by adding the root
// BranchGroup to the SimpleUniverse
u.addBranchGraph( bgRoot );
}
/*
* Create the geometry for the scene. In this case
* we simply create a Sphere
* (a built-in Java 3D primitive).
*/
public BranchGroup createSceneGraph()
{
// create a parent BranchGroup node for the Sphere
BranchGroup bg = new BranchGroup();
// create an Appearance for the Sphere.
// The Appearance object controls various rendering
// options for the Sphere geometry.
Appearance app = new Appearance();
// assign a Material to the Appearance. For the Sphere
// to respond to the light in the scene it must have a Material.
// Assign some colors to the Material and a shininess setting
// that controls how reflective the surface is to lighting.
Color3f objColor = new Color3f(0.8f, 0.2f, 1.0f);
Color3f black = new Color3f(0.0f, 0.0f, 0.0f);
app.setMaterial(new Material(objColor, black, objColor, black,
80.0f));
// create a Sphere with a radius of 0.1
// and associate the Appearance that we described.
// the option GENERATE_NORMALS is required to ensure that the
// Sphere responds correctly to lighting.
Sphere sphere = new Sphere( 0.1f, Primitive.GENERATE_NORMALS,
app );
// add the sphere to the BranchGroup to wire
// it into the scene.
bg.addChild( sphere );
return bg;
}
/*
* Add a directional light to the BranchGroup.
*/
public void addLights( BranchGroup bg )
{
// create the color for the light
Color3f color = new Color3f( 1.0f,1.0f,0.0f );
// create a vector that describes the direction that
// the light is shining.
Vector3f direction = new Vector3f( -1.0f,-1.0f,-1.0f );
// create the directional light with the color and direction
DirectionalLight light = new DirectionalLight( color, direction );
// set the volume of influence of the light.
// Only objects within the Influencing Bounds
// will be illuminated.
light.setInfluencingBounds( getBoundingSphere() );
// add the light to the BranchGroup
bg.addChild( light );
}
/*
* Create some Background geometry to use as
* a backdrop for the application. Here we create
* a Sphere that will enclose the entire scene and
* apply a texture image onto the inside of the Sphere
* to serve as a graphical backdrop for the scene.
*/
public BranchGroup createBackground()
{
// create a parent BranchGroup for the Background
BranchGroup backgroundGroup = new BranchGroup();
// create a new Background node
Background back = new Background();
// set the range of influence of the background
back.setApplicationBounds( getBoundingSphere() );
// create a BranchGroup that will hold
// our Sphere geometry
BranchGroup bgGeometry = new BranchGroup();
// create an appearance for the Sphere
Appearance app = new Appearance();
// load a texture image using the Java 3D texture loader
Texture tex = new TextureLoader( "c:/1/lipkal.jpg", this).getTexture();
// apply the texture to the Appearance
app.setTexture( tex );
// create the Sphere geometry with radius 1.0.
// we tell the Sphere to generate texture coordinates
// to enable the texture image to be rendered
// and because we are *inside* the Sphere we have to generate
// Normal coordinates inwards or the Sphere will not be visible.
Sphere sphere = new Sphere( 1.0f,
Primitive.GENERATE_TEXTURE_COORDS |
Primitive.GENERATE_NORMALS_INWARD, app );
// start wiring everything together,
// add the Sphere to its parent BranchGroup.
bgGeometry.addChild( sphere );
// assign the BranchGroup to the Background as geometry.
back.setGeometry( bgGeometry );
// add the Background node to its parent BranchGroup.
backgroundGroup.addChild( back );
return backgroundGroup;
}
/*
* Create a behavior to move child nodes along the X-axis.
* The behavior is added to the BranchGroup bg, whereas
* any nodes added to the returned TransformGroup will be
* effected by the behavior.
*/
public TransformGroup createBehaviors( BranchGroup bg )
{
// create a TransformGroup.
//
// A TransformGroup is a Group node (can have children)
// and contains a Transform3D member.
//
// The Transform3D member contains a 4x4 transformation matrix
// that is applied during rendering to all the TransformGroup's
// child nodes. The 4x4 matrix can describe:
// scaling, translation and rotation in one neat package!
// enable the TRANSFORM_WRITE capability so that
// our behavior code can modify it at runtime.
TransformGroup objTrans = new TransformGroup();
objTrans.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
// create a new Transform3D that will describe
// the direction we want to move.
Transform3D xAxis = new Transform3D();
// create an Alpha object.
// The Alpha object describes a function against time.
// The Alpha will output a value that ranges between 0 and 1
// using the time parameters (in milliseconds).
Alpha xAlpha = new Alpha( -1,
Alpha.DECREASING_ENABLE |
Alpha.INCREASING_ENABLE,
1000,
1000,
5000,
1000,
1000,
10000,
2000,
4000 );
// create a PositionInterpolator.
// The PositionInterpolator will modify the translation components
// of a TransformGroup's Transform3D (objTrans) based on the output
// from the Alpha. In this case the movement will range from
// -0.8 along the X-axis with Alpha=0 to X=0.8 when Alpha=1.
PositionInterpolator posInt = new PositionInterpolator( xAlpha,
objTrans,
xAxis, -0.8f, 0.8f );
// set the range of influence of the PositionInterpolator
posInt.setSchedulingBounds( getBoundingSphere() );
// wire the PositionInterpolator into its parent
// TransformGroup. Just like rendering nodes behaviors
// must be added to the scenegraph.
objTrans.addChild( posInt );
// add the TransformGroup to its parent BranchGroup
bg.addChild( objTrans );
// we return the TransformGroup with the
// behavior attached so that we can add nodes to it
// (which will be effected by the PositionInterpolator).
return objTrans;
}
/*
* Return a BoundingSphere that describes the
* volume of the scene.
*/
BoundingSphere getBoundingSphere()
{
return new BoundingSphere( new Point3d(0.0,0.0,0.0), 200.0 );
}
/*
* main entry point for the Application.
*/
public static void main(String[] args)
{
A simpleTest = new A();
}
}
Chodzi? Tylko zmień sobie teksturę na jakąś Twoją grafikę.