jme学习笔记例11

import com.jme.app.SimpleGame;
import com.jme.app.BaseGame;
import com.jme.renderer.Camera;
import com.jme.renderer.ColorRGBA;
import com.jme.scene.Node;
import com.jme.scene.Text;
import com.jme.scene.shape.Box;
import com.jme.scene.state.*;
import com.jme.input.*;
import com.jme.util.Timer;
import com.jme.util.TextureManager;
import com.jme.util.LoggingSystem;
import com.jme.system.DisplaySystem;
import com.jme.system.JmeException;
import com.jme.math.Vector3f;
import com.jme.image.Texture;
import com.jme.light.PointLight;
import java.util.logging.Level;
/**
* Started Date: Jul 29, 2004<br><br>
*
* Is used to demonstrate the inner workings of SimpleGame.
*
* @author Jack Lindamood
*/
public class HelloSimpleGame extends BaseGame {
public static void main(String[] args) {
HelloSimpleGame app = new HelloSimpleGame();
app.setDialogBehaviour(SimpleGame.ALWAYS_SHOW_PROPS_DIALOG);
app.start();
}
/** The camera that we see through. */
protected Camera cam;
/** The root of our normal scene graph. */
protected Node rootNode;
/** Handles our mouse/keyboard input. */
protected InputHandler input;
/** High resolution timer for jME. */
protected Timer timer;
/** The root node of our text. */
protected Node fpsNode;
/** Displays all the lovely information at the bottom. */
protected Text fps;
/** Simply an easy way to get at timer.getTimePerFrame(). */
protected float tpf;
/** True if the renderer should display bounds. */
protected boolean showBounds = false;
65
/** A wirestate to turn on and off for the rootNode */
protected WireframeState wireState;
/** A lightstate to turn on and off for the rootNode */
protected LightState lightState;
/** Location of the font for jME's text at the bottom */
public static String fontLocation = "com/jme/app/defaultfont.tga";
/**
* This is called every frame in BaseGame.start()
* @param interpolation unused in this implementation
* @see com.jme.app.AbstractGame#update(float interpolation)
*/
protected final void update(float interpolation) {
/** Recalculate the framerate. */
timer.update();
/** Update tpf to time per frame according to the Timer. */
tpf = timer.getTimePerFrame();
/** Check for key/mouse updates. */
input.update(tpf);
/** Send the fps to our fps bar at the bottom. */
fps.print("FPS: " + (int) timer.getFrameRate() + " - " +
display.getRenderer().getStatistics());
/** Call simpleUpdate in any derived classes of SimpleGame. */
simpleUpdate();
/**
Update controllers/render states/transforms/bounds for
rootNode.
*/
rootNode.updateGeometricState(tpf, true);
/**
If toggle_wire is a valid command (via key T), change
wirestates.
*/
if (KeyBindingManager
.getKeyBindingManager()
.isValidCommand("toggle_wire", false)) {
wireState.setEnabled(!wireState.isEnabled());
rootNode.updateRenderState();
}
/**
If toggle_lights is a valid command (via key L),
change lightstate.
*/
if (KeyBindingManager
.getKeyBindingManager()
.isValidCommand("toggle_lights", false)) {
lightState.setEnabled(!lightState.isEnabled());
rootNode.updateRenderState();
}
66
/**
If toggle_bounds is a valid command (via key B),
cha
nge bounds.
*/
if (KeyBindingManager
.getKeyBindingManager()
.isValidCommand("toggle_bounds", false)) { showBounds = !showBounds;
}
/**
If camera_out is a valid command (via key C), show camera
location.
*/
if (KeyBindingManager
.getKeyBindingManager()
.isValidCommand("camera_out", false)) {
System.err.println("Camera at: " + display.getRenderer().getCamera().getLocation()); } }
/**
* This is called every frame in BaseGame.start(), after update()
* @param interpolation unused in this implementation
* @see com.jme.app.AbstractGame#render(float interpolation)
*/
protected final void render(float interpolation) {
/**
Reset display's tracking information for
number of triangles/vertexes
*/
display.getRenderer().clearStatistics();
/** Clears the previously rendered information. */
display.getRenderer().clearBuffers();
/** Draw the rootNode and all its children. */
display.getRenderer().draw(rootNode);
/**
If showing bounds, draw rootNode's bounds, and the
bounds of all its children.
*/
if (showBounds)
display.getRenderer().drawBounds(rootNode);
/** Draw the fps node to show the fancy information at the bottom. */
display.getRenderer().draw(fpsNode);
/** Call simpleRender() in any derived classes. */ simpleRender(); }
/**
* Creates display, sets up camera, and binds keys.
* Called in BaseGame.start() directly after
* the dialog box.
* @see com.jme.app.AbstractGame#initSystem() */
67
protected final void initSystem() {
try {
/**
Get a DisplaySystem acording t
o the renderer
selected in the startup box.
*/
display = DisplaySystem.getDisplaySystem(properties.getRenderer());
/** Create a window with the startup box's information. */
display.createWindow(
properties.getWidth(),
properties.getHeight(),
properties.getDepth(),
properties.getFreq(),
properties.getFullscreen());
/**
Create a camera specific to the DisplaySystem that works
with the display's width and height
*/
cam =
display.getRenderer().createCamera(
display.getWidth(), display.getHeight());
} catch (JmeException e) {
/**
If the displaysystem can't be initialized correctly,
exit instantly.
*/
e.printStackTrace(); System.exit(1); }
/** Set a black background.*/ display.getRenderer().setBackgroundColor(ColorRGBA.black);
/** Set up how our camera sees. */
cam.setFrustumPerspective(45.0f,
(float) display.getWidth() /
(float) display.getHeight(), 1, 1000);
Vector3f loc = new Vector3f(0.0f, 0.0f, 25.0f);
Vector3f left = new Vector3f( -1.0f, 0.0f, 0.0f);
Vector3f up = new Vector3f(0.0f, 1.0f, 0.0f);
Vector3f dir = new Vector3f(0.0f, 0f, -1.0f);
/** Move our camera to a correct place and orientation. */
cam.setFrame(loc, left, up, dir);
/** Signal that we've changed our camera's location/frustum. */
cam.update();
/** Assign the camera to this renderer.*/ display.getRenderer().setCamera(cam);
/** Create a basic input controller. */
input = new FirstPersonHandler(this, cam, properties.getRenderer());
/** Signal to all key inputs they should work 10x faster. */
input.setKeySpeed(10f); input.setMouseSpeed(1f);
68
/** Get a high resolution timer for FPS updates. */
timer = Timer.getTimer(properties.getRenderer());
/** Sets the title of our displa
y. */
display.setTitle("SimpleGame");
/**
Signal to the renderer that it should keep track of
rendering information.
*/ display.getRenderer().enableStatistics(true);
/** Assign key T to action "toggle_wire". */
KeyBindingManager.getKeyBindingManager().set(
"toggle_wire",
KeyInput.KEY_T);
/** Assign key L to action "toggle_lights". */
KeyBindingManager.getKeyBindingManager().set(
"toggle_lights",
KeyInput.KEY_L);
/** Assign key B to action "toggle_bounds". */
KeyBindingManager.getKeyBindingManager().set(
"toggle_bounds",
KeyInput.KEY_B);
/** Assign key C to action "camera_out". */
KeyBindingManager.getKeyBindingManager().set(
"camera_out", KeyInput.KEY_C); }
/**
* Creates rootNode, lighting, statistic text, and other basic
* render states.
* Called in BaseGame.start() after initSystem().
* @see com.jme.app.AbstractGame#initGame()
*/
protected final void initGame() {
/** Create rootNode */ rootNode = new Node("rootNode");
/** Create a wirestate to toggle on and off. Starts disabled with
* default width of 1 pixel. */
wireState = display.getRenderer().createWireframeState();
wireState.setEnabled(false); rootNode.setRenderState(wireState); /** Create a ZBuffer to display pixels closest to the camera
above farther ones. */
ZBufferState buf = display.getRenderer().createZBufferState();
buf.setEnabled(true); buf.setFunction(ZBufferState.CF_LEQUAL); rootNode.setRenderState(buf);
// -- FPS DISPLAY // First setup alpha state
69
/** This allows correct blending of text and what is already
rendered below it*/
AlphaState as1 = display.getRenderer().createAlphaState();
as1.setBlendEnabled(true);
as1.setSrcFunction(AlphaState.SB_SRC_AL
PHA);
as1.setDstFunction(AlphaState.DB_ONE);
as1.setTestEnabled(true);
as1.setTestFunction(AlphaState.TF_GREATER); as1.setEnabled(true);
// Now setup font texture
TextureState font = display.getRenderer().createTextureState();
/** The texture is loaded from fontLocation */
font.setTexture(
TextureManager.loadTexture(
SimpleGame.class.getClassLoader().getResource(
fontLocation),
Texture.MM_LINEAR,
Texture.FM_LINEAR,
true)); font.setEnabled(true);
// Then our font Text object.
/** This is what will actually have the text at the bottom. */
fps = new Text("FPS label", "");
fps.setForceView(true); fps.setTextureCombineMode(TextureState.REPLACE);
// Finally, a stand alone node (not attached to root on purpose)
fpsNode = new Node("FPS node");
fpsNode.attachChild(fps);
fpsNode.setRenderState(font);
fpsNode.setRenderState(as1); fpsNode.setForceView(true);
// ---- LIGHTS
/** Set up a basic, default light. */
PointLight light = new PointLight();
light.setDiffuse(new ColorRGBA(1.0f, 1.0f, 1.0f, 1.0f));
light.setAmbient(new ColorRGBA(0.5f, 0.5f, 0.5f, 1.0f));
light.setLocation(new Vector3f(100, 100, 100)); light.setEnabled(true);
/** Attach the light to a lightState and the lightState to rootNode. */
lightState = display.getRenderer().createLightState();
lightState.setEnabled(true);
lightState.attach(light); rootNode.setRenderState(lightState);
/** Let derived classes initialize. */ simpleInitGame(); /** Update geometric and rendering information for both the
rootNode and fpsNode. */ rootNode.updateGeometricState(0.0f, true);
70
rootNode.updateRenderState();
fpsNode.updateGeometricState(0.0f, true);
fpsNode.updateRenderState();
}
protected void simpleInitGame() {
rootNode.attachChild(new Box("my box",
new Vector3f(0,0,0), new Vector3f(1,1,1)));
}
/**
* Can be defined in derived classes for custom updating.
* Called every frame in update.
*/ protected void simpleUpdate() {}
/**
* Can be defined in derived classes for custom rendering.
* Called every frame in render.
*/ protected void simpleRender() {}
/**
* unused
* @see com.jme.app.AbstractGame#reinit()
*/
protected void reinit() { }
/**
* Cleans up the keyboard.
* @see com.jme.app.AbstractGame#cleanup()
*/
protected void cleanup() {
LoggingSystem.getLogger().log(Level.INFO, "Cleaning up resources.");
input.getKeyBindingManager().getKeyInput().destroy(); InputSystem.getMouseInput().destroy(); } }

这个程序介绍了wireframestate, 定时器，draw(),摄像机创建，和显示系统创建，你将学到如何创建和定制你的入口类，
这将给simplegame带来一些神秘的作用.
    这么多的代码你感到无从下手吧，我们先看开头：
public static void main(String[] args) {
HelloSimpleGame app = new HelloSimpleGame();
app.setDialogBehaviour(SimpleGame.ALWAYS_SHOW_PROPS_DIALOG);
app.start();
} 
让我们看app.start()
public final void start() {
LoggingSystem.getLogger().log(Level.INFO, "Application started.");
try {
getAttributes();
initSystem();
assertDisplayCreated();
initGame();
//main loop
while (!finished && !display.isClosing()) {
//update game state, do not use interpolation parameter
update( -1.0f);
//render, do not use interpolation parameter
render( -1.0f);
//swap buffers
72
display.getRenderer().displayBackBuffer();
}
} catch (Throwable t) {
t.printStackTrace();
}
cleanup();
LoggingSystem.getLogger().log(Level.INFO, "Application ending.");
display.reset();
quit();
} 
别被这个吓着,我们看程序调用的顺序
1) getAttributes(): 得到用户选择的 monkey dialog box属性
2) initSystem(): 调用initSystem() 创建 “system” 部分
3) assertDisplayCreated(): 检查显示系统是否被创建
4) initGame(): 初始化游戏
5) while ():  游戏在什么地方运行
6) update(-1): 调用update()改变对象值
7) render(-1): 调用render() 绘制对象值
8) displayBackBuffer() : 显示全部以前绘制的
9) 循环直到完成
10) cleanup() -- quit() : 关闭应用
这个顺序是渲染系统的基础. 让我们看 initSystem():

protected final void initSystem() {
try {
/**
Get a DisplaySystem acording to the renderer
selected in the startup box.
*/
display = DisplaySystem.getDisplaySystem(properties.getRenderer());
/** Create a window with the startup box's information. */
display.createWindow(
properties.getWidth(),
properties.getHeight(),
properties.getDepth(),
properties.getFreq(),
properties.getFullscreen());

这里我们使用你输入的参数对游戏进行设置. 
注意DisplaySystem 是一个singleton类 我么需要初始化静态方法 getDisplaySystem.
对我们的眼睛来说什么颜色是最适合的? 下一步我们创建摄像机:
/**
Create a camera specific to the DisplaySystem that works
with
the display's width and height
*/
cam =
display.getRenderer().createCamera(
display.getWidth(),
display.getHeight());

用renderer’s给出的高和宽创建摄像机, 下面我简单地创建背景颜色,这里没有什么复杂的

/** Set a black background.*/
display.getRenderer().setBackgroundColor(ColorRGBA.black);  
现在你要为你的数学抓狂了!我们要建立一个视锥:
/** Set up how our camera sees. */
cam.setFrustumPerspective(45.0f,
(float) display.getWidth() /
(float) display.getHeight(), 1, 1000); 

jme的视锥是如何消隐对象的（比如一个三维物体的背面让其不可见）
请看下面的图片：



 连接的文章包含了一个非常好的如何消隐视锥的文章
这里我高度建议你如果对jme的内部机制感兴趣。你可以看到这个例子的视锥是一个被切割的金字塔
我定义视锥的视角是投影到屏幕的高和宽，看起来像图片中的表述，除了3d,每个事物看起来都如图片中
黄色区域，在定义我们的摄像机之后，我移动摄像机向后一个点：
Vector3f loc = new Vector3f(0.0f, 0.0f, 25.0f);
Vector3f left = new Vector3f( -1.0f, 0.0f, 0.0f);
Vector3f up = new Vector3f(0.0f, 1.0f, 0.0f);
74
Vector3f dir = new Vector3f(0.0f, 0f, -1.0f);
/** Move our camera to a correct place and orientation. */
cam.setFrame(loc, left, up, dir);
/** Signal that we've changed our camera's location/frustum. */
cam.update();
/** Assign the camera to this renderer.*/

方法setFrame() 定为了摄像头的位置, 
这个方向是根据摄像头上下决定的。 
摄像头的信息被设置后,
 我必须更新摄像头 (类似更新renderstates, geometry, 和 sounds)，设置摄像头被渲染. 下一步,我们创建
基础的移动按键使用一个预定义的类叫FirstPersonHandler

/** Create a basic input controller. */
input = new FirstPersonHandler(this, cam, properties.getRenderer());
/** Signal to all key inputs they should work 10x faster. */
input.setKeySpeed(10f);
input.setMouseSpeed(1f); 



 InputHandler类提供键盘和鼠标的控制，你的主程序你将制作一个扩展 InputHandler的类并定义你的输入句柄，
在这里，你的主游戏你将使用FirstPersonHandler，它定义鼠标和ADW键移动
注意我们设置key的速度是10倍快，通知FirstPersonHandler的readers10倍速度。
例如你可以让你的游戏切换走路和跑步两种状态，下面我使用一个timer更新我的FPS:
FirstPersonHa/** Get a high resolution timer for FPS updates. */
timer = Timer.getTimer(properties.getRenderer()); ndler extends InputHandler.

这个定时器使用'ticks'去获得非常精确的相隔帧的时间间隔，我们使用定时器去更新，最后，我设置一个
计数器并为显示设置一个标题：
/** Sets the title of our display. */
display.setTitle("SimpleGame");
/**
Signal to the renderer that it should keep track of
rendering information.
*/
display.getRenderer().enableStatistics(true); 


最后，我绑定T,L.B,C建和初始换系统，现在这个系统被初始化了，我设置游戏部分。
开始创建我的根节点，创建节点的渲染状态：
/** Create a wirestate to toggle on and off. Starts disabled with
* default width of 1 pixel. */
wireState = display.getRenderer().createWireframeState();
wireState.setEnabled(false);
75
rootNode.setRenderState(wireState);
/** Create a ZBuffer to display pixels closest to the camera
above farther ones. */
ZBufferState buf = display.getRenderer().createZBufferState();
buf.setEnabled(true);
buf.setFunction(ZBufferState.CF_LEQUAL);
rootNode.setRenderState(buf); 

首先是一个wirestate
The first is a wirestate. 
无论何时你按T的时候会使用，它绘制网线，不完全填充三角形。
随后我创建一个ZBufferState用来告诉rootnode如何渲染屏幕顶端的每个像素.绘制最接近你眼睛的方法，
 这是我设置buffer绘制LEQUAL开销要小，之后rootnode有它的渲染状态，为fpsnode显示屏幕顶端的文本，
第一个是beta状态：
/** This allows correct blending of text and what is already
rendered below it*/
AlphaState as1 = display.getRenderer().createAlphaState();
as1.setBlendEnabled(true);
as1.setSrcFunction(AlphaState.SB_SRC_ALPHA);
as1.setDstFunction(AlphaState.DB_ONE);
as1.setTestEnabled(true);
as1.setTestFunction(AlphaState.TF_GREATER);

同样我需要设置鼠标， 混合纹理的文本和背景绘制. 在alphastate之后, 我设置 text:
as1.setEnabled(true); 
// Now setup font texture
TextureState font = display.getRenderer().createTextureState();
/** The texture is loaded from fontLocation */
font.setTexture(
TextureManager.loadTexture(
SimpleGame.class.getClassLoader().getResource(
fontLocation),
Texture.MM_LINEAR,
Texture.FM_LINEAR,
true));
font.setEnabled(true); 

fpsNode把文本显示到屏幕上，下面，我创建屏幕底部的text对象  
// Then our font Text object.
/** This is what will actually have the text at the bottom. */
fps = new Text("FPS label", "");
fps.setForceView(true);
fps.setTextureCombineMode(TextureState.REPLACE); 

我使用它并允许用户更换字体。
默认情况下，只使用fpsNode的字体。

最后，我创建fpsNode。
我故意不分配到RootNode因为文本不应该被其他类型的对象一样控制。


// Finally, a stand alone node (not attached to root on purpose)
fpsNode = new Node("FPS node");
fpsNode.attachChild(fps);
fpsNode.setRenderState(font);
fpsNode.setRenderState(as1);
fpsNode.setForceView(true);
 
最后我创建灯光，灯光对象分配到LightStates---分配到Spatials,首先我创建灯光：
/** Set up a basic, default light. */
PointLight light = new PointLight();
light.setDiffuse(new ColorRGBA(1.0f, 1.0f, 1.0f, 1.0f));
light.setAmbient(new ColorRGBA(0.5f, 0.5f, 0.5f, 1.0f));
light.setLocation(new Vector3f(100, 100, 100));
light.setEnabled(true); 

光源定位在100,100,100和基础的环境弥漫色泽,下面把灯光分配到LightState并放进rootnode使它可以照亮
该节点的全部物体。
/** Attach the light to a lightState and the lightState to rootNode. */
lightState = display.getRenderer().createLightState();
lightState.setEnabled(true);
lightState.attach(light);
rootNode.setRenderState(lightState); 

geometry和renderstates被更新:
simpleInitGame();
/** Update geometric and rendering information for both the
rootNode and fpsNode. */
rootNode.updateGeometricState(0.0f, true);
rootNode.updateRenderState();
fpsNode.updateGeometricState(0.0f, true);

fpsNode.updateRenderState(); 

0是一个时间值传递给所有控制器应该更新的对象。

updateGeometricState和updateRenderState在几何形状或绘制状态被改变时调用。
正确设置游戏后，我们
进入一个更新/渲染的无限循环。
首先，让我们来看看更新。
在更新的第一件事情就是设置帧之间的时间：


/** Recalculate the framerate. */
timer.update();
/** Update tpf to time per frame according to the Timer. */
更新我的time对象在update被调用的前后，这样我就有每帧的准确间隔时间，检查键盘的输入，更新屏幕底部的文本
/** Check for key/mouse updates. */
input.update(tpf);
/** Send the fps to our fps bar at the bottom. */
fps.print("FPS: " + (int) timer.getFrameRate() + " - " +
display.getRenderer().getStatistics());
/** Call simpleUpdate in any derived classes of SimpleGame. */

在场景图改变后 ，更新场景图根节点下的所有几何信息：
/**
Update controllers/render states/transforms/bounds for
rootNode.
*/
rootNode.updateGeometricState(tpf, true);

最后是update()检查key的按键，注意如果一个键改变一个渲染状态，方法
updateRenderState() 被调用，在更新之后，渲染发生，第一步是清空渲染信息，
/**
Reset display's tracking information for
number of triangles/vertexes
*/
display.getRenderer().clearStatistics();

jme的统计信息包括顶点和三角形的统计，如果顶点或三角形被渲染，计数器会增加，每帧信息会被重置，
下面我们清空缓冲区
/** Clears the previously rendered information. */
display.getRenderer().clearBuffers();

这样我们就清除了以前绘制的东东，如果不这样做，每帧会重复叠加，下面绘制rootnode和fpsnode
/** Draw the rootNode and all its children. */
display.getRenderer().draw(rootNode);
/**
If showing bounds, draw rootNode's bounds, and the
bounds of all its children.

*/
if (showBounds)
display.getRenderer().drawBounds(rootNode);
/** Draw the fps node to show the fancy information at the bottom. */
display.getRenderer().draw(fpsNode);
/** Call simpleRender() in any derived classes. */
simpleRender();