在Irrlicht中使用Newton物理引擎SDK

*创建者：履霜坚冰  @7 a* v0 U  x" w
*说明：简单地英译汉，更多细节还望大家补充，如果愿意，请留下你的论坛ID，方便咨询9 k+ `# E5 C, }* ^. m
----
$ Z* x2 I2 V9 k) l9 v4 g" U4 X0 G, b4 j6 b. R4 L7 W. N2 H
本文还可以在：WIKI-  首页-->关于Irrlicht --->第三方Irrlicht例子 中找到
2 E2 Y% y% X( w# k I9 N  u( C*原文地址:http://www.irrlicht3d.org/wiki/i ... cCollisionDetection. ]( O% z4 [7 _$ r0 R
牛顿物理引擎：http://www.newtondynamics.com/
( C! a4 C( ~0 Q
, a! O; G" `0 L2 A1 t+ ^这个教程教我们使用牛顿物理引擎在Irrlicht中进行两个物体间简单的碰撞检测
/ v, c0 B; Y8 [0 R*首先，我们需要把Irrlicht引擎和Newton引擎以及它们的命名空间添加到我们的项目中. v- A4 x( _5 B" I( j
----  c, _1 S" d2 E$ ^( }2 U S
#include <irrlicht.h>
3 p5 L% I+ J1 G0 b$ Z#include <newton.h>0 Q9 J4 B C' }8 I5 z

+ g' }  f$ Z5 ~) [#ifdef WIN32
8 M, j. m) ?, M0 B) r#pragma comment(lib,"irrlicht.lib")
4 b+ e( S9 ]- M  J4 b, ?- ~#pragma comment(lib,"newton.lib")
+ ~$ _# }) P- W  A#endif/ o- Y8 u5 U  r9 d
" k% p: {! h( _) {  B1 h
using namespace irr;" L* G  |5 _) ?( a- k2 V
using namespace core;* T7 e6 X2 B3 h
using namespace scene;
, h w- J8 y! ~' C: rusing namespace video;
" d( Q" b# O6 |, S+ C----
' J( Y% }7 ^' _2 ^+ I2 B*不要忘了将Newton.dll和Irrlicht.dll拷贝到你的工程目录下。' H: t, W9 /( }! I: r8 t* @) /( /" s' o

* L9 k, b7 p9 L  D! M$ z; b  t
$ J9 m b8 J4 q8 n6 r. v9 R/ _" Y*我们需要一个结构体用来包含 IMeshSceneNode和NewtonCollision. NewtonCollision包含了碰撞的数学运算并且能够对Irrlicht中的两个IMesh进行比较.但它不含任何的位置,旋转和缩放信息.为了使用这些我们需要一个NewtonBody ,它在Newton引擎中就和Irrlicht中的IMeshSceneNode 一样,但是我们不在这里使用他们.
; E6 y' z" z2 x9 p' F
9 w8 e8 t, y1 N/ A
5 n3 T7 ~6 B' @. r. _6 N" m*用于碰撞检测的结构体. g( h3 y0 Y1 e8 w7 _3 F
----
; d# n% y2 z k% R/ D9 Gstruct SObject0 [: ]2 x$ [8 ~
{ 1 x5 O: j3 o" z- y
*Irrlicht的场景节点$ w+ i2 c" g. Z  i* c. b' P* B
IMeshSceneNode *irr_node;
( U9 _- a. m7 ~, ?, x) X* K% |, N8 g  t O7 m6 `0 O0 O
6 Y! p- |7 q4 {. d! L
//Newton 的碰撞对象
! i% G2 {3 w2 A. hNewtonCollision *nwtn_collision; " V5 T6 ]. v1 S: A. `
}; ( A- U6 q- F! u
----
0 j, G6 P) x4 k8 i6 q% w
' Y3 a7 T* O0 Z" F8 Z4 H*现在,我们需要写一个用于从IMesh对象中创建一个NewtonCollision 对象的函数.为了实现这个目标,我们只需要从IMesh中拷贝所有的顶点信息到我们的碰撞对象中即可.为了创建NewtonCollisions 我们还需要传一个指针给一个NewtonWorld对象,我们使用Newton引擎的每一样东西,都需要一个NewtonWorld.因为它描述了对象所存储的位置,它可以通过简单地调用NewtonCreate(NULL,NULL)函数创建.3 U9 J2 e" U- {+ ?4 c

. Z" E: Y3 M9 C, s5 j2 J//从irrlicht mesh中创建NewtonCollision的函数
. n4 A- E9 /6 A0 F----; D9 C* Q: ^# U; W
NewtonCollision *CreateCollisionFromMesh(NewtonWorld *nWorld, IMesh *irr_mesh )8 h9 ^2 j8 a! y8 |1 h, A- b2 L
{/ T- B8 ^0 H* /( G7 k
*//Mesh Buffer数量
7 c  u/ X) Q) j- eint nMeshBuffer = 0;
$ n! _$ ^' o2 C, Q' J$ m6 A6 |IMeshBuffer *mesh_buffer = NULL;' Z/ [5 ^" [. O' o
*//用于存储顶点的数组
B) L  P' a( @7 I/ i: Gfloat *vertices;
# u  X* A9 ^' U8 A" h, J
  ~' r# T8 j) j* E, T$ cu32 nVertices = 0;! l0 n6 ]$ `/ /

; Q' o: W9 k. O*//取得顶点数量
, T5 [# w; D. R" ]for( nMeshBuffer=0 ; nMeshBuffer < irr_mesh->getMeshBufferCount() ; nMeshBuffer++ )
1 v9 }. |/ A# G% B{
P6 ~. /9 v/ `% knVertices += irr_mesh->getMeshBuffer(nMeshBuffer)->getVertexCount();' q9 b! i! H+ W
}
$ A4 C7 H9 ~$ @" |+ {' `
( P1 g/ Q' t. ~" h1 }9 k1 I' ~4 K5 [  x: `8 ?
5 H2 A; a( c( g# W$ h" i5 p L
*//创建一个顶点缓冲  C8 ?8 s9 D+ ~8 Z' b+ F
vertices = new float[nVertices * 3];. B; V `; |% B; L1 f
u32 tmpCounter = 0;6 Z0 v# g# N3 X7 _6 _9 {

! F H, m9 o8 k" M) o8 J, |8 |$ b% Y/ p; n# k6 G6 e
*//取得(irr_)mesh buffers并拷贝面顶点% ]9 X' ]# h4 O" I1 Y) s P0 {
for( nMeshBuffer=0 ; nMeshBuffer < irr_mesh->getMeshBufferCount() ; nMeshBuffer++ )
0 z8 H* v4 H" S9 u- h" y0 U{
; J1 c7 Z! B1 P# ^: }
8 g N4 `- g; W) ~mesh_buffer = irr_mesh->getMeshBuffer(nMeshBuffer);
0 n1 M% m2 y0 M
6 ~9 e4 Q  l4 R8 `
7 c) h5 u  a% K( q6 m9 X$ T0 M# I*//取得顶点和索引的指针
* Q' F# m# C, o$ p9 S' Z- p7 iS3DVertex *S3vertices = (S3DVertex*)mesh_buffer->getVertices();
! F4 h) H0 p2 i: m1 o; m ~( l. m. ?' w6 Z7 J- V9 B. {
* N, / Q" g/ I6 n
7 c) t' p, W! I1 ]/ X. J
*//从MESH拷贝顶点到BUFFER
+ c9 e3 F2 S, k! a4 [# G9 I$ /for(int i=0; i<mesh_buffer->getVertexCount(); i++)
7 q- T8 V d0 _6 w  n/ P6 s{ 7 a" d, N4 Z1 b! j; m) {
/ d' f! `* e6 j3 a: Z5 O' w
vertices[tmpCounter++] = S3vertices.Pos.X;' }: T% r* n! ~7 r5 h h; n! T. ]& d
vertices[tmpCounter++] = S3vertices.Pos.Y;1 T+ ^' @4 ~4 H5 y
vertices[tmpCounter++] = S3vertices.Pos.Z; 4 ]) z% X2 u Z: v; J
} # z# Z7 x# @8 z# B# h( d
}
6 _) n2 o% Y" X9 D! k" x0 F# w i0 R$ b7 S; o' j
*//创建一个Newton碰撞对象! o" Y# r/ W, o
NewtonCollision *collision_obj = NewtonCreateConvexHull(nWorld,nVertices,vertices,sizeof(float)*3,NULL);
. b* Y0 E% k  V, l( k' k0 _ d5 b* v
. }9 T4 s- Z8 S: O; N# U
8 o1 v. V# Q. M0 a) u. v$ I*//删除顶点4 E7 i: C4 r# O3 |6 l
delete [] vertices;{ return collision_obj; } 6 R8 g% g0 ]8 Z0 V9 q- I$ {
----
3 D  q% a6 A" d
% d( v3 c0 V: q*NewtonCreateConvexHull创建一个动态的NewtonCollision对象.我们也可以用NewtonCreateTreeCollision函数创建树优化(tree optimized )的NewtonCollisions对象.优化的对象对大模型来说是很好的,因为它们会更快.不同于前一个函数,NewtonCollisions 被创建为一个静态对象,并且我们不能对两个树优化的对象作出碰撞检测反应.
+ I( U) N; A9 Z( G! C0 _
5 s! d4 [1 u# t8 k3 i# X. D) c! o7 S o2 s: `3 w
*为了创建一个树优化NewtonCollision 对象,我们需要拷贝所以的IMESH面,而不是顶点.  m" p6 /! j* h2 g

. g; K( L+ N6 t, D) Q9 }5 y* c, H- Z9 C8 Y( ^
*用于创建树优化NewtonCollision对象的函数.! ^6 e/ ?- A' F: b
-----
% _$ z P+ S$ ^8 x- Q" _1 C$ ~NewtonCollision *CreateTreeCollisionFromMesh(NewtonWorld *nWorld, IMesh *irr_mesh )- D8 k  /, z8 h; Z( X# K _
{
% F4 `. l% d; `8 N' Y. s/ G* |! r
*创建一个新的树优化MESH
- X* _1 [* x6 U2 E( f  N, K! gNewtonCollision *collision_obj = NewtonCreateTreeCollision(nWorld ,NULL);
, n3 R1 v1 ~% O/ k$ g( g3 ?0 @; ?  W+ N( {6 b, T* F+ U2 t

6 C. p  p3 U2 r U*//开始碰撞模型的构造
$ b. {7 C( N JNewtonTreeCollisionBeginBuild(collision_obj);$ w* W3 N; w, e- J

: D+ p$ }+ C6 D* p$ f4 D*// 模型BUFFER数量7 m) p# m/ ^( h: q, ^# Y
int nMeshBuffer = 0;. o( S, `  J6 ?: B; A
*//  顶点索引
+ i( v7 S. p% O3 m' Qint v_index[3] = {0,0,0}; 0 j6 ~5 ^; W- b
IMeshBuffer *mesh_buffer = NULL;
$ g/ L+ j+ q* v5 h; R# }. F*//数组用于存放3顶点0 I2 f) z3 m" j! |7 D l( E4 L
float array[9];
$ Y/ y2 D9 E7 E9 h/ |' H+ x) k, H7 M% D) e$ w: S, j# O! t+ M
; b) y* A  C* ?0 s% ~$ K
*取得(irr_)mesh buffers并拷贝三角面到碰撞模型
: J* d! P# [2 u$ Gfor( nMeshBuffer=0 ; nMeshBuffer < irr_mesh->getMeshBufferCount() ; nMeshBuffer++ ); x6 c- ~5 P0 O  N. L
{ 8 P0 R( I* k1 u' f3 I+ |9 g5 c
mesh_buffer = irr_mesh->getMeshBuffer(nMeshBuffer);$ u# d. z; U a0 G
2 D/ M, m" P$ Z; U
*取得顶点和索引指针
0 v* x$ W$ K" ?$ {, y+ }S3DVertex *vertices = (S3DVertex*)mesh_buffer->getVertices();
# n( X5 |2 S) }u16 *indices = mesh_buffer->getIndices();2 y0 e$ C  u* P# u- Y

2 d* o5 y2 a6 P2 l6 C. f( c: p) k8 b6 S- j
*填充碰撞模型( }8 a) o; b2 ^3 }. w, a9 R
for(int i=0; i<mesh_buffer->getIndexCount(); i+=3)2 B: L" {) I! g/ X4 s
{
3 K$ }* z8 U1 Yv_index[0] = indices[ i ];
2 p8 Y+ _+ V) W8 n3 B$ B3 ]( hv_index[1] = indices[i+1];! @/ x1 R0 Y) n5 D/ }. x
v_index[2] = indices[i+2];
. ]0 U5 T, {3 r% I9 Y, m2 o m+ a) F; J# _4 `2 m
*第一个顶点; c' S1 j( w7 ]
array[0] = vertices[ v_index[0] ].Pos.X;
; h; P; p" N6 U4 R8 Earray[1] = vertices[ v_index[0] ].Pos.Y;/ f9 c9 K) E4 I7 g/ @; o
array[2] = vertices[ v_index[0] ].Pos.Z;* G9 S: G: j9 ?9 d

8 S- ?" D$ p+ t% M1 m
; f5 /, e1 A/ @$ /2 _*第二个顶点+ ^5 x5 U' _$ l5 F1 O
array[3] = vertices[ v_index[1] ].Pos.X;
$ u+ J2 /. b) H! H2 N$ l7 H" Harray[4] = vertices[ v_index[1] ].Pos.Y;+ @3 Y) J1 h1 L  c  [+ s) U, k
array[5] = vertices[ v_index[1] ].Pos.Z;
# M, V Q, i  j+ h
% n$ t. h- b5 R- L. p" n
! c; s: f; {* Z+ M*第三个顶点5 w7 r8 j8 z Z
array[6] = vertices[ v_index[2] ].Pos.X; H6 K2 Q' L. i- @% h, a. ?
array[7] = vertices[ v_index[2] ].Pos.Y;/ q, ]3 n3 ]" z: j1 w( l
array[8] = vertices[ v_index[2] ].Pos.Z;
: z) k6 b- k: e7 A y$ /) A9 e
( A2 i( G7 x. l
' s% u Z2 |" J; s; @( L& z: O*增加新的面到碰撞模型/ U8 v# G/ K! /  q$ O
NewtonTreeCollisionAddFace(collision_obj, //将要增加面的碰撞模型
/ z: [* o+ L6 H2 O t& e- q2 E0 u3, //数组中的顶点数量
8 g4 e! F# ? Q; e% m0 s. m. u(float*)array, //顶点数组指针
$ Z- m  _0 s: {, r" `2 w# j' k4 H3*sizeof(float),//顶点大小
1 I2 T8 l: K1 N! w1); //面的ID! h# ]1 M- K! [; n! `# n* n
} * k/ Q" N$ ^! P0 T3 V; _# E
}5 q8 A8 o: f5 N: [$ b5 ]

! f4 {+ w! C" C/ Y6 D" u
) r$ g! H% ?$ P*结束碰撞模型的构造,设置用于优化的第1个和第2个参数) |" a+ L4 m, s2 K1 ~" p
NewtonTreeCollisionEndBuild(collision_obj,0);' ` }5 y3 p% X  _& n7 b+ w/ W
' Q6 t) r* f7 f }) I( Q
return collision_obj; + j9 ]# q4 H, e6 V0 i1 u. q
} 8 u7 o0 s, Q5 j+ _2 e
----' w3 P/ t* e" w
*前面的两个函数可以改良.通过调用IMeshBuffer::getVertexType()来确保我们使用了正确的数据和标准的顶点格式.我们需要的最后一个函数是CheckForCollision.它将决定我们的SObjects 是否横穿其它物体.如果它横穿了,返回TRUE.为了检测两个NewtonCollisions 对象间的碰撞,我们使用NewtonCollisionCollide. T: m5 [- W% s

' v. F  M2 Z4 K
* p5 c, B+ j1 i/ A# L*检测两个SObject的碰撞
; |8 T E3 o3 o+ c  z----
1 ^/ U5 E) l0 h! D. w/ z# abool CheckForCollision(NewtonWorld *nWorld, SObject *obj_A, SObject *obj_B)$ J# t' ^. P2 x1 c1 C" |/ u
{ % k) ?9 w* Y8 `/ k% S# w
//Matrix to store irr_node position
+ U6 |  v. c0 Y/ A) e5 X8 l: l*存储irr_node位置的矩阵
9 B8 V+ v" s* c. }; r- Cmatrix4 mat_A,mat_B;/ D  I2 n) N0 A( t$ ]$ ~  `1 m0 K
7 |" E( Z5 e7 V( C2 [
//Copy position
8 g4 V7 k# o8 T2 N+ u' y; Z! ?*复制位置1 t$ H7 x  u4 G  /  L
mat_A.makeIdentity();
' V2 Q) b, t3 s% K% Z* tmat_B.makeIdentity();  u( f" y8 I; m2 W
8 z9 c# z( y2 Y. v% F  b
mat_A.setTranslation(obj_A->irr_node->getPosition());
0 |8 D I, D- /# y4 l  X6 Fmat_B.setTranslation(obj_B->irr_node->getPosition());
" @$ A4 h2 J5 t5 c  P: I4 ~9 W- f% l; ?8 i/ e
const int nContacts = 2;: J/ I- f' k. B# z8 u
float contacts[3 * nContacts];. X0 _! l4 C2 c' /) K1 I
float normals[3 * nContacts];0 [; B+ G( w% i+ y! b
float penetration[ nContacts ];+ e$ Z% p) g8 x" M3 R8 U

' D% u/ l8 M1 Z1 R/ v# s/ }
+ A8 `( d. l; z; l/ @*检测两个碰撞模型的碰撞
2 i3 q' w7 [$ U2 w*返回连接的顶点数目
/ j- X. m- M8 T% b/ N1 V7 v* L: uint nHits = NewtonCollisionCollide( nWorld,nContacts,
1 c8 D; E- X' T. v) K7 gobj_A->nwtn_collision, (float*)mat_A[0],
* ?' q {. v# oobj_B->nwtn_collision, (float*)mat_B[0],
  x  {! j" m/ j0 l$ Ucontacts,   B) Q7 S/ /) X. _3 {" O: m$ c8 v
normals, 1 e; S6 E) l2 y0 h) A
penetration);3 E  A3 B3 V8 f: J* /

# y' ^7 K$ M6 j9 s$ t7 G! /9 q: D8 i. Y0 {) E$ a, ~
*if nHits > 0 表示碰撞. O7 E' A ^& w- k- t* b8 [# j
if( nHits > 0)
" h/ ?8 S8 y ?, }return true;
; {6 Y8 e [; z6 q) I
; Z; ^0 P5 G, N3 Oreturn false;
/ B6 Q; R5 B% c1 G$ P* P; Z  _}
+ /( o6 w* s# w i- S' y0 M----1 @8 l  F' I5 M) S
' [ R+ t$ `; s! J2 t1 o4 ^
*现在我们要做的唯一事情就是创建一个IrrlichtDevice 并且初始化我们的场景,我们将要创建两个SObjects并且像往常一样加载两个模型.首先我们把其中一个将放在中间,另一个从左移到右,反之亦然.如果CheckForCollision 返回true,我们将设置它的emessive颜色成红色来表示它们的接触,最后,我们需要清除所有的东西.
) r" z" G: o( y [4 R*为了运行这个程序,就需要两个模型,我使用Blender来创建一个icosphere 和一个立方体,并导出它们成.3ds格式,你也可以使用你自已的模型.# y- M" U, k  I% i+ u4 O7 s+ A
*推荐在碰撞检测中你使用低模.而不是节点模型.这样容易看见.这样可以加速程序的速度.. |5 Q0 |2 i, l! o
) M6 O' K: P `! r! W; W
----' o* p. M; m# `5 q( |; X; @2 _
int main()
% ^7 n  g7 y) U2 g# n{ 5 B* f7 p7 h4 C3 N
*创建irrlicht 设备
$ g8 E0 D. P, ?  A: P7 B; LIrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<s32>(800, 600), 16,
) Q5 W' |) ^$ n$ q Afalse, false, true, 0); + P: m4 W% e/ r; i
% o! q( @: x. w6 q4 C

/ }6 R! F9 `7 ^6 P/ a* j! [*创建newton world. k3 A8 {# K; P3 Z
NewtonWorld *nWorld = NewtonCreate(NULL,NULL);
6 v  G V1 t2 g. M& /- s$ W8 w" R* P3 `
$ m( B4 a; D Q: x0 k; d
*设置0用于准确的碰撞检测
4 O( Q$ f" A/ x3 v' i5 E5 k) h  h*1到n用于加速程序
* O6 T2 X1 h, l; z, H$ P5 wNewtonSetSolverModel(nWorld,1);8 Q* _ h) _2 M" /, f
- ]) Q+ l9 /( b

/ m) w/ Y2 B% q# J% t( R' [*设置WINDOWS标题,注意这里使用了'L',Irrlicht引擎在显示文本的时候使用宽字符5 h3 @% |5 v- E0 h/ f4 [: i8 e. }
device->setWindowCaption(L"Basic Collision Detection with Newton GD");  I* }. A5 D7 }8 L8 j9 v1 b% e/ `4 O

1 W# `6 y( X4 z0 E, z
Y4 N& i* R6 [0 i  b*取得一个图形设备的指针,场景管理器和GUI,以至于我们不用总是写
4 g% ~) t: Z$ W4 C, F) [# m*device->getVideoDriver(),
  W+ /" h, r+ E. O B. ^*device->getSceneManager()% c/ p% p( Q' ~7 G
*device->getGUIEnvironment().( Z1 /" A! Z$ X5 C

: e+ F; Y; ]4 B2 }IVideoDriver* driver = device->getVideoDriver();" B4 `3 Q' Y2 Q+ f6 H# I0 V3 u
ISceneManager* smgr = device->getSceneManager();$ Y$ a2 |$ A: z
//IGUIEnvironment* guienv = device->getGUIEnvironment();
$ n- /- z6 L  b% n1 M M& w  t7 T7 P  t! ~2 z

  e8 s7 _2 j, d2 k# c1 v% j+ A3 v! G# L

: A7 R9 X2 `) z. e' J9 ?% w*创建两个SObjects
, m4 f( `- m; G0 rSObject sphere;' L0 b F; h8 _; g" m% j
SObject cube;
# a1 ]$ G6 J2 q2 l$ h
2 c6 ?+ g# r9 J8 @) R  j1 h! v*加载模型并创建一个irrlicht 节点
M0 Q! t/ B: t9 R1 b* d* Z( _' ~sphere.irr_node = smgr->addMeshSceneNode(smgr->getMesh("sphere.3ds")->getMesh(0));- w0 W, A, E( }7 /) f' w4 ~
cube.irr_node = smgr->addMeshSceneNode(smgr->getMesh("cube.3ds")->getMesh(0));
5 o3 ?" G/ ~* ~- ]/ Psphere.irr_node->getMaterial(0).EmissiveColor.set(255,0,255,5);; N5 /% ^/ s7 z2 x
cube.irr_node->getMaterial(0).EmissiveColor.set(255,0,255,255);1 G$ i% h  h3 ]  m2 O z) k
2 p: Y* /; F- K

! H" a+ I: y% c1 l2 e*从irrlicht 创建一个碰撞模型
' d! F1 [* c) w) d2 F' W$ O) jsphere.nwtn_collision = CreateCollisionFromMesh(nWorld,sphere.irr_node->getMesh());5 M! `' f x* b+ }
cube.nwtn_collision = CreateCollisionFromMesh(nWorld,cube.irr_node->getMesh());# I6 v( m( z! x! i q" y

y* f7 n7 @; t( D2 |/ r J* x7 }" B2 v+ L" R& u& q. g1 s
*设置位置
0 {) c9 S5 R8 J- R* A! c( d4 x( `sphere.irr_node->setPosition(vector3df(-5,0,0));
3 Z4 G2 x) j5 x6 /) z o: e) Y# Ycube.irr_node->setPosition(vector3df(0,0,0));
: u  |3 l- /2 d' A6 // |1 W+ {. J1 C8 s3 x2 u
*增加摄相机
5 {9 C8 J, u$ C! Y; d  Ismgr->addCameraSceneNode(0, vector3df(0,1,-7), vector3df(0,0,0));
( U: x# Q3 /, P9 c3 e+ } Y7 H: x& g7 u8 J4 @+ L
*好了,现在我们设置好了场景,让我们绘制所有的东西.
; L* m* C! X% C) m% N3 t( c- p*我们用一个while()循环,直到设备不想再运行为止.当用户关闭容器或者用
5 Z% T2 d# m2 a9 b$ k3 {*ALT+F4关闭窗口
% E  c2 p. N; E' P: t5 o+ A4 z8 a

8 [( M- H) H. K  I5 W# I*定义节点要移动的位置" @3 s2 c7 d6 T4 /; |# m. W
float vel=0.1f;$ P1 G) `; v8 ]  V8 y0 n
$ w: u8 ]9 k6 _6 y, P, a
while(device->run()) X+ j3 ^! x/ T& u; E
{
  o6 ?3 o) Y5 v* B) P3 {* [  v+ B  ldriver->beginScene(true, true, SColor(0,200,200,200));
5 d8 H0 t1 e' J( h% U# T9 K
, b# L' e; N1 n* {! p usmgr->drawAll();: h, z. @' x( /8 w8 M5 V- L

9 f4 M/ P6 _4 b5 j$ ^; R% c2 xdriver->endScene();' a: _. ?6 O0 k8 U
0 Z) X6 r" a; ^
- a/ U) ^! l+ o- Y+ G" V- [. a
*让我们移动这个圆
/ |/ y5 T" f0 T2 x$ Gsphere.irr_node->setPosition(sphere.irr_node->getPosition()+vector3df(1,0,0)*vel);
; ?# s" T- V5 S+ pif(sphere.irr_node->getPosition().X > 5.5f)8 a2 k+ e' j3 u" J2 D4 r
vel = -0.05f; ! f/ T7 D% o2 b4 c3 n9 Y( i, s
if(sphere.irr_node->getPosition().X < -5.5f)
0 L( x- a0 h) w$ n  a+ x' E# xvel = 0.05f;
3 W, x4 C, Z% i5 x" a; e6 d
+ f* D; |" W6 O$ i+ l  d, P*检测碰撞并,如果发生了就设置为红色. o! M* b+ L# U* G( e7 B
if(CheckForCollision(nWorld,sphere,&cube)) / p1 k5 K: T" T) ]
cube.irr_node->getMaterial(0).EmissiveColor.set(255,255,0,0);
) [# M) o# U! m, Q8 Q9 ~else * u( O! }. J/ /: g
*使用蓝色
% h+ M4 u0 c4 w0 /" z( q- ecube.irr_node->getMaterial(0).EmissiveColor.set(255,0,0,255);
: `; y! }% x% ^3 h* ^% y4 T}
6 T2 e3 g3 k$ b/ ?: c5 j0 b3 `
" x" O# @) t/ O% t* /5 M0 ^+ n9 t7 J" n; K1 ]
*如果你不再需要了,那我们需要释放newton碰撞模型
( V* f$ K0 m# A# JNewtonReleaseCollision(nWorld, sphere.nwtn_collision);9 G, K6 |* D$ ?- d% /. u( s; M! e
NewtonReleaseCollision(nWorld, cube.nwtn_collision);
" r3 z4 n) w3 w' B7 V! h* n" o4 Z, Y4 ?0 l# E- h- x) b$ B

" h Q) Z- w3 ]- f*销毁newton world1 n5 K+ _/ E* Z# }( j6 q; b! Q
NewtonDestroy(nWorld);. z5 u3 {$ D6 m' m/ H: P

6 V% k; f% m  z: v; h4 X: jdevice->drop();
* r  y. p4 G0 I, n8 h: O( B" Q
: r/ e8 r u$ J. z# c- n) H( Qreturn 0;
% ?) |0 Z- ^7 Z; W+ v} $ t9 q# q' z+ w7 M$ {$ z
- Y1 v0 R- Y( @9 ^5 @
----. W% o. F: q1 Q* F/ q
*NewtonReleaseCollision 销毁NewtonCollision 对象(类似于Irrlicht中的drop()).如果你不再需要NewtonCollision 对象,你需要调用它.
3 H6 x8 S  W1 P# /*NewtonDestroy 销毁一个NewtonWorld.如果我们不再需要物理系统,则要调用他.
9 X9 _' v+ a+ Z' k' o# M*更多信息参见NewtonSDK文档
6 _* d! }0 S, E% P
3 Q) A# S) /1 L! }4 {" N原文:Xwan/ _$ K* c* T% L9 c
译:履霜坚冰# i$ k# U: n) r5 C
发表于: irrlicht3d中文官方论坛(3D网游开发论坛)http://www.irrlicht3d.cn