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

需积分: 3 183 浏览量更新于2024-07-25 收藏 8.56MB PDF 举报

Java 2 Micro Edition (J2ME) 是一套专为移动设备设计的轻量级Java平台，旨在简化移动应用开发，尤其是针对手机和其他嵌入式设备。在这个框架下，"Mobile 3D Graphics API for Java 2 Micro Edition" 版本1.0（发布日期：2003年11月19日）是JSR-184专家组（JSR-184 Expert Group）为J2ME提供的一个重要扩展，致力于为移动设备提供3D图形处理能力。该规范的主要目标是使开发者能够在资源受限的环境下创建具有三维视觉效果的应用程序，如游戏、图表和图形用户界面。这个API允许开发人员利用Java语言进行有限的3D图形渲染，包括几何形状、纹理贴图和光照处理，但必须注意，由于设备性能的限制，其功能相较于桌面或台式机上的3D图形API较为有限。在使用Mobile 3D Graphics API时，开发者需要遵循严格的版权通知和许可条款。Nokia Corporation作为规范领导方，提供了非独家、不可转让且全球范围内的有限许可，仅限于内部评估目的，即为了开发那些运行在符合该API规范的实现环境中的应用程序。这些应用程序不能包含API的部分实现，且必须按照许可协议使用，尊重Nokia及其知识产权。开发者在开发过程中需要注意，由于硬件限制，API可能不支持复杂的3D场景和计算密集型操作，因此需要优化代码以适应移动设备的性能要求。此外，因为这是最终发布的规范，所以它是稳定和成熟的，但随着技术的发展，可能会有后续版本来扩展或改进功能。 Mobile 3D Graphics API for Java 2 Micro Edition为移动开发者提供了一套关键工具，帮助他们在移动平台上实现基本的3D体验，同时确保了跨设备的一致性和兼容性。对于那些寻求在资源有限的环境中创造引人注目视觉效果的工程师来说，理解并掌握这一API是至关重要的。

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页未读，继续阅读

kekok

粉丝: 4
资源: 155

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

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

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

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

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

Mobile 3D Graphics with OpenGL ES and M3G

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

dg_java_3d_cn_r33a.rar_micro3D

[JSR-184][3D编程指南]Part I: Quick jump into the world of Mobile Java 3D programming

Java手机API开发

诺基亚Java用户界面API程序员指南

最新资源