Java 2 Micro Edition: Mobile 3D Graphics API 深入探索

需积分: 3 103 浏览量更新于2024-08-02 收藏 8.56MB PDF 举报

"本书是关于Mobile 3D Graphics API for Java 2 Micro Edition的英文版，主要探讨了在Java 2 Micro Edition (J2ME)平台上实现移动设备的三维图形渲染技术。JSR-184是Java Community Process (JCP)下的一个专家小组项目，致力于开发这个API，以提升移动设备的3D图形处理能力。" Java 2 Micro Edition（J2ME）是Java平台的一个子集，设计用于嵌入式设备和移动设备，如智能手机和功能手机。它提供了一个轻量级的框架，以便在资源有限的设备上运行应用程序。在J2ME中，3D图形处理是一个关键领域，因为它允许开发者创建更丰富、更吸引人的用户体验。本书基于JSR-184（Mobile 3D Graphics API for J2ME），这是一个标准化的API，旨在为J2ME平台提供3D图形编程接口。JSR（Java Specification Request）是JCP推动新特性和API标准化的过程。JSR-184由诺基亚公司领导，于2003年11月19日发布，标志着1.0版本的最终发布。这个API的目的是为了让开发者能够创建运行在J2ME实现上的3D应用，而无需在应用中直接实现规范的任何部分。使用JSR-184，开发者可以构建复杂的3D模型、场景和动画，从而在移动设备上实现游戏、虚拟现实和其他图形密集型应用。API可能包括了3D几何对象的表示、纹理映射、光照效果、视图控制以及图形渲染管线的管理等核心功能。这些功能使J2ME应用程序能够与桌面或游戏主机平台上的高端3D游戏相媲美，尽管在资源和性能上存在显著差异。值得注意的是，JSR-184提供了内部评估的许可，允许开发者查看、下载、使用和复制该规范，目的是为了开发运行在规范实现上的应用。但这些应用自身不能实现规范的任何部分，以确保对规范的合规使用。此外，规范包含了规格领先者的专有信息，因此必须按照许可证条款使用。通过学习本书，开发者将深入了解如何利用JSR-184来优化移动设备的3D图形性能，掌握如何在有限的硬件资源下创建高性能的3D应用程序。这不仅对移动游戏开发者有益，也为其他需要在小型设备上展示高级视觉效果的领域，如教育、工程和设计应用，提供了宝贵的指导。

javax.microedition.m3g

matrices.

• Diagram notation. The following common notation is used in diagrams that involve scene graph nodes

and node components.

Package Discovery

Because of its optional nature, this API may not always be available on every platform. Each profile and

platform may have their own methods for J2ME package discovery as there is no universal method existing at

this time. An additional method for package discovery of the Mobile 3D Graphics API is by using a system

properties query. To discover this package, call System.getProperty with a key of

microedition.m3g.version. If the API is present, the value returned is the version of the API (currently

“1.0”). If the API is not present then the key is also not present and null will be returned.

General implementation requirements

Dynamic range and accuracy

The floating point format used for input and output is the standard IEEE float, having an 8-bit exponent and a

24-bit mantissa normalized to [1.0, 2.0). To facilitate efficient operation without floating point hardware,

implementations are allowed to substitute more constrained representations internally. The internal

representation must satisfy the following requirements:

• The input range must be at least [2

-64

, 2

]. Any floating-point value in this range is legal as input to a

method that accepts floating point numbers. If the input value is not within that range, or is not a floating-

point number (NaN), the result is undefined.

• Elementary operations must have a range of at least [2

-64

, 2

]. If the operands and the result of an

elementary arithmetic operation are within this range, the operation must not overflow or underflow. If the

operands and/or the result are not within that range, the result is undefined.

• The precision must be at least 16 significant bits. Provided that both the operands and the result of an

elementary arithmetic operation are within the range specified above, the result must be accurate to at least

16 significant bits.

These requirements apply to all arithmetic operations in this API, except triangle rasterization and per-fragment

operations, such as depth buffering, blending, and interpolation of colors and texture coordinates. In particular,

the requirements apply to node transformations in the scene graph; vertex coordinate, texture coordinate and

normal vector transformations; picking; keyframe interpolation; mesh morphing; skinning; and all methods in

the Transform class.

Node

Component

Grey objects are "Nodes" -

groups or children of groups

White objects are components

Arrows indicate references.

These components are

referenced by the node.

Component Component

Components can reference other

components, and nodes can

reference other nodes.

javax.microedition.m3g

Blending, interpolation, comparisons and other operations on color, alpha and (screen-space) depth values must

have at least the same precision as the corresponding channel in the frame buffer. The minimum frame buffer

resolution is 1 bit for alpha and each color component, and 8 bits for depth. Of course, if some of the channels

do not exist, the corresponding values need not be computed.

All color and alpha blending operations are done component-wise and saturated to 1.0. In addition to the

general precision requirements, blending operations must also satisfy the following for all values of alpha and s

between [0, 1]:

alpha * s + (1 - alpha) * s = s

Correspondence of getters and setters

When querying the value of some property in the API, the returned value does not need to be exactly the same

that was set with the corresponding set method. Instead, it may be any value that produces an equivalent

result. The returned values are also not required to be in any “canonical” or “normalized” form. In the case of

node orientation, for example, there are a number of different axis-angle combinations that specify the same

orientation, and any one of them may be returned.

The returned value may also be an approximation of the original value, as long as the accuracy constraints for

the particular type of data are satisfied.

References to Objects

Unless otherwise stated, Object3Ds are held by reference, not by copying their data. Changes to the original

object therefore have immediate effect in the data structure as a whole. For example, changes to an Image2D

attached to the Background take effect without having to call the Background.setImage method again.

Where exceptions exist, these will be clearly documented as copying the values from the supplied Object3D.

Thread safety

Implementations must not crash or throw an exception as a result of being accessed from multiple threads at the

same time. However, the results of the requested operation in that case may be unpredictable.

No method in this API is allowed to block waiting for a resource, such as a rendering target, to be released. This

is to guarantee that no deadlock situations will occur. Also, any resources required by a method must be

released upon return. No method is allowed to leave its host object or other resources locked.

Pixel format conversion

Several different pixel formats are supported in rendering targets, textures, sprites, and background images.

Depending on the case, a mismatch between the source and destination pixel formats may require a format

conversion to be done. The general rules that are obeyed throughout the API are as follows:

• Luminance to RGB: The luminance value (L) is replicated to each of R, G and B.

• RGB to Luminance: Unspecified, but must take all components into account. For example, (R+G+B) / 3.

• Any missing luminance, color or alpha components are set to 1.0, unless explicitly stated otherwise.

More specific rules related to pixel formats are specified on a case-by-case basis in classes dealing with images

and the frame buffer. These include Graphics3D, Image2D, Texture2D, CompositingMode and Background.

Example applications

Two example MIDlets using the API are presented below. The first MIDlet is a pure immediate mode

application that displays a rotating, texture-mapped cube. It shows how to initialize a 3D graphics context, bind

it to a MIDP Canvas, and render some simple content with it. It also illustrates how to create a Mesh object

“manually”, that is, how to set up the coordinates, triangle connectivity, texture maps, and materials. In practice,

javax.microedition.m3g

(1) Immediate mode example MIDlet: Class MyCanvas

import javax.microedition.lcdui.*;

import javax.microedition.m3g.*;

public class MyCanvas extends Canvas {

private Graphics3D iG3D;

private Camera iCamera;

private Light iLight;

private float iAngle = 0.0f;

private Transform iTransform = new Transform();

private Background iBackground = new Background();

private VertexBuffer iVb; // positions, normals, colors, texcoords

private IndexBuffer iIb; // indices to iVB, forming triangle strips

private Appearance iAppearance; // material, texture, compositing, ...

private Material iMaterial = new Material();

private Image iImage;

/**

* Construct the Displayable.

public MyCanvas() {

// set up this Displayable to listen to command events

setCommandListener(new CommandListener() {

public void commandAction(Command c, Displayable d) {

if (c.getCommandType() == Command.EXIT) {

// exit the MIDlet

MIDletMain.quitApp();

}

});

try {

init();

}

catch(Exception e) {

e.printStackTrace();

}

/**

* Component initialization.

private void init() throws Exception {

// add the Exit command

addCommand(new Command(“Exit”, Command.EXIT, 1));

// get the singleton Graphics3D instance

iG3D = Graphics3D.getInstance();

// create a camera

iCamera = new Camera();

iCamera.setPerspective( 60.0f, // field of view

(float)getWidth()/ (float)getHeight(), // aspectRatio

1.0f, // near clipping plane

1000.0f ); // far clipping plane

// create a light

iLight = new Light();

iLight.setColor(0xffffff); // white light

iLight.setIntensity(1.25f); // overbright

// init some arrays for our object (cube)

// Each line in this array declaration represents a triangle strip for

// one side of a cube. The only primitive we can draw with is the

javax.microedition.m3g

// triangle strip so if we want to make a cube with hard edges we

// need to construct one triangle strip per face of the cube.

// 1 * * * * * 0

// * * *

// 3 * * * * * 2

// The ascii diagram above represents the vertices in the first line

// (the first tri-strip)

short[] vert = {

10, 10, 10, -10, 10, 10, 10,-10, 10, -10,-10, 10, // front

-10, 10,-10, 10, 10,-10, -10,-10,-10, 10,-10,-10, // back

-10, 10, 10, -10, 10,-10, -10,-10, 10, -10,-10,-10, // left

10, 10,-10, 10, 10, 10, 10,-10,-10, 10,-10, 10, // right

10, 10,-10, -10, 10,-10, 10, 10, 10, -10, 10, 10, // top

10,-10, 10, -10,-10, 10, 10,-10,-10, -10,-10,-10 }; // bottom

// create a VertexArray to hold the vertices for the object

VertexArray vertArray = new VertexArray(vert.length / 3, 3, 2);

vertArray.set(0, vert.length/3, vert);

// The per-vertex normals for the cube; these match with the vertices

// above. Each normal is perpendicular to the surface of the object at

// the corresponding vertex.

byte[] norm = {

0, 0, 127, 0, 0, 127, 0, 0, 127, 0, 0, 127,

0, 0,-127, 0, 0,-127, 0, 0,-127, 0, 0,-127,

-127, 0, 0, -127, 0, 0, -127, 0, 0, -127, 0, 0,

127, 0, 0, 127, 0, 0, 127, 0, 0, 127, 0, 0,

0, 127, 0, 0, 127, 0, 0, 127, 0, 0, 127, 0,

0,-127, 0, 0,-127, 0, 0,-127, 0, 0,-127, 0 };

// create a vertex array for the normals of the object

VertexArray normArray = new VertexArray(norm.length / 3, 3, 1);

normArray.set(0, norm.length/3, norm);

// per vertex texture coordinates

short[] tex = {

1, 0, 0, 0, 1, 1, 0, 1,

1, 0, 0, 0, 1, 1, 0, 1 };

// create a vertex array for the texture coordinates of the object

VertexArray texArray = new VertexArray(tex.length / 2, 2, 2);

texArray.set(0, tex.length/2, tex);

// the length of each triangle strip

int[] stripLen = { 4, 4, 4, 4, 4, 4 };

// create the VertexBuffer for our object

VertexBuffer vb = iVb = new VertexBuffer();

vb.setPositions(vertArray, 1.0f, null); // unit scale, zero bias

vb.setNormals(normArray);

vb.setTexCoords(0, texArray, 1.0f, null); // unit scale, zero bias

// create the index buffer for our object (this tells how to

// create triangle strips from the contents of the vertex buffer).

iIb = new TriangleStripArray( 0, stripLen );

// load the image for the texture

iImage = Image.createImage( “/texture.png” );

// create the Image2D (we need this so we can make a Texture2D)

Image2D image2D = new Image2D( Image2D.RGB, iImage );

剩余270页未读，继续阅读

geicuili

粉丝: 3
资源: 3

Java 2 Micro Edition: Mobile 3D Graphics API 深入探索

Java 2 Micro Edition的移动3D图形API规范

Java ME图像与游戏开发教程源码解析

Java 2 ME 3D图形API开发指南：移动设备专版

[Java.2.Micro.Edition.rar_Java书籍_Java_

Sonyericsson.Mobile.Java.3D.rar_j2me_j2me 3d_java 3d_mobile

Mobile Information Device Profile for Java 2 Micro Edition Version 2.0(MIDP 2.0).PDF

dg_java_3d_cn_r33a.rar_micro3D

基于J2ME (Java 2 Micro Edition)的手机游戏开发

J2ME.mobile.phone.games.LLK..rar_游戏_Java_

Mobile 3D Graphics with OpenGL ES and M3G

最新资源