LZScene

NewtonImport.pas
984 строки · 89.3 Кб
Перенос по словам
1
{                                                                            
2
 Newton Game Dynamics Header Translation (Delphi/FreePascal)                  
3
  Newton Version 3.14 
4
  Generated by NewtonDoc on 31/03/2017 16:17:44  
5

6

7
********************************************************************************
8
*                                                                              *
9
* Copyright (c) <2003-2016> <Julio Jerez, Newton Game Dynamics>                *
10
*                                                                              *
11
* This software is provided 'as-is', without any express or implied            *
12
* warranty. In no event will the authors be held liable for any damages        *
13
* arising from the use of this software.                                       *
14
*                                                                              *
15
* Permission is granted to anyone to use this software for any purpose,        *
16
* including commercial applications, and to alter it and redistribute it       *
17
* freely, subject to the following restrictions:                               *
18
*                                                                              *
19
* 1. The origin of this software must not be misrepresented; you must not      *
20
* claim that you wrote the original software. If you use this software         *
21
* in a product, an acknowledgment in the product documentation would be        *
22
* appreciated but is not required.                                             *
23
*                                                                              *
24
* 2. Altered source versions must be plainly marked as such, and must not be   *
25
* misrepresented as being the original software.                               *
26
*                                                                              *
27
* 3. This notice may not be removed or altered from any source distribution.   *
28
*                                                                              *
29
********************************************************************************
30
}
31

32
unit NewtonImport;
33

34
{== Local Defines ==
35
  __NONDELPHI__            - Enables compatiblity with compilers other than Delphi.
36
                             Note that pascaldefines.inc and newtonpascal.inc
37
                             are protected under the Mozilla Public License.
38

39
 == Conditionals ==
40
 Declare the Following in Projects->Options->Conditionals to enable them:
41
  __USE_DOUBLE_PRECISION__ - Toggles Double Precision. DLL used must match this setting.
42

43
 == Local Defines ==}
44
 //{$DEFINE __NONDELPHI__}
45

46

47

48
{$IFDEF __NONDELPHI__}
49
 {$I pascaldefines.inc}
50
{$ENDIF}
51

52
interface
53

54
{$IFDEF __NONDELPHI__}
55
 {$I newtonpascal.inc}
56
{$ELSE}
57
 const
58
 {$IFDEF __USE_DOUBLE_PRECISION__}
59
  NEWTON_API = 'newtond.dll';
60
 {$ELSE}
61
  NEWTON_API = 'newton.dll';
62
 {$ENDIF}
63
{$ENDIF}
64

65
 NEWTON_MAJOR_VERSION = 3;
66
 NEWTON_MINOR_VERSION = 14;
67
 NEWTON_BROADPHASE_DEFAULT = 0;
68
 NEWTON_BROADPHASE_PERSINTENT = 1;
69
 NEWTON_DYNAMIC_BODY = 0;
70
 NEWTON_KINEMATIC_BODY = 1;
71
 SERIALIZE_ID_SPHERE = 0;
72
 SERIALIZE_ID_CAPSULE = 1;
73
 SERIALIZE_ID_CYLINDER = 2;
74
 SERIALIZE_ID_CHAMFERCYLINDER = 3;
75
 SERIALIZE_ID_BOX = 4;
76
 SERIALIZE_ID_CONE = 5;
77
 SERIALIZE_ID_CONVEXHULL = 6;
78
 SERIALIZE_ID_NULL = 7;
79
 SERIALIZE_ID_COMPOUND = 8;
80
 SERIALIZE_ID_TREE = 9;
81
 SERIALIZE_ID_HEIGHTFIELD = 10;
82
 SERIALIZE_ID_CLOTH_PATCH = 11;
83
 SERIALIZE_ID_DEFORMABLE_SOLID = 12;
84
 SERIALIZE_ID_USERMESH = 13;
85
 SERIALIZE_ID_SCENE = 14;
86
 SERIALIZE_ID_FRACTURED_COMPOUND = 15;
87

88
type
89
{$IFDEF __USE_DOUBLE_PRECISION__}
90
 dFloat                       = Double;
91
{$ELSE}
92
 dFloat                       = Single;
93
{$ENDIF}
94
 dFloat64                     = Double;
95
 dLong                        = Int64;
96

97
 PdFloat                      = ^dFloat;
98
 PdFloat64                    = ^dFloat64;
99
 PdLong                       = ^dLong;
100

101
 NewtonMesh                   = ^Pointer;
102
 NewtonBody                   = ^Pointer;
103
 NewtonWorld                  = ^Pointer;
104
 NewtonJoint                  = ^Pointer;
105
 NewtonMaterial               = ^Pointer;
106
 NewtonCollision              = ^Pointer;
107
// NewtonSceneProxy           = ^Pointer;
108
 //NewtonSkeletonContainer      = ^Pointer;
109
 NewtonDeformableMeshSegment  = ^Pointer;
110
 NewtonFracturedCompoundMeshPart = ^Pointer;
111

112
 NewtonSerializeHandle        = ^Pointer;
113
 NewtonMeshHandle             = ^Pointer;
114
 NewtonMeshVertex             = ^Pointer;
115
 NewtonMeshPoint              = ^Pointer;
116
 NewtonMeshEdge               = ^Pointer;
117
 NewtonMeshFace               = ^Pointer;
118
 NewtonListener               = ^Pointer;
119

120
 TNewtonBoxParam = Packed Record
121
  m_x,
122
  m_y,
123
  m_z                    : dFloat;
124
 end;
125

126
 TNewtonSphereParam = Packed Record
127
  m_radio                : dFloat;
128
 end;
129

130
 TNewtonCylinderParam = Packed Record
131
  m_radio,
132
  m_height               : dFloat;
133
 end;
134

135
 TNewtonCapsuleParam = Packed Record
136
  m_radio,
137
  m_height               : dFloat;
138
 end;
139

140
 TNewtonConeParam = Packed Record
141
  m_radio,
142
  m_height               : dFloat;
143
 end;
144

145
 TNewtonTaperedCapsuleParam = Packed Record
146
  m_radio0,
147
  m_radio1,
148
  m_height               : dFloat;
149
 end;
150

151

152
 TNewtonTaperedCylinderParam = Packed Record
153
  m_radio0,
154
  m_radio1,
155
  m_height               : dFloat;
156
 end;
157

158
 TNewtonChamferCylinderParam = Packed Record
159
  m_radio,
160
  m_height               : dFloat;
161
 end;
162

163
 TNewtonConvexHullParam = Packed Record
164
  m_vertexCount,
165
  m_vertexStrideInBytes,
166
  m_faceCount            : Integer;
167
  m_vertex               : PdFloat;
168
 end;
169

170

171
 TNewtonCompoundCollisionParam = Packed Record
172
  m_chidrenCount         : Integer;
173
 end;
174

175

176
 TNewtonCollisionTreeParam = Packed Record
177
  m_vertexCount,
178
  m_indexCount           : Integer;
179
 end;
180

181
 TNewtonDeformableMeshParam = Packed Record
182
  m_vertexCount,
183
  m_triangleCount,
184
  m_vertexStrideInBytes  : Integer;
185
  m_indexList            : PWord;
186
  m_vertexList           : PdFloat;
187
 end;
188

189

190
 TNewtonHeightFieldCollisionParam = Packed Record
191
  m_width,
192
  m_height,
193
  m_gridsDiagonals,
194
  m_elevationDataType     : Integer;// 0 = 32 bit floats, 1 = unsigned 16 bit integers
195
  m_verticalScale         : dFloat;
196
  m_horizonalScale_x : dFloat;
197
  m_horizonalScale_z : dFloat;
198
  m_horizonalDisplacementScale_x : dFloat;
199
  m_horizonalDisplacementScale_z : dFloat;
200
  m_vertialElevation      : Pointer;
201
  m_horizotalDisplacement : PSmallInt;
202
  m_atributes             : PShortInt;
203
 end;
204

205
 TNewtonSceneCollisionParam = Packed Record
206
  m_childrenProxyCount   : Integer;
207
 end;
208

209
 TNewtonCollisionNullParam = packed record
210
 end;
211

212
 NewtonCollisionInfoRecord = ^TNewtonCollisionInfoRecord;
213
 TNewtonCollisionInfoRecord = Packed Record
214
  m_offsetMatrix         : Array [0..3,0..3] of dFloat;
215
  m_collisionType,    // tag id to identify the collision primitive
216
  m_collisionUserID      : Integer;
217

218
  case Integer of
219
       SERIALIZE_ID_SPHERE           : (sdSphere             : TNewtonSphereParam);
220
       SERIALIZE_ID_CAPSULE          : (sdCapsule            : TNewtonCapsuleParam);
221
	   SERIALIZE_ID_CYLINDER         : (sdCylinder           : TNewtonCylinderParam);
222
       SERIALIZE_ID_CHAMFERCYLINDER  : (sdChamferCylinder    : TNewtonChamferCylinderParam);
223
       SERIALIZE_ID_BOX              : (sdBox                : TNewtonBoxParam);
224
       SERIALIZE_ID_CONE             : (sdCone               : TNewtonConeParam);
225
       SERIALIZE_ID_CONVEXHULL       : (sdConvexHull         : TNewtonConvexHullParam);
226
       SERIALIZE_ID_NULL             : (sdNull               : TNewtonCollisionNullParam);
227
       SERIALIZE_ID_COMPOUND         : (sdCompound           : TNewtonCompoundCollisionParam);
228
       SERIALIZE_ID_TREE             : (sdTree               : TNewtonCollisionTreeParam);
229
       SERIALIZE_ID_HEIGHTFIELD      : (sdHeightField        : TNewtonHeightFieldCollisionParam);
230
       SERIALIZE_ID_DEFORMABLE_SOLID : (sdDeformableMesh     : TNewtonDeformableMeshParam);
231
       SERIALIZE_ID_USERMESH         : (sdUserMesh           : Array[0..63] of dFloat);
232
       SERIALIZE_ID_SCENE            : (sdSceneCollision     : TNewtonSceneCollisionParam);
233
  end;
234

235
 NewtonJointRecord = ^TNewtonJointRecord;
236
 TNewtonJointRecord = Packed Record
237
  m_attachmenMatrix_0    : Array [0..3,0..3] of dFloat;
238
  m_attachmenMatrix_1    : Array [0..3,0..3] of dFloat;
239
  m_minLinearDof         : Array [0..2] of dFloat;
240
  m_maxLinearDof         : Array [0..2] of dFloat;
241
  m_minAngularDof        : Array [0..2] of dFloat;
242
  m_maxAngularDof        : Array [0..2] of dFloat;
243
  m_attachBody_0         : NewtonBody;
244
  m_attachBody_1         : NewtonBody;
245
  m_extraParameters      : Array [0..63] of dFloat;
246
  m_bodiesCollisionOn    : Integer;
247
  m_descriptionType      : Array [0..127] of ShortInt;
248
 end;
249

250
 NewtonUserMeshCollisionCollideDesc = ^TNewtonUserMeshCollisionCollideDesc;
251
 TNewtonUserMeshCollisionCollideDesc = Packed Record
252
  m_boxP0,                                              // lower bounding box of intersection query in local space
253
  m_boxP1,                                              // upper bounding box of intersection query in local space
254
  m_m_boxDistanceTravel  : Array [0..3] of dFloat;      // max distance that box bpxP0 and boxP1 can travel on this timestep, used this for continue collision mode.
255
                                                        // used this for continue collision mode
256
  m_threadNumber,                                       // current thread executing this query
257
  m_faceCount,                                          // the application should set here how many polygons intersect the query box
258
  m_vertexStrideInBytes  : Integer;                     // the application should set here the size of each vertex
259
  m_skinThickness        : dFloat;                      // this is the minimum skin separation specified by the material between these two colliding shapes
260
  m_userData             : Pointer;                     // user data passed to the collision geometry at creation time
261

262
  m_objBody,                                            // pointer to the colliding body
263
  m_polySoupBody         : NewtonBody;                  // pointer to the rigid body owner of this collision tree
264
  m_objCollision,                                       // collision shape of the colliding body, (no necessarily the collision of m_objBody)
265
  m_polySoupCollision    : NewtonCollision;             // collision shape of teh collsion tree, (no necessarily the collision of m_polySoupBody)
266

267
  m_vertex               : PdFloat;                     // the application should set here the pointer to the global vertex of the mesh.
268
  m_faceIndexCount,                                     // the application should set here the pointer to the vertex count of each face.
269
  m_faceVertexIndex      : PInteger;                    // the application should set here the pointer index array for each vertex on a face.
270
                                                        // the format of a face is I0, I1, I2, I3, ..., M, N, E0, E1, E2, ..., A
271
                                                        // I0, I1, I2, .. are the indices to the vertex, relative to m_vertex pointer
272
                                                        // M is the index to the material sub shape id
273
                                                        // N in the index to the vertex normal relative to m_vertex pointer
274
                                                        // E0, E1, E2, ... are the indices of the the face normal that is shared to that face edge, when the edge does not share a face normal then the edge index is set to index N, which the index to the face normal
275
                                                        // A is and estimate of the largest diagonal of the face, this used internally as a hint to improve floating point accuracy and algorithm performance.
276
 end;
277

278
 NewtonWorldConvexCastReturnInfo = ^TNewtonWorldConvexCastReturnInfo;
279
 TNewtonWorldConvexCastReturnInfo = Packed Record
280
  m_point,                                              // collision point in global space
281
  m_normal{,                                             // surface normal at collision point in global space
282
  m_normalOnHitPoint}     : Array [0..3] of dFloat;      // surface normal at the surface of the hit body,
283
                                                        // is the same as the normal calculated by a ray cast hitting the body at the hit point
284
  m_contactID            : Integer;                     // collision ID at contact point
285
  m_hitBody              : NewtonBody;                  // body hit at contact point
286
  m_penetration          : dFloat;                      // contact penetration at collision point
287
 end;
288

289
 NewtonUserMeshCollisionRayHitDesc = ^TNewtonUserMeshCollisionRayHitDesc;
290
 TNewtonUserMeshCollisionRayHitDesc = Packed Record
291
  m_p0,                                                 // ray origin in collision local space
292
  m_p1,                                                 // ray destination in collision local space
293
  m_normalOut            : Array [0..3] of dFloat;      // copy here the normal at the ray intersection
294
  m_userIdOut            : dLong;                       // copy here a user defined id for further feedback
295
  m_userData             : Pointer;                     // user data passed to the collision geometry at creation time
296
 end;
297

298
 NewtonHingeSliderUpdateDesc = ^TNewtonHingeSliderUpdateDesc;
299
 TNewtonHingeSliderUpdateDesc = Packed Record
300
  m_accel,
301
  m_minFriction,
302
  m_maxFriction,
303
  m_timestep             : dFloat;
304
 end;
305

306
 NewtonUserContactPoint = ^TNewtonUserContactPoint;
307
 TNewtonUserContactPoint = Packed Record
308
  m_point,
309
  m_normal               : Array [0..3] of dFloat;
310
  m_shapeId0             : dLong;
311
  m_shapeId1             : dLong;
312
  m_penetration          : dFloat;
313
  m_unused               : Array [0..2] of Integer;
314
 end;
315

316
 // data structure for interfacing with NewtonMesh
317
 NewtonMeshDoubleData = ^TNewtonMeshDoubleData;
318
 TNewtonMeshDoubleData = Packed Record
319
  m_data          : PdFloat64;
320
  m_indexList     : PInteger;
321
  m_strideInBytes : Integer;
322
 end;
323
 
324
 NewtonMeshFloatData = ^TNewtonMeshFloatData;
325
 TNewtonMeshFloatData = Packed Record
326
  m_data          : PdFloat;
327
  m_indexList     : PInteger;
328
  m_strideInBytes : Integer;
329
 end;
330
 
331
 NewtonMeshVertexFormat = ^TNewtonMeshVertexFormat;
332
 TNewtonMeshVertexFormat = Packed Record
333
 // int m_faceCount : Integer;
334
  m_faceIndexCount : PInteger;
335
  m_faceMaterial : PInteger;
336
  m_vertex : NewtonMeshDoubleData;
337
  m_normal : NewtonMeshFloatData;
338
  m_binormal : NewtonMeshFloatData;
339
  m_uv0 : NewtonMeshFloatData;
340
  m_uv1 : NewtonMeshFloatData;
341
  m_vertexColor : NewtonMeshFloatData;
342
 end;
343
 
344
 // Newton callback functions
345
 NewtonAllocMemory                          = ^TNewtonAllocMemory;
346
 TNewtonAllocMemory                          = function (sizeInBytes : Integer) : Pointer;
347
 NewtonFreeMemory                           = ^TNewtonFreeMemory;
348
 TNewtonFreeMemory                           = procedure (ptr : Pointer; sizeInBytes : Integer);
349

350
 NewtonWorldDestructorCallback              = ^TNewtonWorldDestructorCallback;
351
 TNewtonWorldDestructorCallback              = procedure (const World : NewtonWorld);
352

353
 NewtonWorldListenerBodyDestroyCallback          = ^TNewtonWorldListenerBodyDestroyCallback;
354
 TNewtonWorldListenerBodyDestroyCallback          = procedure (const World : NewtonWorld; listenerUserData : Pointer; body : NewtonBody);
355

356
 NewtonWorldUpdateListenerCallback          = ^TNewtonWorldUpdateListenerCallback;
357
 TNewtonWorldUpdateListenerCallback          = procedure (const World : NewtonWorld; listenerUserData : Pointer; timestep : dFloat);
358
 NewtonWorldDestroyListenerCallback         = ^TNewtonWorldDestroyListenerCallback;
359
 TNewtonWorldDestroyListenerCallback         = procedure (const World : NewtonWorld; listenerUserData : Pointer);
360

361
 NewtonGetTimeInMicrosencondsCallback                = ^TNewtonGetTimeInMicrosencondsCallback;
362
 TNewtonGetTimeInMicrosencondsCallback               = function () : dLong;
363

364
 NewtonSerializeCallback                    = ^TNewtonSerializeCallback;
365
 TNewtonSerializeCallback                    = procedure (Handle : NewtonSerializeHandle; const buffer : Pointer; size : Integer);
366
 NewtonDeserializeCallback                  = ^TNewtonDeserializeCallback;
367
 TNewtonDeserializeCallback                  = procedure (Handle : NewtonSerializeHandle; buffer : Pointer; size : Integer);
368

369
 NewtonOnBodySerializationCallback          = ^TNewtonOnBodySerializationCallback;
370
 TNewtonOnBodySerializationCallback          = procedure (body : NewtonBody; userData : Pointer; Callback : NewtonSerializeCallback; Handle : NewtonSerializeHandle);
371
 NewtonOnBodyDeserializationCallback        = ^TNewtonOnBodyDeserializationCallback;
372
 TNewtonOnBodyDeserializationCallback        = procedure (body : NewtonBody; userData : Pointer; Callback : NewtonDeserializeCallback; Handle : NewtonSerializeHandle);
373

374
 NewtonOnJointSerializationCallback         = ^TNewtonOnJointSerializationCallback;
375
 TNewtonOnJointSerializationCallback         = procedure (joint : NewtonJoint; funct : NewtonSerializeCallback; serializeHandle : NewtonSerializeHandle);
376

377
 NewtonOnJointDeserializationCallback       = ^TNewtonOnJointDeserializationCallback;
378
 TNewtonOnJointDeserializationCallback       = procedure (body0 : NewtonBody; body1 : NewtonBody; funct : NewtonDeserializeCallback; serializeHandle : NewtonSerializeHandle);
379

380
 NewtonOnUserCollisionSerializationCallback = ^TNewtonOnUserCollisionSerializationCallback;
381
 TNewtonOnUserCollisionSerializationCallback = procedure (userData : Pointer; Callback : NewtonSerializeCallback; Handle : NewtonSerializeHandle);
382

383

384
 // user collision callbacks
385
 NewtonUserMeshCollisionDestroyCallback     = ^TNewtonUserMeshCollisionDestroyCallback;
386
 TNewtonUserMeshCollisionDestroyCallback     = procedure (userData : Pointer);
387
 NewtonUserMeshCollisionRayHitCallback      = ^TNewtonUserMeshCollisionRayHitCallback;
388
 TNewtonUserMeshCollisionRayHitCallback      = function (lineDescData : NewtonUserMeshCollisionRayHitDesc) : dFloat;
389
 NewtonUserMeshCollisionGetCollisionInfo    = ^TNewtonUserMeshCollisionGetCollisionInfo;
390
 TNewtonUserMeshCollisionGetCollisionInfo    = procedure (userData : Pointer; infoRecord : NewtonCollisionInfoRecord);
391
 NewtonUserMeshCollisionAABBTest            = ^TNewtonUserMeshCollisionAABBTest;
392
 TNewtonUserMeshCollisionAABBTest            = function (userData : Pointer; const boxP0,boxP1 : PdFloat) : Integer;
393
 NewtonUserMeshCollisionGetFacesInAABB      = ^TNewtonUserMeshCollisionGetFacesInAABB;
394
 TNewtonUserMeshCollisionGetFacesInAABB      = function (userData : Pointer; const p0 : PdFloat; const p1 : PdFloat;
395
                                                        const vertexArray : PdFloat; vertexCount : PInteger;
396
                                                        vertexStrideInBytes : PInteger; const indexList : PInteger;
397
                                                        maxIndexCount : Integer; const userDataList : PInteger) : Integer;
398

399
 NewtonUserMeshCollisionCollideCallback     = ^TNewtonUserMeshCollisionCollideCallback;
400
 TNewtonUserMeshCollisionCollideCallback     = procedure (collideDescData : NewtonUserMeshCollisionCollideDesc; continueCollisionHandle : Pointer);
401

402
 NewtonTreeCollisionFaceCallback            = ^TNewtonTreeCollisionFaceCallback;
403
 TNewtonTreeCollisionFaceCallback            = function (context : Pointer; polygon : PdFloat; strideInBytes : Integer; indexArray : PInteger; indexCount : Integer) : Integer;
404

405
 NewtonCollisionTreeRayCastCallback         = ^TNewtonCollisionTreeRayCastCallback;
406
 TNewtonCollisionTreeRayCastCallback         = function (const body : NewtonBody; const treeCollision : NewtonCollision;
407
                                                        interception : dFloat; normal : PdFloat; faceID : Integer;
408
                                                        userData : Pointer) : dFloat;
409
 NewtonHeightFieldRayCastCallback           = ^TNewtonHeightFieldRayCastCallback;
410
 TNewtonHeightFieldRayCastCallback           = function (const body : NewtonBody; const heightFieldCollision : NewtonCollision;
411
                                                        interception : dFloat; row, col : Integer; normal : PdFloat;
412
                                                        faceID : Integer; userData : Pointer) : dFloat;
413

414
 NewtonCollisionCopyConstructionCallback    = ^TNewtonCollisionCopyConstructionCallback;
415
 TNewtonCollisionCopyConstructionCallback    = procedure (newtonWorld : NewtonWorld; collision : NewtonCollision; sourceCollision : NewtonCollision);
416

417
 NewtonCollisionDestructorCallback          = ^TNewtonCollisionDestructorCallback;
418
 TNewtonCollisionDestructorCallback          = procedure (newtonWorld : NewtonWorld; collision : NewtonCollision);
419

420
 // collision tree call back (obsoleted no recommended)
421
 NewtonTreeCollisionCallback                = ^TNewtonTreeCollisionCallback;
422
 TNewtonTreeCollisionCallback                = procedure (const bodyWithTreeCollision : NewtonBody; const body : NewtonBody;
423
                                                         faceID : Integer; vertexCount : Integer; const vertexArray : PdFloat;
424
                                                         vertexStrideInBytes : Integer);
425

426
 NewtonBodyDestructor                       = ^TNewtonBodyDestructor;
427
 TNewtonBodyDestructor                       = procedure (const body : NewtonBody);
428
 NewtonApplyForceAndTorque                  = ^TNewtonApplyForceAndTorque;
429
 TNewtonApplyForceAndTorque                  = procedure (const body : NewtonBody; timestep : dFloat; threadIndex : Integer);
430
 NewtonSetTransform                         = ^TNewtonSetTransform;
431
 TNewtonSetTransform                         = procedure (const body : NewtonBody; const matrix : PdFloat; threadIndex : Integer);
432

433
 NewtonIslandUpdate                         = ^TNewtonIslandUpdate;
434
 TNewtonIslandUpdate                         = function (const world : NewtonWorld; islandHandle : Pointer; bodyCount : Integer) : Integer;
435

436
 NewtonFractureCompoundCollisionOnEmitCompoundFractured   = ^TNewtonFractureCompoundCollisionOnEmitCompoundFractured;
437
 TNewtonFractureCompoundCollisionOnEmitCompoundFractured   = procedure (fracturedBody : NewtonBody);
438

439
 NewtonFractureCompoundCollisionOnEmitChunk   = ^TNewtonFractureCompoundCollisionOnEmitChunk;
440
 TNewtonFractureCompoundCollisionOnEmitChunk   = procedure (chunkBody : NewtonBody; fracturexChunkMesh : NewtonFracturedCompoundMeshPart; fracturedCompountCollision : NewtonCollision);
441

442
 NewtonFractureCompoundCollisionReconstructMainMeshCallBack   = ^TNewtonFractureCompoundCollisionReconstructMainMeshCallBack;
443
 TNewtonFractureCompoundCollisionReconstructMainMeshCallBack   = procedure (body : NewtonBody; mainMesh : NewtonFracturedCompoundMeshPart; fracturedCompountCollision : NewtonCollision);
444

445
 NewtonWorldRayPrefilterCallback            = ^TNewtonWorldRayPrefilterCallback;
446
 TNewtonWorldRayPrefilterCallback            = function (const body : NewtonBody; collision : NewtonCollision; userData : Pointer) : Cardinal;
447
 NewtonWorldRayFilterCallback               = ^TNewtonWorldRayFilterCallback;
448
 TNewtonWorldRayFilterCallback               = function (const body : NewtonBody; const shapeHit : NewtonCollision; const hitContact : PDFloat; const hitNormal : PdFloat; collisionID : dLong;
449
                                                        userData : Pointer; intersectParam : dFloat) : dFloat;
450

451
 NewtonContactsProcess                      = ^TNewtonContactsProcess;
452
 TNewtonContactsProcess                      = procedure (const contact : NewtonJoint; timestep : dFloat; threadIndex : Integer);
453

454
 NewtonOnAABBOverlap                        = ^TNewtonOnAABBOverlap;
455
 TNewtonOnAABBOverlap                        = function (const material : NewtonMaterial; const body0 : NewtonBody; const body1 : NewtonBody;
456
                                                        threadIndex : Integer) : Integer;
457

458
 NewtonOnCompoundSubCollisionAABBOverlap    = ^TNewtonOnCompoundSubCollisionAABBOverlap;
459
 TNewtonOnCompoundSubCollisionAABBOverlap    = function (const material : NewtonMaterial; body0 : NewtonBody; collisionNode0 : Pointer; body1 : NewtonBody; collisionNode1 : Pointer; threadIndex : Integer) : Integer;
460

461
 NewtonOnContactGeneration                  = ^TNewtonOnContactGeneration;
462
 TNewtonOnContactGeneration                  = function (const material : NewtonMaterial; body0 : NewtonBody; collision0 : Pointer; body1 : NewtonBody; collision1 : Pointer; contactBuffer : NewtonUserContactPoint; maxCount : Integer; threadIndex : Integer) : Integer;
463

464
 NewtonBodyIterator                         = ^TNewtonBodyIterator;
465
 TNewtonBodyIterator                         = function (const body : NewtonBody; userData : Pointer) : Integer;
466
 NewtonJointIterator                        = ^TNewtonJointIterator;
467
 TNewtonJointIterator                        = procedure (const joint : NewtonJoint; userData : Pointer);
468
 NewtonCollisionIterator                    = ^TNewtonCollisionIterator;
469
 TNewtonCollisionIterator                    = procedure (userData : Pointer; vertexCount : Integer; const faceArray : PdFloat; faceId : Integer);
470

471
 NewtonBallCallback                         = ^TNewtonBallCallback;
472
 TNewtonBallCallback                        = procedure (const ball : NewtonJoint; timestep : dFloat);
473
 NewtonHingeCallback                        = ^TNewtonHingeCallback;
474
 TNewtonHingeCallback                       = function (const hinge : NewtonJoint; desc : NewtonHingeSliderUpdateDesc) : Cardinal;
475
 NewtonSliderCallback                       = ^TNewtonSliderCallback;
476
 TNewtonSliderCallback                      = function (const slider : NewtonJoint; desc : NewtonHingeSliderUpdateDesc) : Cardinal;
477
 NewtonUniversalCallback                    = ^TNewtonUniversalCallback;
478
 TNewtonUniversalCallback                   = function (const universal : NewtonJoint; desc : NewtonHingeSliderUpdateDesc) : Cardinal;
479
 NewtonCorkscrewCallback                    = ^TNewtonCorkscrewCallback;
480
 TNewtonCorkscrewCallback                   = function (const corkscrew : NewtonJoint; desc : NewtonHingeSliderUpdateDesc) : Cardinal;
481

482
 NewtonUserBilateralCallback                = ^TNewtonUserBilateralCallback;
483
 TNewtonUserBilateralCallback               = procedure (const userJoint : NewtonJoint; timestep : dFloat; threadIndex : Integer);
484
 NewtonUserBilateralGetInfoCallback         = ^TNewtonUserBilateralGetInfoCallback;
485
 TNewtonUserBilateralGetInfoCallback        = procedure (const userJoint : NewtonJoint; info : NewtonJointRecord);
486

487
 NewtonConstraintDestructor                 = ^TNewtonConstraintDestructor;
488
 TNewtonConstraintDestructor                = procedure (const me : NewtonJoint);
489

490
 NewtonJobTask                              = ^TNewtonJobTask;
491
 TNewtonJobTask                             = procedure (world : NewtonWorld; userData : Pointer; threadIndex : Integer);
492

493
 NewtonReportProgress                       = ^TNewtonReportProgress;
494
 TNewtonReportProgress                      = function (progressNormalzedPercent : dFloat; userData : Pointer) : Integer;
495

496

497
function NewtonWorldGetVersion() : Integer; cdecl; external NEWTON_API;
498
function NewtonWorldFloatSize() : Integer; cdecl; external NEWTON_API;
499
function NewtonGetMemoryUsed() : Integer; cdecl; external NEWTON_API;
500
procedure NewtonSetMemorySystem(malloc : NewtonAllocMemory; free : NewtonFreeMemory); cdecl; external NEWTON_API;
501
function NewtonCreate() : NewtonWorld; cdecl; external NEWTON_API;
502
function NewtonCreateEx(stackSizeInMegabytes : Integer) : NewtonWorld; cdecl; external NEWTON_API;
503
procedure NewtonDestroy(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
504
procedure NewtonDestroyAllBodies(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
505
function NewtonAlloc(sizeInBytes : Integer) : Pointer; cdecl; external NEWTON_API;
506
procedure NewtonFree(ptr : Pointer); cdecl; external NEWTON_API;
507
function NewtonGetStackSize(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
508
procedure NewtonSetStackSize(newtonWorld : NewtonWorld; size : Integer); cdecl; external NEWTON_API;
509
function NewtonEnumerateDevices(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
510
function NewtonGetCurrentDevice(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
511
procedure NewtonSetCurrentDevice(newtonWorld : NewtonWorld; deviceIndex : Integer); cdecl; external NEWTON_API;
512
procedure NewtonGetDeviceString(newtonWorld : NewtonWorld; deviceIndex : Integer; vendorString : Pchar; maxSize : Integer); cdecl; external NEWTON_API;
513
function NewtonGetContactMergeTolerance(newtonWorld : NewtonWorld) : dFloat; cdecl; external NEWTON_API;
514
procedure NewtonSetContactMergeTolerance(newtonWorld : NewtonWorld; tolerance : dFloat); cdecl; external NEWTON_API;
515
procedure NewtonInvalidateCache(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
516
procedure NewtonSetSolverModel(newtonWorld : NewtonWorld; model : Integer); cdecl; external NEWTON_API;
517
function NewtonGetSolverModel(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
518
procedure NewtonSetSolverConvergenceQuality(newtonWorld : NewtonWorld; lowOrHigh : Integer); cdecl; external NEWTON_API;
519
function NewtonGetSolverConvergenceQuality(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
520
procedure NewtonSetMultiThreadSolverOnSingleIsland(newtonWorld : NewtonWorld; mode : Integer); cdecl; external NEWTON_API;
521
function NewtonGetMultiThreadSolverOnSingleIsland(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
522
procedure NewtonSetPerformanceClock(newtonWorld : NewtonWorld; callback : NewtonGetTimeInMicrosencondsCallback); cdecl; external NEWTON_API;
523
function NewtonGetBroadphaseAlgorithm(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
524
procedure NewtonSelectBroadphaseAlgorithm(newtonWorld : NewtonWorld; algorithmType : Integer); cdecl; external NEWTON_API;
525
procedure NewtonUpdate(newtonWorld : NewtonWorld; timestep : dFloat); cdecl; external NEWTON_API;
526
procedure NewtonUpdateAsync(newtonWorld : NewtonWorld; timestep : dFloat); cdecl; external NEWTON_API;
527
procedure NewtonWaitForUpdateToFinish(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
528
function NewtonGetNumberOfSubsteps(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
529
procedure NewtonSetNumberOfSubsteps(newtonWorld : NewtonWorld; subSteps : Integer); cdecl; external NEWTON_API;
530
function NewtonGetLastUpdateTime(newtonWorld : NewtonWorld) : dFloat; cdecl; external NEWTON_API;
531
procedure NewtonSerializeToFile(newtonWorld : NewtonWorld; filename : Pchar; bodyCallback : NewtonOnBodySerializationCallback; bodyUserData : Pointer); cdecl; external NEWTON_API;
532
procedure NewtonDeserializeFromFile(newtonWorld : NewtonWorld; filename : Pchar; bodyCallback : NewtonOnBodyDeserializationCallback; bodyUserData : Pointer); cdecl; external NEWTON_API;
533
function NewtonFindSerializedBody(newtonWorld : NewtonWorld; bodySerializedID : Integer) : NewtonBody; cdecl; external NEWTON_API;
534
procedure NewtonSetJointSerializationCallbacks(newtonWorld : NewtonWorld; serializeJoint : NewtonOnJointSerializationCallback; deserializeJoint : NewtonOnJointDeserializationCallback); cdecl; external NEWTON_API;
535
procedure NewtonGetJointSerializationCallbacks(newtonWorld : NewtonWorld; serializeJoint : NewtonOnJointSerializationCallback; deserializeJoint : NewtonOnJointDeserializationCallback); cdecl; external NEWTON_API;
536
procedure NewtonWorldCriticalSectionLock(newtonWorld : NewtonWorld; threadIndex : Integer); cdecl; external NEWTON_API;
537
procedure NewtonWorldCriticalSectionUnlock(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
538
procedure NewtonSetThreadsCount(newtonWorld : NewtonWorld; threads : Integer); cdecl; external NEWTON_API;
539
function NewtonGetThreadsCount(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
540
function NewtonGetMaxThreadsCount(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
541
procedure NewtonDispachThreadJob(newtonWorld : NewtonWorld; task : NewtonJobTask; usedData : Pointer); cdecl; external NEWTON_API;
542
procedure NewtonSyncThreadJobs(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
543
function NewtonAtomicAdd(ptr : PInteger; value : Integer) : Integer; cdecl; external NEWTON_API;
544
function NewtonAtomicSwap(ptr : PInteger; value : Integer) : Integer; cdecl; external NEWTON_API;
545
procedure NewtonYield(); cdecl; external NEWTON_API;
546
procedure NewtonSetIslandUpdateEvent(newtonWorld : NewtonWorld; islandUpdate : NewtonIslandUpdate); cdecl; external NEWTON_API;
547
procedure NewtonWorldForEachJointDo(newtonWorld : NewtonWorld; callback : NewtonJointIterator; userData : Pointer); cdecl; external NEWTON_API;
548
procedure NewtonWorldForEachBodyInAABBDo(newtonWorld : NewtonWorld; p0 : PdFloat; p1 : PdFloat; callback : NewtonBodyIterator; userData : Pointer); cdecl; external NEWTON_API;
549
procedure NewtonWorldSetUserData(newtonWorld : NewtonWorld; userData : Pointer); cdecl; external NEWTON_API;
550
function NewtonWorldGetUserData(newtonWorld : NewtonWorld) : Pointer; cdecl; external NEWTON_API;
551
function NewtonWorldGetListenerUserData(newtonWorld : NewtonWorld; listener : Pointer) : Pointer; cdecl; external NEWTON_API;
552
function NewtonWorldListenerGetBodyDestroyCallback(newtonWorld : NewtonWorld; listener : Pointer) : NewtonWorldListenerBodyDestroyCallback; cdecl; external NEWTON_API;
553
procedure NewtonWorldListenerSetBodyDestroyCallback(newtonWorld : NewtonWorld; listener : Pointer; bodyDestroyCallback : NewtonWorldListenerBodyDestroyCallback); cdecl; external NEWTON_API;
554
function NewtonWorldGetPreListener(newtonWorld : NewtonWorld; nameId : Pchar) : Pointer; cdecl; external NEWTON_API;
555
function NewtonWorldAddPreListener(newtonWorld : NewtonWorld; nameId : Pchar; listenerUserData : Pointer; update : NewtonWorldUpdateListenerCallback; destroy : NewtonWorldDestroyListenerCallback) : Pointer; cdecl; external NEWTON_API;
556
function NewtonWorldGetPostListener(newtonWorld : NewtonWorld; nameId : Pchar) : Pointer; cdecl; external NEWTON_API;
557
function NewtonWorldAddPostListener(newtonWorld : NewtonWorld; nameId : Pchar; listenerUserData : Pointer; update : NewtonWorldUpdateListenerCallback; destroy : NewtonWorldDestroyListenerCallback) : Pointer; cdecl; external NEWTON_API;
558
procedure NewtonWorldSetDestructorCallback(newtonWorld : NewtonWorld; _destructor : NewtonWorldDestructorCallback); cdecl; external NEWTON_API;
559
function NewtonWorldGetDestructorCallback(newtonWorld : NewtonWorld) : NewtonWorldDestructorCallback; cdecl; external NEWTON_API;
560
procedure NewtonWorldSetCollisionConstructorDestructorCallback(newtonWorld : NewtonWorld; _constructor : NewtonCollisionCopyConstructionCallback; _destructor : NewtonCollisionDestructorCallback); cdecl; external NEWTON_API;
561
procedure NewtonWorldRayCast(newtonWorld : NewtonWorld; p0 : PdFloat; p1 : PdFloat; filter : NewtonWorldRayFilterCallback; userData : Pointer; prefilter : NewtonWorldRayPrefilterCallback; threadIndex : Integer); cdecl; external NEWTON_API;
562
function NewtonWorldConvexCast(newtonWorld : NewtonWorld; matrix : PdFloat; target : PdFloat; shape : NewtonCollision; param : PdFloat; userData : Pointer; prefilter : NewtonWorldRayPrefilterCallback; info : NewtonWorldConvexCastReturnInfo; maxContactsCount : Integer; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
563
function NewtonWorldCollide(newtonWorld : NewtonWorld; matrix : PdFloat; shape : NewtonCollision; userData : Pointer; prefilter : NewtonWorldRayPrefilterCallback; info : NewtonWorldConvexCastReturnInfo; maxContactsCount : Integer; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
564
function NewtonWorldGetBodyCount(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
565
function NewtonWorldGetConstraintCount(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
566
function NewtonIslandGetBody(island : Pointer; bodyIndex : Integer) : NewtonBody; cdecl; external NEWTON_API;
567
procedure NewtonIslandGetBodyAABB(island : Pointer; bodyIndex : Integer; p0 : PdFloat; p1 : PdFloat); cdecl; external NEWTON_API;
568
function NewtonMaterialCreateGroupID(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
569
function NewtonMaterialGetDefaultGroupID(newtonWorld : NewtonWorld) : Integer; cdecl; external NEWTON_API;
570
procedure NewtonMaterialDestroyAllGroupID(newtonWorld : NewtonWorld); cdecl; external NEWTON_API;
571
function NewtonMaterialGetUserData(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer) : Pointer; cdecl; external NEWTON_API;
572
procedure NewtonMaterialSetSurfaceThickness(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; thickness : dFloat); cdecl; external NEWTON_API;
573
procedure NewtonMaterialSetCallbackUserData(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; userData : Pointer); cdecl; external NEWTON_API;
574
procedure NewtonMaterialSetContactGenerationCallback(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; contactGeneration : NewtonOnContactGeneration); cdecl; external NEWTON_API;
575
procedure NewtonMaterialSetCompoundCollisionCallback(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; compoundAabbOverlap : NewtonOnCompoundSubCollisionAABBOverlap); cdecl; external NEWTON_API;
576
procedure NewtonMaterialSetCollisionCallback(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; aabbOverlap : NewtonOnAABBOverlap; process : NewtonContactsProcess); cdecl; external NEWTON_API;
577
procedure NewtonMaterialSetDefaultSoftness(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; value : dFloat); cdecl; external NEWTON_API;
578
procedure NewtonMaterialSetDefaultElasticity(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; elasticCoef : dFloat); cdecl; external NEWTON_API;
579
procedure NewtonMaterialSetDefaultCollidable(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; state : Integer); cdecl; external NEWTON_API;
580
procedure NewtonMaterialSetDefaultFriction(newtonWorld : NewtonWorld; id0 : Integer; id1 : Integer; staticFriction : dFloat; kineticFriction : dFloat); cdecl; external NEWTON_API;
581
function NewtonWorldGetFirstMaterial(newtonWorld : NewtonWorld) : NewtonMaterial; cdecl; external NEWTON_API;
582
function NewtonWorldGetNextMaterial(newtonWorld : NewtonWorld; material : NewtonMaterial) : NewtonMaterial; cdecl; external NEWTON_API;
583
function NewtonWorldGetFirstBody(newtonWorld : NewtonWorld) : NewtonBody; cdecl; external NEWTON_API;
584
function NewtonWorldGetNextBody(newtonWorld : NewtonWorld; curBody : NewtonBody) : NewtonBody; cdecl; external NEWTON_API;
585
function NewtonMaterialGetMaterialPairUserData(material : NewtonMaterial) : Pointer; cdecl; external NEWTON_API;
586
function NewtonMaterialGetContactFaceAttribute(material : NewtonMaterial) : Cardinal; cdecl; external NEWTON_API;
587
function NewtonMaterialGetBodyCollidingShape(material : NewtonMaterial; body : NewtonBody) : NewtonCollision; cdecl; external NEWTON_API;
588
function NewtonMaterialGetContactNormalSpeed(material : NewtonMaterial) : dFloat; cdecl; external NEWTON_API;
589
procedure NewtonMaterialGetContactForce(material : NewtonMaterial; body : NewtonBody; force : PdFloat); cdecl; external NEWTON_API;
590
procedure NewtonMaterialGetContactPositionAndNormal(material : NewtonMaterial; body : NewtonBody; posit : PdFloat; normal : PdFloat); cdecl; external NEWTON_API;
591
procedure NewtonMaterialGetContactTangentDirections(material : NewtonMaterial; body : NewtonBody; dir0 : PdFloat; dir1 : PdFloat); cdecl; external NEWTON_API;
592
function NewtonMaterialGetContactTangentSpeed(material : NewtonMaterial; index : Integer) : dFloat; cdecl; external NEWTON_API;
593
function NewtonMaterialGetContactMaxNormalImpact(material : NewtonMaterial) : dFloat; cdecl; external NEWTON_API;
594
function NewtonMaterialGetContactMaxTangentImpact(material : NewtonMaterial; index : Integer) : dFloat; cdecl; external NEWTON_API;
595
function NewtonMaterialGetContactPenetration(material : NewtonMaterial) : dFloat; cdecl; external NEWTON_API;
596
procedure NewtonMaterialSetContactSoftness(material : NewtonMaterial; softness : dFloat); cdecl; external NEWTON_API;
597
procedure NewtonMaterialSetContactElasticity(material : NewtonMaterial; restitution : dFloat); cdecl; external NEWTON_API;
598
procedure NewtonMaterialSetContactFrictionState(material : NewtonMaterial; state : Integer; index : Integer); cdecl; external NEWTON_API;
599
procedure NewtonMaterialSetContactFrictionCoef(material : NewtonMaterial; staticFrictionCoef : dFloat; kineticFrictionCoef : dFloat; index : Integer); cdecl; external NEWTON_API;
600
procedure NewtonMaterialSetContactNormalAcceleration(material : NewtonMaterial; accel : dFloat); cdecl; external NEWTON_API;
601
procedure NewtonMaterialSetContactNormalDirection(material : NewtonMaterial; directionVector : PdFloat); cdecl; external NEWTON_API;
602
procedure NewtonMaterialSetContactPosition(material : NewtonMaterial; position : PdFloat); cdecl; external NEWTON_API;
603
procedure NewtonMaterialSetContactTangentFriction(material : NewtonMaterial; friction : dFloat; index : Integer); cdecl; external NEWTON_API;
604
procedure NewtonMaterialSetContactTangentAcceleration(material : NewtonMaterial; accel : dFloat; index : Integer); cdecl; external NEWTON_API;
605
procedure NewtonMaterialContactRotateTangentDirections(material : NewtonMaterial; directionVector : PdFloat); cdecl; external NEWTON_API;
606
function NewtonCreateNull(newtonWorld : NewtonWorld) : NewtonCollision; cdecl; external NEWTON_API;
607
function NewtonCreateSphere(newtonWorld : NewtonWorld; radius : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
608
function NewtonCreateBox(newtonWorld : NewtonWorld; dx : dFloat; dy : dFloat; dz : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
609
function NewtonCreateCone(newtonWorld : NewtonWorld; radius : dFloat; height : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
610
function NewtonCreateCapsule(newtonWorld : NewtonWorld; radius0 : dFloat; radius1 : dFloat; height : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
611
function NewtonCreateCylinder(newtonWorld : NewtonWorld; radio0 : dFloat; radio1 : dFloat; height : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
612
function NewtonCreateChamferCylinder(newtonWorld : NewtonWorld; radius : dFloat; height : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
613
function NewtonCreateConvexHull(newtonWorld : NewtonWorld; count : Integer; vertexCloud : PdFloat; strideInBytes : Integer; tolerance : dFloat; shapeID : Integer; offsetMatrix : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
614
function NewtonCreateConvexHullFromMesh(newtonWorld : NewtonWorld; mesh : NewtonMesh; tolerance : dFloat; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
615
function NewtonCollisionGetMode(convexCollision : NewtonCollision) : Integer; cdecl; external NEWTON_API;
616
procedure NewtonCollisionSetMode(convexCollision : NewtonCollision; mode : Integer); cdecl; external NEWTON_API;
617
function NewtonConvexHullGetFaceIndices(convexHullCollision : NewtonCollision; face : Integer; faceIndices : PInteger) : Integer; cdecl; external NEWTON_API;
618
function NewtonConvexHullGetVertexData(convexHullCollision : NewtonCollision; vertexData : PdFloat; strideInBytes : PInteger) : Integer; cdecl; external NEWTON_API;
619
function NewtonConvexCollisionCalculateVolume(convexCollision : NewtonCollision) : dFloat; cdecl; external NEWTON_API;
620
procedure NewtonConvexCollisionCalculateInertialMatrix(convexCollision : NewtonCollision; inertia : PdFloat; origin : PdFloat); cdecl; external NEWTON_API;
621
procedure NewtonConvexCollisionCalculateBuoyancyAcceleration(convexCollision : NewtonCollision; matrix : PdFloat; shapeOrigin : PdFloat; gravityVector : PdFloat; fluidPlane : PdFloat; fluidDensity : dFloat; fluidViscosity : dFloat; accel : PdFloat; alpha : PdFloat); cdecl; external NEWTON_API;
622
function NewtonCollisionDataPointer(convexCollision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
623
function NewtonCreateCompoundCollision(newtonWorld : NewtonWorld; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
624
function NewtonCreateCompoundCollisionFromMesh(newtonWorld : NewtonWorld; mesh : NewtonMesh; hullTolerance : dFloat; shapeID : Integer; subShapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
625
procedure NewtonCompoundCollisionBeginAddRemove(compoundCollision : NewtonCollision); cdecl; external NEWTON_API;
626
function NewtonCompoundCollisionAddSubCollision(compoundCollision : NewtonCollision; convexCollision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
627
procedure NewtonCompoundCollisionRemoveSubCollision(compoundCollision : NewtonCollision; collisionNode : Pointer); cdecl; external NEWTON_API;
628
procedure NewtonCompoundCollisionRemoveSubCollisionByIndex(compoundCollision : NewtonCollision; nodeIndex : Integer); cdecl; external NEWTON_API;
629
procedure NewtonCompoundCollisionSetSubCollisionMatrix(compoundCollision : NewtonCollision; collisionNode : Pointer; matrix : PdFloat); cdecl; external NEWTON_API;
630
procedure NewtonCompoundCollisionEndAddRemove(compoundCollision : NewtonCollision); cdecl; external NEWTON_API;
631
function NewtonCompoundCollisionGetFirstNode(compoundCollision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
632
function NewtonCompoundCollisionGetNextNode(compoundCollision : NewtonCollision; collisionNode : Pointer) : Pointer; cdecl; external NEWTON_API;
633
function NewtonCompoundCollisionGetNodeByIndex(compoundCollision : NewtonCollision; index : Integer) : Pointer; cdecl; external NEWTON_API;
634
function NewtonCompoundCollisionGetNodeIndex(compoundCollision : NewtonCollision; collisionNode : Pointer) : Integer; cdecl; external NEWTON_API;
635
function NewtonCompoundCollisionGetCollisionFromNode(compoundCollision : NewtonCollision; collisionNode : Pointer) : NewtonCollision; cdecl; external NEWTON_API;
636
function NewtonCreateFracturedCompoundCollision(newtonWorld : NewtonWorld; solidMesh : NewtonMesh; shapeID : Integer; fracturePhysicsMaterialID : Integer; pointcloudCount : Integer; vertexCloud : PdFloat; strideInBytes : Integer; materialID : Integer; textureMatrix : PdFloat; regenerateMainMeshCallback : NewtonFractureCompoundCollisionReconstructMainMeshCallBack; emitFracturedCompound : NewtonFractureCompoundCollisionOnEmitCompoundFractured; emitFracfuredChunk : NewtonFractureCompoundCollisionOnEmitChunk) : NewtonCollision; cdecl; external NEWTON_API;
637
function NewtonFracturedCompoundPlaneClip(fracturedCompound : NewtonCollision; plane : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
638
procedure NewtonFracturedCompoundSetCallbacks(fracturedCompound : NewtonCollision; regenerateMainMeshCallback : NewtonFractureCompoundCollisionReconstructMainMeshCallBack; emitFracturedCompound : NewtonFractureCompoundCollisionOnEmitCompoundFractured; emitFracfuredChunk : NewtonFractureCompoundCollisionOnEmitChunk); cdecl; external NEWTON_API;
639
function NewtonFracturedCompoundIsNodeFreeToDetach(fracturedCompound : NewtonCollision; collisionNode : Pointer) : Integer; cdecl; external NEWTON_API;
640
function NewtonFracturedCompoundNeighborNodeList(fracturedCompound : NewtonCollision; collisionNode : Pointer; list : Pointer; maxCount : Integer) : Integer; cdecl; external NEWTON_API;
641
function NewtonFracturedCompoundGetMainMesh(fracturedCompound : NewtonCollision) : NewtonFracturedCompoundMeshPart; cdecl; external NEWTON_API;
642
function NewtonFracturedCompoundGetFirstSubMesh(fracturedCompound : NewtonCollision) : NewtonFracturedCompoundMeshPart; cdecl; external NEWTON_API;
643
function NewtonFracturedCompoundGetNextSubMesh(fracturedCompound : NewtonCollision; subMesh : NewtonFracturedCompoundMeshPart) : NewtonFracturedCompoundMeshPart; cdecl; external NEWTON_API;
644
function NewtonFracturedCompoundCollisionGetVertexCount(fracturedCompound : NewtonCollision; meshOwner : NewtonFracturedCompoundMeshPart) : Integer; cdecl; external NEWTON_API;
645
function NewtonFracturedCompoundCollisionGetVertexPositions(fracturedCompound : NewtonCollision; meshOwner : NewtonFracturedCompoundMeshPart) : PdFloat; cdecl; external NEWTON_API;
646
function NewtonFracturedCompoundCollisionGetVertexNormals(fracturedCompound : NewtonCollision; meshOwner : NewtonFracturedCompoundMeshPart) : PdFloat; cdecl; external NEWTON_API;
647
function NewtonFracturedCompoundCollisionGetVertexUVs(fracturedCompound : NewtonCollision; meshOwner : NewtonFracturedCompoundMeshPart) : PdFloat; cdecl; external NEWTON_API;
648
function NewtonFracturedCompoundMeshPartGetIndexStream(fracturedCompound : NewtonCollision; meshOwner : NewtonFracturedCompoundMeshPart; segment : Pointer; index : PInteger) : Integer; cdecl; external NEWTON_API;
649
function NewtonFracturedCompoundMeshPartGetFirstSegment(fractureCompoundMeshPart : NewtonFracturedCompoundMeshPart) : Pointer; cdecl; external NEWTON_API;
650
function NewtonFracturedCompoundMeshPartGetNextSegment(fractureCompoundMeshSegment : Pointer) : Pointer; cdecl; external NEWTON_API;
651
function NewtonFracturedCompoundMeshPartGetMaterial(fractureCompoundMeshSegment : Pointer) : Integer; cdecl; external NEWTON_API;
652
function NewtonFracturedCompoundMeshPartGetIndexCount(fractureCompoundMeshSegment : Pointer) : Integer; cdecl; external NEWTON_API;
653
function NewtonCreateSceneCollision(newtonWorld : NewtonWorld; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
654
procedure NewtonSceneCollisionBeginAddRemove(sceneCollision : NewtonCollision); cdecl; external NEWTON_API;
655
function NewtonSceneCollisionAddSubCollision(sceneCollision : NewtonCollision; collision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
656
procedure NewtonSceneCollisionRemoveSubCollision(compoundCollision : NewtonCollision; collisionNode : Pointer); cdecl; external NEWTON_API;
657
procedure NewtonSceneCollisionRemoveSubCollisionByIndex(sceneCollision : NewtonCollision; nodeIndex : Integer); cdecl; external NEWTON_API;
658
procedure NewtonSceneCollisionSetSubCollisionMatrix(sceneCollision : NewtonCollision; collisionNode : Pointer; matrix : PdFloat); cdecl; external NEWTON_API;
659
procedure NewtonSceneCollisionEndAddRemove(sceneCollision : NewtonCollision); cdecl; external NEWTON_API;
660
function NewtonSceneCollisionGetFirstNode(sceneCollision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
661
function NewtonSceneCollisionGetNextNode(sceneCollision : NewtonCollision; collisionNode : Pointer) : Pointer; cdecl; external NEWTON_API;
662
function NewtonSceneCollisionGetNodeByIndex(sceneCollision : NewtonCollision; index : Integer) : Pointer; cdecl; external NEWTON_API;
663
function NewtonSceneCollisionGetNodeIndex(sceneCollision : NewtonCollision; collisionNode : Pointer) : Integer; cdecl; external NEWTON_API;
664
function NewtonSceneCollisionGetCollisionFromNode(sceneCollision : NewtonCollision; collisionNode : Pointer) : NewtonCollision; cdecl; external NEWTON_API;
665
function NewtonCreateUserMeshCollision(newtonWorld : NewtonWorld; minBox : PdFloat; maxBox : PdFloat; userData : Pointer; collideCallback : NewtonUserMeshCollisionCollideCallback; rayHitCallback : NewtonUserMeshCollisionRayHitCallback; destroyCallback : NewtonUserMeshCollisionDestroyCallback; getInfoCallback : NewtonUserMeshCollisionGetCollisionInfo; getLocalAABBCallback : NewtonUserMeshCollisionAABBTest; facesInAABBCallback : NewtonUserMeshCollisionGetFacesInAABB; serializeCallback : NewtonOnUserCollisionSerializationCallback; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
666
function NewtonUserMeshCollisionContinuousOverlapTest(collideDescData : NewtonUserMeshCollisionCollideDesc; continueCollisionHandle : Pointer; minAabb : PdFloat; maxAabb : PdFloat) : Integer; cdecl; external NEWTON_API;
667
function NewtonCreateCollisionFromSerialization(newtonWorld : NewtonWorld; deserializeFunction : NewtonDeserializeCallback; serializeHandle : Pointer) : NewtonCollision; cdecl; external NEWTON_API;
668
procedure NewtonCollisionSerialize(newtonWorld : NewtonWorld; collision : NewtonCollision; serializeFunction : NewtonSerializeCallback; serializeHandle : Pointer); cdecl; external NEWTON_API;
669
procedure NewtonCollisionGetInfo(collision : NewtonCollision; collisionInfo : NewtonCollisionInfoRecord); cdecl; external NEWTON_API;
670
function NewtonCreateHeightFieldCollision(newtonWorld : NewtonWorld; width : Integer; height : Integer; gridsDiagonals : Integer; elevationdatType : Integer; elevationMap : Pointer; attributeMap : Pchar; verticalScale : dFloat; horizontalScale_x : dFloat; horizontalScale_z : dFloat; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
671
procedure NewtonHeightFieldSetUserRayCastCallback(heightfieldCollision : NewtonCollision; rayHitCallback : NewtonHeightFieldRayCastCallback); cdecl; external NEWTON_API;
672
procedure NewtonHeightFieldSetHorizontalDisplacement(heightfieldCollision : NewtonCollision; horizontalMap : Pword; scale : dFloat); cdecl; external NEWTON_API;
673
function NewtonCreateTreeCollision(newtonWorld : NewtonWorld; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
674
function NewtonCreateTreeCollisionFromMesh(newtonWorld : NewtonWorld; mesh : NewtonMesh; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
675
procedure NewtonTreeCollisionSetUserRayCastCallback(treeCollision : NewtonCollision; rayHitCallback : NewtonCollisionTreeRayCastCallback); cdecl; external NEWTON_API;
676
procedure NewtonTreeCollisionBeginBuild(treeCollision : NewtonCollision); cdecl; external NEWTON_API;
677
procedure NewtonTreeCollisionAddFace(treeCollision : NewtonCollision; vertexCount : Integer; vertexPtr : PdFloat; strideInBytes : Integer; faceAttribute : Integer); cdecl; external NEWTON_API;
678
procedure NewtonTreeCollisionEndBuild(treeCollision : NewtonCollision; optimize : Integer); cdecl; external NEWTON_API;
679
function NewtonTreeCollisionGetFaceAttribute(treeCollision : NewtonCollision; faceIndexArray : PInteger; indexCount : Integer) : Integer; cdecl; external NEWTON_API;
680
procedure NewtonTreeCollisionSetFaceAttribute(treeCollision : NewtonCollision; faceIndexArray : PInteger; indexCount : Integer; attribute : Integer); cdecl; external NEWTON_API;
681
procedure NewtonTreeCollisionForEachFace(treeCollision : NewtonCollision; forEachFaceCallback : NewtonTreeCollisionFaceCallback; context : Pointer); cdecl; external NEWTON_API;
682
function NewtonTreeCollisionGetVertexListTriangleListInAABB(treeCollision : NewtonCollision; p0 : PdFloat; p1 : PdFloat; vertexArray : PdFloat; vertexCount : PInteger; vertexStrideInBytes : PInteger; indexList : PInteger; maxIndexCount : Integer; faceAttribute : PInteger) : Integer; cdecl; external NEWTON_API;
683
procedure NewtonStaticCollisionSetDebugCallback(staticCollision : NewtonCollision; userCallback : NewtonTreeCollisionCallback); cdecl; external NEWTON_API;
684
function NewtonCollisionCreateInstance(collision : NewtonCollision) : NewtonCollision; cdecl; external NEWTON_API;
685
function NewtonCollisionGetType(collision : NewtonCollision) : Integer; cdecl; external NEWTON_API;
686
function NewtonCollisionIsConvexShape(collision : NewtonCollision) : Integer; cdecl; external NEWTON_API;
687
function NewtonCollisionIsStaticShape(collision : NewtonCollision) : Integer; cdecl; external NEWTON_API;
688
procedure NewtonCollisionSetUserData(collision : NewtonCollision; userData : Pointer); cdecl; external NEWTON_API;
689
function NewtonCollisionGetUserData(collision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
690
procedure NewtonCollisionSetUserData1(collision : NewtonCollision; userData : Pointer); cdecl; external NEWTON_API;
691
function NewtonCollisionGetUserData1(collision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
692
procedure NewtonCollisionSetUserID(collision : NewtonCollision; id : Cardinal); cdecl; external NEWTON_API;
693
function NewtonCollisionGetUserID(collision : NewtonCollision) : Cardinal; cdecl; external NEWTON_API;
694
function NewtonCollisionGetSubCollisionHandle(collision : NewtonCollision) : Pointer; cdecl; external NEWTON_API;
695
function NewtonCollisionGetParentInstance(collision : NewtonCollision) : NewtonCollision; cdecl; external NEWTON_API;
696
procedure NewtonCollisionSetMatrix(collision : NewtonCollision; matrix : PdFloat); cdecl; external NEWTON_API;
697
procedure NewtonCollisionGetMatrix(collision : NewtonCollision; matrix : PdFloat); cdecl; external NEWTON_API;
698
procedure NewtonCollisionSetScale(collision : NewtonCollision; scaleX : dFloat; scaleY : dFloat; scaleZ : dFloat); cdecl; external NEWTON_API;
699
procedure NewtonCollisionGetScale(collision : NewtonCollision; scaleX : PdFloat; scaleY : PdFloat; scaleZ : PdFloat); cdecl; external NEWTON_API;
700
procedure NewtonDestroyCollision(collision : NewtonCollision); cdecl; external NEWTON_API;
701
function NewtonCollisionIntersectionTest(newtonWorld : NewtonWorld; collisionA : NewtonCollision; matrixA : PdFloat; collisionB : NewtonCollision; matrixB : PdFloat; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
702
function NewtonCollisionPointDistance(newtonWorld : NewtonWorld; point : PdFloat; collision : NewtonCollision; matrix : PdFloat; contact : PdFloat; normal : PdFloat; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
703
function NewtonCollisionClosestPoint(newtonWorld : NewtonWorld; collisionA : NewtonCollision; matrixA : PdFloat; collisionB : NewtonCollision; matrixB : PdFloat; contactA : PdFloat; contactB : PdFloat; normalAB : PdFloat; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
704
function NewtonCollisionCollide(newtonWorld : NewtonWorld; maxSize : Integer; collisionA : NewtonCollision; matrixA : PdFloat; collisionB : NewtonCollision; matrixB : PdFloat; contacts : PdFloat; normals : PdFloat; penetration : PdFloat; attributeA : PdLong; attributeB : PdLong; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
705
function NewtonCollisionCollideContinue(newtonWorld : NewtonWorld; maxSize : Integer; timestep : dFloat; collisionA : NewtonCollision; matrixA : PdFloat; velocA : PdFloat; omegaA : PdFloat; collisionB : NewtonCollision; matrixB : PdFloat; velocB : PdFloat; omegaB : PdFloat; timeOfImpact : PdFloat; contacts : PdFloat; normals : PdFloat; penetration : PdFloat; attributeA : PdLong; attributeB : PdLong; threadIndex : Integer) : Integer; cdecl; external NEWTON_API;
706
procedure NewtonCollisionSupportVertex(collision : NewtonCollision; dir : PdFloat; vertex : PdFloat); cdecl; external NEWTON_API;
707
function NewtonCollisionRayCast(collision : NewtonCollision; p0 : PdFloat; p1 : PdFloat; normal : PdFloat; attribute : PdLong) : dFloat; cdecl; external NEWTON_API;
708
procedure NewtonCollisionCalculateAABB(collision : NewtonCollision; matrix : PdFloat; p0 : PdFloat; p1 : PdFloat); cdecl; external NEWTON_API;
709
procedure NewtonCollisionForEachPolygonDo(collision : NewtonCollision; matrix : PdFloat; callback : NewtonCollisionIterator; userData : Pointer); cdecl; external NEWTON_API;
710
function NewtonCollisionAggregateCreate(world : NewtonWorld) : Pointer; cdecl; external NEWTON_API;
711
procedure NewtonCollisionAggregateDestroy(aggregate : Pointer); cdecl; external NEWTON_API;
712
procedure NewtonCollisionAggregateAddBody(aggregate : Pointer; body : NewtonBody); cdecl; external NEWTON_API;
713
procedure NewtonCollisionAggregateRemoveBody(aggregate : Pointer; body : NewtonBody); cdecl; external NEWTON_API;
714
function NewtonCollisionAggregateGetSelfCollision(aggregate : Pointer) : Integer; cdecl; external NEWTON_API;
715
procedure NewtonCollisionAggregateSetSelfCollision(aggregate : Pointer; state : Integer); cdecl; external NEWTON_API;
716
procedure NewtonSetEulerAngle(eulersAngles : PdFloat; matrix : PdFloat); cdecl; external NEWTON_API;
717
procedure NewtonGetEulerAngle(matrix : PdFloat; eulersAngles0 : PdFloat; eulersAngles1 : PdFloat); cdecl; external NEWTON_API;
718
function NewtonCalculateSpringDamperAcceleration(dt : dFloat; ks : dFloat; x : dFloat; kd : dFloat; s : dFloat) : dFloat; cdecl; external NEWTON_API;
719
function NewtonCreateDynamicBody(newtonWorld : NewtonWorld; collision : NewtonCollision; matrix : PdFloat) : NewtonBody; cdecl; external NEWTON_API;
720
function NewtonCreateKinematicBody(newtonWorld : NewtonWorld; collision : NewtonCollision; matrix : PdFloat) : NewtonBody; cdecl; external NEWTON_API;
721
procedure NewtonDestroyBody(body : NewtonBody); cdecl; external NEWTON_API;
722
function NewtonBodyGetSimulationState(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
723
procedure NewtonBodySetSimulationState(bodyPtr : NewtonBody; state : Integer); cdecl; external NEWTON_API;
724
function NewtonBodyGetType(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
725
function NewtonBodyGetCollidable(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
726
procedure NewtonBodySetCollidable(body : NewtonBody; collidableState : Integer); cdecl; external NEWTON_API;
727
procedure NewtonBodyAddForce(body : NewtonBody; force : PdFloat); cdecl; external NEWTON_API;
728
procedure NewtonBodyAddTorque(body : NewtonBody; torque : PdFloat); cdecl; external NEWTON_API;
729
procedure NewtonBodyCalculateInverseDynamicsForce(body : NewtonBody; timestep : dFloat; desiredVeloc : PdFloat; forceOut : PdFloat); cdecl; external NEWTON_API;
730
procedure NewtonBodySetCentreOfMass(body : NewtonBody; com : PdFloat); cdecl; external NEWTON_API;
731
procedure NewtonBodySetMassMatrix(body : NewtonBody; mass : dFloat; Ixx : dFloat; Iyy : dFloat; Izz : dFloat); cdecl; external NEWTON_API;
732
procedure NewtonBodySetFullMassMatrix(body : NewtonBody; mass : dFloat; inertiaMatrix : PdFloat); cdecl; external NEWTON_API;
733
procedure NewtonBodySetMassProperties(body : NewtonBody; mass : dFloat; collision : NewtonCollision); cdecl; external NEWTON_API;
734
procedure NewtonBodySetMatrix(body : NewtonBody; matrix : PdFloat); cdecl; external NEWTON_API;
735
procedure NewtonBodySetMatrixNoSleep(body : NewtonBody; matrix : PdFloat); cdecl; external NEWTON_API;
736
procedure NewtonBodySetMatrixRecursive(body : NewtonBody; matrix : PdFloat); cdecl; external NEWTON_API;
737
procedure NewtonBodySetMaterialGroupID(body : NewtonBody; id : Integer); cdecl; external NEWTON_API;
738
procedure NewtonBodySetContinuousCollisionMode(body : NewtonBody; state : Cardinal); cdecl; external NEWTON_API;
739
procedure NewtonBodySetJointRecursiveCollision(body : NewtonBody; state : Cardinal); cdecl; external NEWTON_API;
740
procedure NewtonBodySetOmega(body : NewtonBody; omega : PdFloat); cdecl; external NEWTON_API;
741
procedure NewtonBodySetOmegaNoSleep(body : NewtonBody; omega : PdFloat); cdecl; external NEWTON_API;
742
procedure NewtonBodySetVelocity(body : NewtonBody; velocity : PdFloat); cdecl; external NEWTON_API;
743
procedure NewtonBodySetVelocityNoSleep(body : NewtonBody; velocity : PdFloat); cdecl; external NEWTON_API;
744
procedure NewtonBodySetForce(body : NewtonBody; force : PdFloat); cdecl; external NEWTON_API;
745
procedure NewtonBodySetTorque(body : NewtonBody; torque : PdFloat); cdecl; external NEWTON_API;
746
procedure NewtonBodySetLinearDamping(body : NewtonBody; linearDamp : dFloat); cdecl; external NEWTON_API;
747
procedure NewtonBodySetAngularDamping(body : NewtonBody; angularDamp : PdFloat); cdecl; external NEWTON_API;
748
procedure NewtonBodySetCollision(body : NewtonBody; collision : NewtonCollision); cdecl; external NEWTON_API;
749
procedure NewtonBodySetCollisionScale(body : NewtonBody; scaleX : dFloat; scaleY : dFloat; scaleZ : dFloat); cdecl; external NEWTON_API;
750
function NewtonBodyGetMaxRotationPerStep(body : NewtonBody) : dFloat; cdecl; external NEWTON_API;
751
procedure NewtonBodySetMaxRotationPerStep(body : NewtonBody; angleInRadians : dFloat); cdecl; external NEWTON_API;
752
function NewtonBodyGetSleepState(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
753
procedure NewtonBodySetSleepState(body : NewtonBody; state : Integer); cdecl; external NEWTON_API;
754
function NewtonBodyGetAutoSleep(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
755
procedure NewtonBodySetAutoSleep(body : NewtonBody; state : Integer); cdecl; external NEWTON_API;
756
function NewtonBodyGetFreezeState(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
757
procedure NewtonBodySetFreezeState(body : NewtonBody; state : Integer); cdecl; external NEWTON_API;
758
procedure NewtonBodySetDestructorCallback(body : NewtonBody; callback : NewtonBodyDestructor); cdecl; external NEWTON_API;
759
function NewtonBodyGetDestructorCallback(body : NewtonBody) : NewtonBodyDestructor; cdecl; external NEWTON_API;
760
procedure NewtonBodySetTransformCallback(body : NewtonBody; callback : NewtonSetTransform); cdecl; external NEWTON_API;
761
function NewtonBodyGetTransformCallback(body : NewtonBody) : NewtonSetTransform; cdecl; external NEWTON_API;
762
procedure NewtonBodySetForceAndTorqueCallback(body : NewtonBody; callback : NewtonApplyForceAndTorque); cdecl; external NEWTON_API;
763
function NewtonBodyGetForceAndTorqueCallback(body : NewtonBody) : NewtonApplyForceAndTorque; cdecl; external NEWTON_API;
764
function NewtonBodyGetID(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
765
procedure NewtonBodySetUserData(body : NewtonBody; userData : Pointer); cdecl; external NEWTON_API;
766
function NewtonBodyGetUserData(body : NewtonBody) : Pointer; cdecl; external NEWTON_API;
767
function NewtonBodyGetWorld(body : NewtonBody) : NewtonWorld; cdecl; external NEWTON_API;
768
function NewtonBodyGetCollision(body : NewtonBody) : NewtonCollision; cdecl; external NEWTON_API;
769
function NewtonBodyGetMaterialGroupID(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
770
function NewtonBodyGetSerializedID(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
771
function NewtonBodyGetContinuousCollisionMode(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
772
function NewtonBodyGetJointRecursiveCollision(body : NewtonBody) : Integer; cdecl; external NEWTON_API;
773
procedure NewtonBodyGetPosition(body : NewtonBody; pos : PdFloat); cdecl; external NEWTON_API;
774
procedure NewtonBodyGetMatrix(body : NewtonBody; matrix : PdFloat); cdecl; external NEWTON_API;
775
procedure NewtonBodyGetRotation(body : NewtonBody; rotation : PdFloat); cdecl; external NEWTON_API;
776
procedure NewtonBodyGetMass(body : NewtonBody; mass : PdFloat; Ixx : PdFloat; Iyy : PdFloat; Izz : PdFloat); cdecl; external NEWTON_API;
777
procedure NewtonBodyGetInvMass(body : NewtonBody; invMass : PdFloat; invIxx : PdFloat; invIyy : PdFloat; invIzz : PdFloat); cdecl; external NEWTON_API;
778
procedure NewtonBodyGetInertiaMatrix(body : NewtonBody; inertiaMatrix : PdFloat); cdecl; external NEWTON_API;
779
procedure NewtonBodyGetInvInertiaMatrix(body : NewtonBody; invInertiaMatrix : PdFloat); cdecl; external NEWTON_API;
780
procedure NewtonBodyGetOmega(body : NewtonBody; vector : PdFloat); cdecl; external NEWTON_API;
781
procedure NewtonBodyGetVelocity(body : NewtonBody; vector : PdFloat); cdecl; external NEWTON_API;
782
procedure NewtonBodyGetForce(body : NewtonBody; vector : PdFloat); cdecl; external NEWTON_API;
783
procedure NewtonBodyGetTorque(body : NewtonBody; vector : PdFloat); cdecl; external NEWTON_API;
784
procedure NewtonBodyGetCentreOfMass(body : NewtonBody; com : PdFloat); cdecl; external NEWTON_API;
785
procedure NewtonBodyGetPointVelocity(body : NewtonBody; point : PdFloat; velocOut : PdFloat); cdecl; external NEWTON_API;
786
procedure NewtonBodyApplyImpulsePair(body : NewtonBody; linearImpulse : PdFloat; angularImpulse : PdFloat; timestep : dFloat); cdecl; external NEWTON_API;
787
procedure NewtonBodyAddImpulse(body : NewtonBody; pointDeltaVeloc : PdFloat; pointPosit : PdFloat; timestep : dFloat); cdecl; external NEWTON_API;
788
procedure NewtonBodyApplyImpulseArray(body : NewtonBody; impuleCount : Integer; strideInByte : Integer; impulseArray : PdFloat; pointArray : PdFloat; timestep : dFloat); cdecl; external NEWTON_API;
789
procedure NewtonBodyIntegrateVelocity(body : NewtonBody; timestep : dFloat); cdecl; external NEWTON_API;
790
function NewtonBodyGetLinearDamping(body : NewtonBody) : dFloat; cdecl; external NEWTON_API;
791
procedure NewtonBodyGetAngularDamping(body : NewtonBody; vector : PdFloat); cdecl; external NEWTON_API;
792
procedure NewtonBodyGetAABB(body : NewtonBody; p0 : PdFloat; p1 : PdFloat); cdecl; external NEWTON_API;
793
function NewtonBodyGetFirstJoint(body : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
794
function NewtonBodyGetNextJoint(body : NewtonBody; joint : NewtonJoint) : NewtonJoint; cdecl; external NEWTON_API;
795
function NewtonBodyGetFirstContactJoint(body : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
796
function NewtonBodyGetNextContactJoint(body : NewtonBody; contactJoint : NewtonJoint) : NewtonJoint; cdecl; external NEWTON_API;
797
function NewtonContactJointGetFirstContact(contactJoint : NewtonJoint) : Pointer; cdecl; external NEWTON_API;
798
function NewtonContactJointGetNextContact(contactJoint : NewtonJoint; contact : Pointer) : Pointer; cdecl; external NEWTON_API;
799
function NewtonContactJointGetContactCount(contactJoint : NewtonJoint) : Integer; cdecl; external NEWTON_API;
800
procedure NewtonContactJointRemoveContact(contactJoint : NewtonJoint; contact : Pointer); cdecl; external NEWTON_API;
801
function NewtonContactJointGetClosestDistance(contactJoint : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
802
function NewtonContactGetMaterial(contact : Pointer) : NewtonMaterial; cdecl; external NEWTON_API;
803
function NewtonContactGetCollision0(contact : Pointer) : NewtonCollision; cdecl; external NEWTON_API;
804
function NewtonContactGetCollision1(contact : Pointer) : NewtonCollision; cdecl; external NEWTON_API;
805
function NewtonContactGetCollisionID0(contact : Pointer) : Pointer; cdecl; external NEWTON_API;
806
function NewtonContactGetCollisionID1(contact : Pointer) : Pointer; cdecl; external NEWTON_API;
807
function NewtonJointGetUserData(joint : NewtonJoint) : Pointer; cdecl; external NEWTON_API;
808
procedure NewtonJointSetUserData(joint : NewtonJoint; userData : Pointer); cdecl; external NEWTON_API;
809
function NewtonJointGetBody0(joint : NewtonJoint) : NewtonBody; cdecl; external NEWTON_API;
810
function NewtonJointGetBody1(joint : NewtonJoint) : NewtonBody; cdecl; external NEWTON_API;
811
procedure NewtonJointGetInfo(joint : NewtonJoint; info : NewtonJointRecord); cdecl; external NEWTON_API;
812
function NewtonJointGetCollisionState(joint : NewtonJoint) : Integer; cdecl; external NEWTON_API;
813
procedure NewtonJointSetCollisionState(joint : NewtonJoint; state : Integer); cdecl; external NEWTON_API;
814
function NewtonJointGetStiffness(joint : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
815
procedure NewtonJointSetStiffness(joint : NewtonJoint; state : dFloat); cdecl; external NEWTON_API;
816
procedure NewtonDestroyJoint(newtonWorld : NewtonWorld; joint : NewtonJoint); cdecl; external NEWTON_API;
817
procedure NewtonJointSetDestructor(joint : NewtonJoint; _destructor : NewtonConstraintDestructor); cdecl; external NEWTON_API;
818
function NewtonJointIsActive(joint : NewtonJoint) : Integer; cdecl; external NEWTON_API;
819
function NewtonCreateMassSpringDamperSystem(newtonWorld : NewtonWorld; shapeID : Integer; points : PdFloat; pointCount : Integer; strideInBytes : Integer; pointMass : PdFloat; links : PInteger; linksCount : Integer; linksSpring : PdFloat; linksDamper : PdFloat) : NewtonCollision; cdecl; external NEWTON_API;
820
function NewtonCreateDeformableSolid(newtonWorld : NewtonWorld; mesh : NewtonMesh; shapeID : Integer) : NewtonCollision; cdecl; external NEWTON_API;
821
function NewtonDeformableMeshGetParticleCount(deformableMesh : NewtonCollision) : Integer; cdecl; external NEWTON_API;
822
function NewtonDeformableMeshGetParticleStrideInBytes(deformableMesh : NewtonCollision) : Integer; cdecl; external NEWTON_API;
823
function NewtonDeformableMeshGetParticleArray(deformableMesh : NewtonCollision) : PdFloat; cdecl; external NEWTON_API;
824
function NewtonConstraintCreateBall(newtonWorld : NewtonWorld; pivotPoint : PdFloat; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
825
procedure NewtonBallSetUserCallback(ball : NewtonJoint; callback : NewtonBallCallback); cdecl; external NEWTON_API;
826
procedure NewtonBallGetJointAngle(ball : NewtonJoint; angle : PdFloat); cdecl; external NEWTON_API;
827
procedure NewtonBallGetJointOmega(ball : NewtonJoint; omega : PdFloat); cdecl; external NEWTON_API;
828
procedure NewtonBallGetJointForce(ball : NewtonJoint; force : PdFloat); cdecl; external NEWTON_API;
829
procedure NewtonBallSetConeLimits(ball : NewtonJoint; pin : PdFloat; maxConeAngle : dFloat; maxTwistAngle : dFloat); cdecl; external NEWTON_API;
830
function NewtonConstraintCreateHinge(newtonWorld : NewtonWorld; pivotPoint : PdFloat; pinDir : PdFloat; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
831
procedure NewtonHingeSetUserCallback(hinge : NewtonJoint; callback : NewtonHingeCallback); cdecl; external NEWTON_API;
832
function NewtonHingeGetJointAngle(hinge : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
833
function NewtonHingeGetJointOmega(hinge : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
834
procedure NewtonHingeGetJointForce(hinge : NewtonJoint; force : PdFloat); cdecl; external NEWTON_API;
835
function NewtonHingeCalculateStopAlpha(hinge : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; angle : dFloat) : dFloat; cdecl; external NEWTON_API;
836
function NewtonConstraintCreateSlider(newtonWorld : NewtonWorld; pivotPoint : PdFloat; pinDir : PdFloat; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
837
procedure NewtonSliderSetUserCallback(slider : NewtonJoint; callback : NewtonSliderCallback); cdecl; external NEWTON_API;
838
function NewtonSliderGetJointPosit(slider : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
839
function NewtonSliderGetJointVeloc(slider : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
840
procedure NewtonSliderGetJointForce(slider : NewtonJoint; force : PdFloat); cdecl; external NEWTON_API;
841
function NewtonSliderCalculateStopAccel(slider : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; position : dFloat) : dFloat; cdecl; external NEWTON_API;
842
function NewtonConstraintCreateCorkscrew(newtonWorld : NewtonWorld; pivotPoint : PdFloat; pinDir : PdFloat; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
843
procedure NewtonCorkscrewSetUserCallback(corkscrew : NewtonJoint; callback : NewtonCorkscrewCallback); cdecl; external NEWTON_API;
844
function NewtonCorkscrewGetJointPosit(corkscrew : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
845
function NewtonCorkscrewGetJointAngle(corkscrew : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
846
function NewtonCorkscrewGetJointVeloc(corkscrew : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
847
function NewtonCorkscrewGetJointOmega(corkscrew : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
848
procedure NewtonCorkscrewGetJointForce(corkscrew : NewtonJoint; force : PdFloat); cdecl; external NEWTON_API;
849
function NewtonCorkscrewCalculateStopAlpha(corkscrew : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; angle : dFloat) : dFloat; cdecl; external NEWTON_API;
850
function NewtonCorkscrewCalculateStopAccel(corkscrew : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; position : dFloat) : dFloat; cdecl; external NEWTON_API;
851
function NewtonConstraintCreateUniversal(newtonWorld : NewtonWorld; pivotPoint : PdFloat; pinDir0 : PdFloat; pinDir1 : PdFloat; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
852
procedure NewtonUniversalSetUserCallback(universal : NewtonJoint; callback : NewtonUniversalCallback); cdecl; external NEWTON_API;
853
function NewtonUniversalGetJointAngle0(universal : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
854
function NewtonUniversalGetJointAngle1(universal : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
855
function NewtonUniversalGetJointOmega0(universal : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
856
function NewtonUniversalGetJointOmega1(universal : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
857
procedure NewtonUniversalGetJointForce(universal : NewtonJoint; force : PdFloat); cdecl; external NEWTON_API;
858
function NewtonUniversalCalculateStopAlpha0(universal : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; angle : dFloat) : dFloat; cdecl; external NEWTON_API;
859
function NewtonUniversalCalculateStopAlpha1(universal : NewtonJoint; desc : NewtonHingeSliderUpdateDesc; angle : dFloat) : dFloat; cdecl; external NEWTON_API;
860
function NewtonConstraintCreateUpVector(newtonWorld : NewtonWorld; pinDir : PdFloat; body : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
861
procedure NewtonUpVectorGetPin(upVector : NewtonJoint; pin : PdFloat); cdecl; external NEWTON_API;
862
procedure NewtonUpVectorSetPin(upVector : NewtonJoint; pin : PdFloat); cdecl; external NEWTON_API;
863
function NewtonConstraintCreateUserJoint(newtonWorld : NewtonWorld; maxDOF : Integer; callback : NewtonUserBilateralCallback; getInfo : NewtonUserBilateralGetInfoCallback; childBody : NewtonBody; parentBody : NewtonBody) : NewtonJoint; cdecl; external NEWTON_API;
864
function NewtonUserJointGetSolverModel(joint : NewtonJoint) : Integer; cdecl; external NEWTON_API;
865
procedure NewtonUserJointSetSolverModel(joint : NewtonJoint; model : Integer); cdecl; external NEWTON_API;
866
procedure NewtonUserJointSetFeedbackCollectorCallback(joint : NewtonJoint; getFeedback : NewtonUserBilateralCallback); cdecl; external NEWTON_API;
867
procedure NewtonUserJointAddLinearRow(joint : NewtonJoint; pivot0 : PdFloat; pivot1 : PdFloat; dir : PdFloat); cdecl; external NEWTON_API;
868
procedure NewtonUserJointAddAngularRow(joint : NewtonJoint; relativeAngle : dFloat; dir : PdFloat); cdecl; external NEWTON_API;
869
procedure NewtonUserJointAddGeneralRow(joint : NewtonJoint; jacobian0 : PdFloat; jacobian1 : PdFloat); cdecl; external NEWTON_API;
870
procedure NewtonUserJointSetRowMinimumFriction(joint : NewtonJoint; friction : dFloat); cdecl; external NEWTON_API;
871
procedure NewtonUserJointSetRowMaximumFriction(joint : NewtonJoint; friction : dFloat); cdecl; external NEWTON_API;
872
function NewtonUserCalculateRowZeroAccelaration(joint : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
873
function NewtonUserJointGetRowAcceleration(joint : NewtonJoint) : dFloat; cdecl; external NEWTON_API;
874
procedure NewtonUserJointSetRowAcceleration(joint : NewtonJoint; acceleration : dFloat); cdecl; external NEWTON_API;
875
procedure NewtonUserJointSetRowSpringDamperAcceleration(joint : NewtonJoint; rowStiffness : dFloat; spring : dFloat; damper : dFloat); cdecl; external NEWTON_API;
876
procedure NewtonUserJointSetRowStiffness(joint : NewtonJoint; stiffness : dFloat); cdecl; external NEWTON_API;
877
function NewtonUserJoinRowsCount(joint : NewtonJoint) : Integer; cdecl; external NEWTON_API;
878
procedure NewtonUserJointGetGeneralRow(joint : NewtonJoint; index : Integer; jacobian0 : PdFloat; jacobian1 : PdFloat); cdecl; external NEWTON_API;
879
function NewtonUserJointGetRowForce(joint : NewtonJoint; row : Integer) : dFloat; cdecl; external NEWTON_API;
880
function NewtonMeshCreate(newtonWorld : NewtonWorld) : NewtonMesh; cdecl; external NEWTON_API;
881
function NewtonMeshCreateFromMesh(mesh : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
882
function NewtonMeshCreateFromCollision(collision : NewtonCollision) : NewtonMesh; cdecl; external NEWTON_API;
883
function NewtonMeshCreateTetrahedraIsoSurface(mesh : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
884
function NewtonMeshCreateConvexHull(newtonWorld : NewtonWorld; pointCount : Integer; vertexCloud : PdFloat; strideInBytes : Integer; tolerance : dFloat) : NewtonMesh; cdecl; external NEWTON_API;
885
function NewtonMeshCreateVoronoiConvexDecomposition(newtonWorld : NewtonWorld; pointCount : Integer; vertexCloud : PdFloat; strideInBytes : Integer; materialID : Integer; textureMatrix : PdFloat) : NewtonMesh; cdecl; external NEWTON_API;
886
function NewtonMeshCreateFromSerialization(newtonWorld : NewtonWorld; deserializeFunction : NewtonDeserializeCallback; serializeHandle : Pointer) : NewtonMesh; cdecl; external NEWTON_API;
887
procedure NewtonMeshDestroy(mesh : NewtonMesh); cdecl; external NEWTON_API;
888
procedure NewtonMeshSerialize(mesh : NewtonMesh; serializeFunction : NewtonSerializeCallback; serializeHandle : Pointer); cdecl; external NEWTON_API;
889
procedure NewtonMeshSaveOFF(mesh : NewtonMesh; filename : Pchar); cdecl; external NEWTON_API;
890
function NewtonMeshLoadOFF(newtonWorld : NewtonWorld; filename : Pchar) : NewtonMesh; cdecl; external NEWTON_API;
891
function NewtonMeshLoadTetrahedraMesh(newtonWorld : NewtonWorld; filename : Pchar) : NewtonMesh; cdecl; external NEWTON_API;
892
procedure NewtonMeshApplyTransform(mesh : NewtonMesh; matrix : PdFloat); cdecl; external NEWTON_API;
893
procedure NewtonMeshCalculateOOBB(mesh : NewtonMesh; matrix : PdFloat; x : PdFloat; y : PdFloat; z : PdFloat); cdecl; external NEWTON_API;
894
procedure NewtonMeshCalculateVertexNormals(mesh : NewtonMesh; angleInRadians : dFloat); cdecl; external NEWTON_API;
895
procedure NewtonMeshApplySphericalMapping(mesh : NewtonMesh; material : Integer); cdecl; external NEWTON_API;
896
procedure NewtonMeshApplyCylindricalMapping(mesh : NewtonMesh; cylinderMaterial : Integer; capMaterial : Integer); cdecl; external NEWTON_API;
897
procedure NewtonMeshApplyBoxMapping(mesh : NewtonMesh; frontMaterial : Integer; sideMaterial : Integer; topMaterial : Integer); cdecl; external NEWTON_API;
898
procedure NewtonMeshApplyAngleBasedMapping(mesh : NewtonMesh; material : Integer; reportPrograssCallback : NewtonReportProgress; reportPrgressUserData : Pointer); cdecl; external NEWTON_API;
899
procedure NewtonCreateTetrahedraLinearBlendSkinWeightsChannel(tetrahedraMesh : NewtonMesh; skinMesh : NewtonMesh); cdecl; external NEWTON_API;
900
procedure NewtonMeshOptimize(mesh : NewtonMesh); cdecl; external NEWTON_API;
901
procedure NewtonMeshOptimizePoints(mesh : NewtonMesh); cdecl; external NEWTON_API;
902
procedure NewtonMeshOptimizeVertex(mesh : NewtonMesh); cdecl; external NEWTON_API;
903
function NewtonMeshIsOpenMesh(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
904
procedure NewtonMeshFixTJoints(mesh : NewtonMesh); cdecl; external NEWTON_API;
905
procedure NewtonMeshPolygonize(mesh : NewtonMesh); cdecl; external NEWTON_API;
906
procedure NewtonMeshTriangulate(mesh : NewtonMesh); cdecl; external NEWTON_API;
907
function NewtonMeshUnion(mesh : NewtonMesh; clipper : NewtonMesh; clipperMatrix : PdFloat) : NewtonMesh; cdecl; external NEWTON_API;
908
function NewtonMeshDifference(mesh : NewtonMesh; clipper : NewtonMesh; clipperMatrix : PdFloat) : NewtonMesh; cdecl; external NEWTON_API;
909
function NewtonMeshIntersection(mesh : NewtonMesh; clipper : NewtonMesh; clipperMatrix : PdFloat) : NewtonMesh; cdecl; external NEWTON_API;
910
procedure NewtonMeshClip(mesh : NewtonMesh; clipper : NewtonMesh; clipperMatrix : PdFloat; topMesh : NewtonMesh; bottomMesh : NewtonMesh); cdecl; external NEWTON_API;
911
function NewtonMeshConvexMeshIntersection(mesh : NewtonMesh; convexMesh : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
912
function NewtonMeshSimplify(mesh : NewtonMesh; maxVertexCount : Integer; reportPrograssCallback : NewtonReportProgress; reportPrgressUserData : Pointer) : NewtonMesh; cdecl; external NEWTON_API;
913
function NewtonMeshApproximateConvexDecomposition(mesh : NewtonMesh; maxConcavity : dFloat; backFaceDistanceFactor : dFloat; maxCount : Integer; maxVertexPerHull : Integer; reportProgressCallback : NewtonReportProgress; reportProgressUserData : Pointer) : NewtonMesh; cdecl; external NEWTON_API;
914
procedure NewtonRemoveUnusedVertices(mesh : NewtonMesh; vertexRemapTable : PInteger); cdecl; external NEWTON_API;
915
procedure NewtonMeshBeginBuild(mesh : NewtonMesh); cdecl; external NEWTON_API;
916
procedure NewtonMeshBeginFace(mesh : NewtonMesh); cdecl; external NEWTON_API;
917
procedure NewtonMeshAddPoint(mesh : NewtonMesh; x : dFloat64; y : dFloat64; z : dFloat64); cdecl; external NEWTON_API;
918
procedure NewtonMeshAddLayer(mesh : NewtonMesh; layerIndex : Integer); cdecl; external NEWTON_API;
919
procedure NewtonMeshAddMaterial(mesh : NewtonMesh; materialIndex : Integer); cdecl; external NEWTON_API;
920
procedure NewtonMeshAddNormal(mesh : NewtonMesh; x : dFloat; y : dFloat; z : dFloat); cdecl; external NEWTON_API;
921
procedure NewtonMeshAddBinormal(mesh : NewtonMesh; x : dFloat; y : dFloat; z : dFloat); cdecl; external NEWTON_API;
922
procedure NewtonMeshAddUV0(mesh : NewtonMesh; u : dFloat; v : dFloat); cdecl; external NEWTON_API;
923
procedure NewtonMeshAddUV1(mesh : NewtonMesh; u : dFloat; v : dFloat); cdecl; external NEWTON_API;
924
procedure NewtonMeshEndFace(mesh : NewtonMesh); cdecl; external NEWTON_API;
925
procedure NewtonMeshEndBuild(mesh : NewtonMesh); cdecl; external NEWTON_API;
926
procedure NewtonMeshClearVertexFormat(format : NewtonMeshVertexFormat); cdecl; external NEWTON_API;
927
procedure NewtonMeshBuildFromVertexListIndexList(mesh : NewtonMesh; format : NewtonMeshVertexFormat); cdecl; external NEWTON_API;
928
function NewtonMeshGetPointCount(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
929
function NewtonMeshGetIndexToVertexMap(mesh : NewtonMesh) : PInteger; cdecl; external NEWTON_API;
930
function NewtonMeshGetVertexWeights(mesh : NewtonMesh; vertexIndex : Integer; weightIndex : PInteger; weightFactor : PdFloat) : Integer; cdecl; external NEWTON_API;
931
procedure NewtonMeshGetVertexDoubleChannel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat64); cdecl; external NEWTON_API;
932
procedure NewtonMeshGetVertexChannel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
933
procedure NewtonMeshGetNormalChannel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
934
procedure NewtonMeshGetBinormalChannel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
935
procedure NewtonMeshGetUV0Channel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
936
procedure NewtonMeshGetUV1Channel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
937
procedure NewtonMeshGetVertexColorChannel(mesh : NewtonMesh; vertexStrideInByte : Integer; outBuffer : PdFloat); cdecl; external NEWTON_API;
938
function NewtonMeshHasNormalChannel(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
939
function NewtonMeshHasBinormalChannel(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
940
function NewtonMeshHasUV0Channel(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
941
function NewtonMeshHasUV1Channel(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
942
function NewtonMeshHasVertexColorChannel(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
943
function NewtonMeshBeginHandle(mesh : NewtonMesh) : Pointer; cdecl; external NEWTON_API;
944
procedure NewtonMeshEndHandle(mesh : NewtonMesh; handle : Pointer); cdecl; external NEWTON_API;
945
function NewtonMeshFirstMaterial(mesh : NewtonMesh; handle : Pointer) : Integer; cdecl; external NEWTON_API;
946
function NewtonMeshNextMaterial(mesh : NewtonMesh; handle : Pointer; materialId : Integer) : Integer; cdecl; external NEWTON_API;
947
function NewtonMeshMaterialGetMaterial(mesh : NewtonMesh; handle : Pointer; materialId : Integer) : Integer; cdecl; external NEWTON_API;
948
function NewtonMeshMaterialGetIndexCount(mesh : NewtonMesh; handle : Pointer; materialId : Integer) : Integer; cdecl; external NEWTON_API;
949
procedure NewtonMeshMaterialGetIndexStream(mesh : NewtonMesh; handle : Pointer; materialId : Integer; index : PInteger); cdecl; external NEWTON_API;
950
procedure NewtonMeshMaterialGetIndexStreamShort(mesh : NewtonMesh; handle : Pointer; materialId : Integer; index : PSmallint); cdecl; external NEWTON_API;
951
function NewtonMeshCreateFirstSingleSegment(mesh : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
952
function NewtonMeshCreateNextSingleSegment(mesh : NewtonMesh; segment : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
953
function NewtonMeshCreateFirstLayer(mesh : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
954
function NewtonMeshCreateNextLayer(mesh : NewtonMesh; segment : NewtonMesh) : NewtonMesh; cdecl; external NEWTON_API;
955
function NewtonMeshGetTotalFaceCount(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
956
function NewtonMeshGetTotalIndexCount(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
957
procedure NewtonMeshGetFaces(mesh : NewtonMesh; faceIndexCount : PInteger; faceMaterial : PInteger; faceIndices : Pointer); cdecl; external NEWTON_API;
958
function NewtonMeshGetVertexCount(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
959
function NewtonMeshGetVertexStrideInByte(mesh : NewtonMesh) : Integer; cdecl; external NEWTON_API;
960
function NewtonMeshGetVertexArray(mesh : NewtonMesh) : PdFloat64; cdecl; external NEWTON_API;
961
function NewtonMeshGetFirstVertex(mesh : NewtonMesh) : Pointer; cdecl; external NEWTON_API;
962
function NewtonMeshGetNextVertex(mesh : NewtonMesh; vertex : Pointer) : Pointer; cdecl; external NEWTON_API;
963
function NewtonMeshGetVertexIndex(mesh : NewtonMesh; vertex : Pointer) : Integer; cdecl; external NEWTON_API;
964
function NewtonMeshGetFirstPoint(mesh : NewtonMesh) : Pointer; cdecl; external NEWTON_API;
965
function NewtonMeshGetNextPoint(mesh : NewtonMesh; point : Pointer) : Pointer; cdecl; external NEWTON_API;
966
function NewtonMeshGetPointIndex(mesh : NewtonMesh; point : Pointer) : Integer; cdecl; external NEWTON_API;
967
function NewtonMeshGetVertexIndexFromPoint(mesh : NewtonMesh; point : Pointer) : Integer; cdecl; external NEWTON_API;
968
function NewtonMeshGetFirstEdge(mesh : NewtonMesh) : Pointer; cdecl; external NEWTON_API;
969
function NewtonMeshGetNextEdge(mesh : NewtonMesh; edge : Pointer) : Pointer; cdecl; external NEWTON_API;
970
procedure NewtonMeshGetEdgeIndices(mesh : NewtonMesh; edge : Pointer; v0 : PInteger; v1 : PInteger); cdecl; external NEWTON_API;
971
function NewtonMeshGetFirstFace(mesh : NewtonMesh) : Pointer; cdecl; external NEWTON_API;
972
function NewtonMeshGetNextFace(mesh : NewtonMesh; face : Pointer) : Pointer; cdecl; external NEWTON_API;
973
function NewtonMeshIsFaceOpen(mesh : NewtonMesh; face : Pointer) : Integer; cdecl; external NEWTON_API;
974
function NewtonMeshGetFaceMaterial(mesh : NewtonMesh; face : Pointer) : Integer; cdecl; external NEWTON_API;
975
function NewtonMeshGetFaceIndexCount(mesh : NewtonMesh; face : Pointer) : Integer; cdecl; external NEWTON_API;
976
procedure NewtonMeshGetFaceIndices(mesh : NewtonMesh; face : Pointer; indices : PInteger); cdecl; external NEWTON_API;
977
procedure NewtonMeshGetFacePointIndices(mesh : NewtonMesh; face : Pointer; indices : PInteger); cdecl; external NEWTON_API;
978
procedure NewtonMeshCalculateFaceNormal(mesh : NewtonMesh; face : Pointer; normal : PdFloat64); cdecl; external NEWTON_API;
979
procedure NewtonMeshSetFaceMaterial(mesh : NewtonMesh; face : Pointer; matId : Integer); cdecl; external NEWTON_API;
980

981

982
implementation
983

984
end.
985
LZScene

Использование cookies
