针对Java移动设备的3D图形第1部分：M3G 的立即模式

package m3gsamples1;

import javax.microedition.lcdui.*;
import javax.microedition.m3g.*;

/**
* Sample displaying a cube defined by eight vertices, which are connected
* by triangles.
*
* @author Claus Hoefele
*/
public class VerticesSample extends Canvas implements Sample
{
/** The cube's vertex positions (x, y, z). */
private static final byte[] VERTEX_POSITIONS = {
-1, -1,  1,    1, -1,  1,   -1,  1,  1,    1,  1,  1,
-1, -1, -1,    1, -1, -1,   -1,  1, -1,    1,  1, -1
};

/** Indices that define how to connect the vertices to build
* triangles. */
private static int[] TRIANGLE_INDICES = {
0, 1, 2, 3, 7, 1, 5, 4, 7, 6, 2, 4, 0, 1
};

/** The cube's vertex data. */
private VertexBuffer _cubeVertexData;

/** The cube's triangles defined as triangle strips. */
private TriangleStripArray _cubeTriangles;

/** Graphics singleton used for rendering. */
private Graphics3D _graphics3d;

/**
* Called when this sample is displayed.
*/
public void showNotify()
{
init();
}

/**
* Initializes the sample.
*/
protected void init()
{
// Get the singleton for 3D rendering.
_graphics3d = Graphics3D.getInstance();

// Create vertex data.
_cubeVertexData = new VertexBuffer();

VertexArray vertexPositions =
new VertexArray(VERTEX_POSITIONS.length/3, 3, 1);
vertexPositions.set(0, VERTEX_POSITIONS.length/3, VERTEX_POSITIONS);
_cubeVertexData.setPositions(vertexPositions, 1.0f, null);

// Create the triangles that define the cube; the indices point to
// vertices in VERTEX_POSITIONS.
_cubeTriangles = new TriangleStripArray(TRIANGLE_INDICES,
new int[] {TRIANGLE_INDICES.length});

// Create a camera with perspective projection.
Camera camera = new Camera();
float aspect = (float) getWidth() / (float) getHeight();
camera.setPerspective(30.0f, aspect, 1.0f, 1000.0f);
Transform cameraTransform = new Transform();
cameraTransform.postTranslate(0.0f, 0.0f, 10.0f);
_graphics3d.setCamera(camera, cameraTransform);
}

/**
* Renders the sample on the screen.
*
* @param graphics the graphics object to draw on.
*/
protected void paint(Graphics graphics)
{
_graphics3d.bindTarget(graphics);
_graphics3d.clear(null);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
new Appearance(), null);
_graphics3d.releaseTarget();
}

/** The cube's vertex colors (R, G, B). */
private static final byte[] VERTEX_COLORS = {
0, (byte) 255, 0,             0, (byte) 255, (byte) 255,
(byte) 255, 0, 0,             (byte) 255, 0, (byte) 255,
(byte) 255, (byte) 255, 0,    (byte) 255, (byte) 255, (byte) 255,
0, 0, (byte) 128,             0, 0, (byte) 255,
};

/**
* Initializes the sample.
*/
protected void init()
{
// Get the singleton for 3D rendering.
_graphics3d = Graphics3D.getInstance();

// Create vertex data.
_cubeVertexData = new VertexBuffer();

VertexArray vertexPositions =
new VertexArray(VERTEX_POSITIONS.length/3, 3, 1);
vertexPositions.set(0, VERTEX_POSITIONS.length/3, VERTEX_POSITIONS);
_cubeVertexData.setPositions(vertexPositions, 1.0f, null);

VertexArray vertexColors =
new VertexArray(VERTEX_COLORS.length/3, 3, 1);
vertexColors.set(0, VERTEX_COLORS.length/3, VERTEX_COLORS);
_cubeVertexData.setColors(vertexColors);

// Create the triangles that define the cube; the indices point to
// vertices in VERTEX_POSITIONS.
_cubeTriangles = new TriangleStripArray(TRIANGLE_INDICES,
new int[] {TRIANGLE_INDICES.length});

// Define an appearance object and set the polygon mode. The
// default values are: SHADE_SMOOTH, CULL_BACK, and WINDING_CCW.
_cubeAppearance = new Appearance();
_polygonMode = new PolygonMode();
_cubeAppearance.setPolygonMode(_polygonMode);

// Create a camera with perspective projection.
Camera camera = new Camera();
float aspect = (float) getWidth() / (float) getHeight();
camera.setPerspective(30.0f, aspect, 1.0f, 1000.0f);
Transform cameraTransform = new Transform();
cameraTransform.postTranslate(0.0f, 0.0f, 10.0f);
_graphics3d.setCamera(camera, cameraTransform);
}

/**
* Renders the sample on the screen.
*
* @param graphics the graphics object to draw on.
*/
protected void paint(Graphics graphics)
{
_graphics3d.bindTarget(graphics);
_graphics3d.clear(null);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
_cubeAppearance, null);
_graphics3d.releaseTarget();

drawMenu(graphics);
}

/**
* Handles key presses.
*
* @param keyCode key code.
*/
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
case FIRE:
init();
break;

case GAME_A:
if (_polygonMode.getShading() == PolygonMode.SHADE_FLAT)
{
_polygonMode.setShading(PolygonMode.SHADE_SMOOTH);
}
else
{
_polygonMode.setShading(PolygonMode.SHADE_FLAT);
}
break;

case GAME_B:
if (_polygonMode.getCulling() == PolygonMode.CULL_BACK)
{
_polygonMode.setCulling(PolygonMode.CULL_FRONT);
}
else
{
_polygonMode.setCulling(PolygonMode.CULL_BACK);
}
break;

case GAME_C:
if (_polygonMode.getWinding() == PolygonMode.WINDING_CCW)
{
_polygonMode.setWinding(PolygonMode.WINDING_CW);
}
else
{
_polygonMode.setWinding(PolygonMode.WINDING_CCW);
}

break;

// no default
}

repaint();
}

/**
* Renders the sample on the screen.
*
* @param graphics the graphics object to draw on.
*/
protected void paint(Graphics graphics)
{
_graphics3d.bindTarget(graphics);
_graphics3d.clear(null);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
new Appearance(), _cubeTransform);
_graphics3d.releaseTarget();

drawMenu(graphics);
}

/**
* Handles key presses.
*
* @param keyCode key code.
*/
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
case UP:
transform(_transformation, TRANSFORMATION_X_AXIS, false);
break;

case DOWN:
transform(_transformation, TRANSFORMATION_X_AXIS, true);
break;

case LEFT:
transform(_transformation, TRANSFORMATION_Y_AXIS, false);
break;

case RIGHT:
transform(_transformation, TRANSFORMATION_Y_AXIS, true);
break;

case GAME_A:
transform(_transformation, TRANSFORMATION_Z_AXIS, false);
break;

case GAME_B:
transform(_transformation, TRANSFORMATION_Z_AXIS, true);
break;

case FIRE:
init();
break;

case GAME_C:
_transformation++;
_transformation %= 3;
break;

// no default
}

repaint();
}

/**
* Transforms the cube with the given parameters.
*
* @param transformation transformation (rotate, translate, scale)
* @param axis axis of translation (x, y, z)
* @param positiveDirection true for increase, false for decreasing
*                          value.
*/
protected void transform(int transformation, int axis,
boolean positiveDirection)
{
if (transformation == TRANSFORMATION_ROTATE)
{
float amount = 10.0f * (positiveDirection ? 1 : -1);

switch (axis)
{
case TRANSFORMATION_X_AXIS:
_cubeTransform.postRotate(amount, 1.0f, 0.0f, 0.0f);
break;

case TRANSFORMATION_Y_AXIS:
_cubeTransform.postRotate(amount, 0.0f, 1.0f, 0.0f);
break;

case TRANSFORMATION_Z_AXIS:
_cubeTransform.postRotate(amount, 0.0f, 0.0f, 1.0f);
break;

// no default
}
}
else if (transformation == TRANSFORMATION_SCALE)
{
float amount = positiveDirection ? 1.2f : 0.8f;

switch (axis)
{
case TRANSFORMATION_X_AXIS:
_cubeTransform.postScale(amount, 1.0f, 1.0f);
break;

case TRANSFORMATION_Y_AXIS:
_cubeTransform.postScale(1.0f, amount, 1.0f);
break;

case TRANSFORMATION_Z_AXIS:
_cubeTransform.postScale(1.0f, 1.0f, amount);
break;

// no default
}
}
else if (transformation == TRANSFORMATION_TRANSLATE)
{
float amount = 0.2f * (positiveDirection ? 1 : -1);

switch (axis)
{
case TRANSFORMATION_X_AXIS:
_cubeTransform.postTranslate(amount, 0.0f, 0.0f);
break;

case TRANSFORMATION_Y_AXIS:
_cubeTransform.postTranslate(0.0f, amount, 0.0f);
break;

case TRANSFORMATION_Z_AXIS:
_cubeTransform.postTranslate(0.0f, 0.0f, amount);
break;

// no default
}
}
}

/**
* Initializes the sample.
*/
protected void init()
{
// Get the singleton for 3D rendering.
_graphics3d = Graphics3D.getInstance();

// Create vertex data.
_cubeVertexData = new VertexBuffer();

VertexArray vertexPositions =
new VertexArray(VERTEX_POSITIONS.length/3, 3, 1);
vertexPositions.set(0, VERTEX_POSITIONS.length/3, VERTEX_POSITIONS);
_cubeVertexData.setPositions(vertexPositions, 1.0f, null);

// Create the triangles that define the cube; the indices point to
// vertices in VERTEX_POSITIONS.
_cubeTriangles = new TriangleStripArray(TRIANGLE_INDICES,
new int[] {TRIANGLE_INDICES.length});

// Create parallel and perspective cameras.
_cameraPerspective = new Camera();

float aspect = (float) getWidth() / (float) getHeight();
_cameraPerspective.setPerspective(30.0f, aspect, 1.0f, 1000.0f);
_cameraTransform = new Transform();
_cameraTransform.postTranslate(0.0f, 0.0f, 10.0f);

_cameraParallel = new Camera();
_cameraParallel.setParallel(5.0f, aspect, 1.0f, 1000.0f);

_graphics3d.setCamera(_cameraPerspective, _cameraTransform);
_isPerspective = true;

// Enable depth buffer.
_isDepthBufferEnabled = true;
}

/**
* Renders the sample on the screen.
*
* @param graphics the graphics object to draw on.
*/
protected void paint(Graphics graphics)
{
// Create transformation objects for the cubes.
Transform origin = new Transform();
Transform behindOrigin = new Transform(origin);
behindOrigin.postTranslate(-1.0f, 0.0f, -1.0f);
Transform inFrontOfOrigin = new Transform(origin);
inFrontOfOrigin.postTranslate(1.0f, 0.0f, 1.0f);

// Disable or enable depth buffering when target is bound.
_graphics3d.bindTarget(graphics, _isDepthBufferEnabled, 0);
_graphics3d.clear(null);

// Draw cubes front to back. If the depth buffer is enabled,
// they will be drawn according to their z coordinate. Otherwise,
// according to the order of rendering.
_cubeVertexData.setDefaultColor(0x00FF0000);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
new Appearance(), inFrontOfOrigin);
_cubeVertexData.setDefaultColor(0x0000FF00);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
new Appearance(), origin);
_cubeVertexData.setDefaultColor(0x000000FF);
_graphics3d.render(_cubeVertexData, _cubeTriangles,
new Appearance(), behindOrigin);

_graphics3d.releaseTarget();

drawMenu(graphics);
}

/**
* Handles key presses.
*
* @param keyCode key code.
*/
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
case GAME_A:
_isPerspective = !_isPerspective;
if (_isPerspective)
{

_graphics3d.setCamera(_cameraPerspective, _cameraTransform);
}
else
{
_graphics3d.setCamera(_cameraParallel, _cameraTransform);
}
break;

case GAME_B:
_isDepthBufferEnabled = !_isDepthBufferEnabled;
break;

case FIRE:
init();
break;

// no default
}

repaint();
}

// Create light.
_light = new Light();
_lightMode = LIGHT_OMNI;
setLightMode(_light, _lightMode);
Transform lightTransform = new Transform();
lightTransform.postTranslate(0.0f, 0.0f, 3.0f);
_graphics3d.resetLights();
_graphics3d.addLight(_light, lightTransform);

/**
* Sets the light mode.
*
* @param light light to be modified.
* @param mode light mode.
*/
protected void setLightMode(Light light, int mode)
{
switch (mode)
{
case LIGHT_AMBIENT:
light.setMode(Light.AMBIENT);
light.setIntensity(2.0f);
break;

case LIGHT_DIRECTIONAL:
light.setMode(Light.DIRECTIONAL);
light.setIntensity(1.0f);
break;

case LIGHT_OMNI:
light.setMode(Light.OMNI);
light.setIntensity(2.0f);
break;

case LIGHT_SPOT:
light.setMode(Light.SPOT);
light.setSpotAngle(20.0f);
light.setIntensity(2.0f);
break;

// no default
}
}

// Create appearance and the material.
_cubeAppearance = new Appearance();
_colorTarget = COLOR_DEFAULT;
setMaterial(_cubeAppearance, _colorTarget);

/**
* Sets the material according to the given target.
*
* @param appearance appearance to be modified.
* @param colorTarget target color.
*/
protected void setMaterial(Appearance appearance, int colorTarget)
{
Material material = new Material();

switch (colorTarget)
{
case COLOR_DEFAULT:
break;

case COLOR_AMBIENT:
material.setColor(Material.AMBIENT, 0x00FF0000);
break;

case COLOR_DIFFUSE:
material.setColor(Material.DIFFUSE, 0x00FF0000);
break;

case COLOR_EMISSIVE:
material.setColor(Material.EMISSIVE, 0x00FF0000);
break;

case COLOR_SPECULAR:

material.setColor(Material.SPECULAR, 0x00FF0000);
material.setShininess(2);
break;

// no default
}

appearance.setMaterial(material);
}

/** The cube's vertex positions (x, y, z). */
private static final byte[] VERTEX_POSITIONS = {
-1, -1,  1,    1, -1,  1,   -1,  1,  1,    1,  1,  1, // front
1, -1, -1,   -1, -1, -1,    1,  1, -1,   -1,  1, -1, // back
1, -1,  1,    1, -1, -1,    1,  1,  1,    1,  1, -1, // right
-1, -1, -1,   -1, -1,  1,   -1,  1, -1,   -1,  1,  1, // left

-1,  1,  1,    1,  1,  1,   -1,  1, -1,    1,  1, -1, // top
-1, -1, -1,    1, -1, -1,   -1, -1,  1,    1, -1,  1  // bottom
};

/** Indices that define how to connect the vertices to build
* triangles. */
private static final int[] TRIANGLE_INDICES = {
0,  1,  2,  3,   // front
4,  5,  6,  7,   // back
8,  9, 10, 11,   // right
12, 13, 14, 15,   // left
16, 17, 18, 19,   // top
20, 21, 22, 23,   // bottom
};

/** Lengths of triangle strips in TRIANGLE_INDICES. */
private static int[] TRIANGLE_LENGTHS = {
4, 4, 4, 4, 4, 4
};

/** File name of the texture. */
private static final String TEXTURE_FILE = "/texture.png";

/** The texture coordinates (s, t) that define how to map the
* texture to the cube. */
private static final byte[] VERTEX_TEXTURE_COORDINATES = {
0, 1,   1, 1,   0, 0,   1, 0,   // front
0, 1,   1, 1,   0, 0,   1, 0,   // back
0, 1,   1, 1,   0, 0,   1, 0,   // right
0, 1,   1, 1,   0, 0,   1, 0,   // left
0, 1,   1, 1,   0, 0,   1, 0,   // top
0, 1,   1, 1,   0, 0,   1, 0,   // bottom
};

/** First color for blending. */
private static final int COLOR_0 = 0x000000FF;

/** Second color for blending. */
private static final int COLOR_1 = 0x0000FF00;

/**
* Initializes the sample.
*/
protected void init()
{
// Get the singleton for 3D rendering.
_graphics3d = Graphics3D.getInstance();

// Create vertex data.
_cubeVertexData = new VertexBuffer();

VertexArray vertexPositions =
new VertexArray(VERTEX_POSITIONS.length/3, 3, 1);
vertexPositions.set(0, VERTEX_POSITIONS.length/3, VERTEX_POSITIONS);
_cubeVertexData.setPositions(vertexPositions, 1.0f, null);

VertexArray vertexTextureCoordinates =

new VertexArray(VERTEX_TEXTURE_COORDINATES.length/2, 2, 1);
vertexTextureCoordinates.set(0,
VERTEX_TEXTURE_COORDINATES.length/2, VERTEX_TEXTURE_COORDINATES);
_cubeVertexData.setTexCoords(0, vertexTextureCoordinates, 2.0f, null);

// Set default color for cube.
_cubeVertexData.setDefaultColor(COLOR_0);

// Create the triangles that define the cube; the indices point to
// vertices in VERTEX_POSITIONS.
_cubeTriangles = new TriangleStripArray(TRIANGLE_INDICES,
TRIANGLE_LENGTHS);

// Create a camera with perspective projection.
Camera camera = new Camera();
float aspect = (float) getWidth() / (float) getHeight();
camera.setPerspective(30.0f, aspect, 1.0f, 1000.0f);
Transform cameraTransform = new Transform();
cameraTransform.postTranslate(0.0f, 0.0f, 10.0f);
_graphics3d.setCamera(camera, cameraTransform);

// Rotate the cube so we can see three sides.
_cubeTransform = new Transform();
_cubeTransform.postRotate(20.0f, 1.0f, 0.0f, 0.0f);
_cubeTransform.postRotate(45.0f, 0.0f, 1.0f, 0.0f);

// Define an appearance object and set the polygon mode.
_cubeAppearance = new Appearance();
_polygonMode = new PolygonMode();
_isPerspectiveCorrectionEnabled = false;
_cubeAppearance.setPolygonMode(_polygonMode);

try
{
// Load image for texture and assign it to the appearance. The
// default values are: WRAP_REPEAT, FILTER_BASE_LEVEL/
// FILTER_NEAREST, and FUNC_MODULATE.
Image2D image2D = (Image2D) Loader.load(TEXTURE_FILE)[0];
_cubeTexture = new Texture2D(image2D);
_cubeTexture.setBlending(Texture2D.FUNC_DECAL);

// Index 0 is used because we have only one texture.
_cubeAppearance.setTexture(0, _cubeTexture);
}
catch (Exception e)
{
System.out.println("Error loading image " + TEXTURE_FILE);
e.printStackTrace();
}
}

/**
* Checks whether perspective correction is supported.
*
* @return true if perspective correction is supported, false otherwise.
*/
protected boolean isPerspectiveCorrectionSupported()
{
Hashtable properties = Graphics3D.getProperties();
Boolean supportPerspectiveCorrection =
(Boolean) properties.get("supportPerspectiveCorrection");

return supportPerspectiveCorrection.booleanValue();
}

/**
* Handles key presses.
*
* @param keyCode key code.
*/
protected void keyPressed(int keyCode)
{
switch (getGameAction(keyCode))
{
case LEFT:
_cubeTransform.postRotate(-10.0f, 0.0f, 1.0f, 0.0f);
break;

case RIGHT:
_cubeTransform.postRotate(10.0f, 0.0f, 1.0f, 0.0f);
break;

case FIRE:
init();
break;

case GAME_A:
if (isPerspectiveCorrectionSupported())
{
_isPerspectiveCorrectionEnabled = !_isPerspectiveCorrectionEnabled;
_polygonMode.setPerspectiveCorrectionEnable(
_isPerspectiveCorrectionEnabled);
}
break;

case GAME_B:
if (_cubeTexture.getWrappingS() == Texture2D.WRAP_CLAMP)
{
_cubeTexture.setWrapping(Texture2D.WRAP_REPEAT,
Texture2D.WRAP_REPEAT);
}
else
{
_cubeTexture.setWrapping(Texture2D.WRAP_CLAMP,
Texture2D.WRAP_CLAMP);
}
break;

case GAME_C:
if (_cubeVertexData.getDefaultColor() == COLOR_0)
{
_cubeVertexData.setDefaultColor(COLOR_1);
}
else
{
_cubeVertexData.setDefaultColor(COLOR_0);
}
break;

// no default
}

repaint();
}