| 1 |
# Copyright (c) 2007 Scott Lembcke |
| 2 |
# |
| 3 |
# Permission is hereby granted, free of charge, to any person obtaining a copy |
| 4 |
# of this software and associated documentation files (the "Software"), to deal |
| 5 |
# in the Software without restriction, including without limitation the rights |
| 6 |
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 7 |
# copies of the Software, and to permit persons to whom the Software is |
| 8 |
# furnished to do so, subject to the following conditions: |
| 9 |
# |
| 10 |
# The above copyright notice and this permission notice shall be included in |
| 11 |
# all copies or substantial portions of the Software. |
| 12 |
# |
| 13 |
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 14 |
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 15 |
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 16 |
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 17 |
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 18 |
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 19 |
# SOFTWARE. |
| 20 |
# |
| 21 |
|
| 22 |
const Lib = "libchipmunk.so.6.1.1" |
| 23 |
|
| 24 |
when defined(MoreNim): |
| 25 |
{.hint: "MoreNim defined; some Chipmunk functions replaced in Nim".} |
| 26 |
from math import sqrt, sin, cos, arctan2 |
| 27 |
when defined(CpUseFloat): |
| 28 |
{.hint: "CpUseFloat defined; using float32 as float".} |
| 29 |
type CpFloat* = cfloat |
| 30 |
else: |
| 31 |
type CpFloat* = cdouble |
| 32 |
const |
| 33 |
CP_BUFFER_BYTES* = (32 * 1024) |
| 34 |
CP_MAX_CONTACTS_PER_ARBITER* = 4 |
| 35 |
CpInfinity*: CpFloat = 1.0/0 |
| 36 |
{.pragma: pf, pure, final.} |
| 37 |
type |
| 38 |
Bool32* = cint #replace one day with cint-compatible bool |
| 39 |
CpDataPointer* = pointer |
| 40 |
TVector* {.final, pure.} = object |
| 41 |
x*, y*: CpFloat |
| 42 |
TTimestamp* = cuint |
| 43 |
TBodyVelocityFunc* = proc(body: PBody, gravity: TVector, |
| 44 |
damping: CpFloat; dt: CpFloat){.cdecl.} |
| 45 |
TBodyPositionFunc* = proc(body: PBody; dt: CpFloat){.cdecl.} |
| 46 |
TComponentNode*{.pf.} = object |
| 47 |
root*: PBody |
| 48 |
next*: PBody |
| 49 |
idleTime*: CpFloat |
| 50 |
|
| 51 |
THashValue = cuint # uintptr_t |
| 52 |
TCollisionType* = cuint #uintptr_t |
| 53 |
TGroup * = cuint #uintptr_t |
| 54 |
TLayers* = cuint |
| 55 |
PArray = ptr TArray |
| 56 |
TArray{.pure,final.} = object |
| 57 |
PHashSet = ptr THashSet |
| 58 |
THashSet{.pf.} = object |
| 59 |
PContact* = ptr TContact |
| 60 |
TContact*{.pure,final.} = object |
| 61 |
PArbiter* = ptr TArbiter |
| 62 |
TArbiter*{.pf.} = object |
| 63 |
e*: CpFloat |
| 64 |
u*: CpFloat |
| 65 |
surface_vr*: TVector |
| 66 |
a*: PShape |
| 67 |
b*: PShape |
| 68 |
body_a*: PBody |
| 69 |
body_b*: PBody |
| 70 |
thread_a*: TArbiterThread |
| 71 |
thread_b*: TArbiterThread |
| 72 |
numContacts*: cint |
| 73 |
contacts*: PContact |
| 74 |
stamp*: TTimestamp |
| 75 |
handler*: PCollisionHandler |
| 76 |
swappedColl*: Bool32 |
| 77 |
state*: TArbiterState |
| 78 |
PCollisionHandler* = ptr TCollisionHandler |
| 79 |
TCollisionHandler*{.pf.} = object |
| 80 |
a*: TCollisionType |
| 81 |
b*: TCollisionType |
| 82 |
begin*: TCollisionBeginFunc |
| 83 |
preSolve*: TCollisionPreSolveFunc |
| 84 |
postSolve*: TCollisionPostSolveFunc |
| 85 |
separate*: TCollisionSeparateFunc |
| 86 |
data*: pointer |
| 87 |
TArbiterState*{.size: sizeof(cint).} = enum |
| 88 |
ArbiterStateFirstColl, # Arbiter is active and its not the first collision. |
| 89 |
ArbiterStateNormal, # Collision has been explicitly ignored. |
| 90 |
# Either by returning false from a begin collision handler or calling cpArbiterIgnore(). |
| 91 |
ArbiterStateIgnore, # Collison is no longer active. A space will cache an arbiter for up to cpSpace.collisionPersistence more steps. |
| 92 |
ArbiterStateCached |
| 93 |
TArbiterThread*{.pf.} = object |
| 94 |
next*: PArbiter # Links to next and previous arbiters in the contact graph. |
| 95 |
prev*: PArbiter |
| 96 |
|
| 97 |
TContactPoint*{.pf.} = object |
| 98 |
point*: TVector #/ The position of the contact point. |
| 99 |
normal*: TVector #/ The normal of the contact point. |
| 100 |
dist*: CpFloat #/ The depth of the contact point. |
| 101 |
#/ A struct that wraps up the important collision data for an arbiter. |
| 102 |
PContactPointSet* = ptr TContactPointSet |
| 103 |
TContactPointSet*{.pf.} = object |
| 104 |
count*: cint #/ The number of contact points in the set. |
| 105 |
points*: array[0..CP_MAX_CONTACTS_PER_ARBITER - 1, TContactPoint] #/ The array of contact points. |
| 106 |
|
| 107 |
#/ Collision begin event function callback type. |
| 108 |
#/ Returning false from a begin callback causes the collision to be ignored until |
| 109 |
#/ the separate callback is called when the objects stop colliding. |
| 110 |
TCollisionBeginFunc* = proc (arb: PArbiter; space: PSpace; data: pointer): bool{. |
| 111 |
cdecl.} |
| 112 |
#/ Collision pre-solve event function callback type. |
| 113 |
#/ Returning false from a pre-step callback causes the collision to be ignored until the next step. |
| 114 |
TCollisionPreSolveFunc* = proc (arb: PArbiter; space: PSpace; |
| 115 |
data: pointer): bool {.cdecl.} |
| 116 |
#/ Collision post-solve event function callback type. |
| 117 |
TCollisionPostSolveFunc* = proc (arb: PArbiter; space: PSpace; |
| 118 |
data: pointer){.cdecl.} |
| 119 |
#/ Collision separate event function callback type. |
| 120 |
TCollisionSeparateFunc* = proc (arb: PArbiter; space: PSpace; |
| 121 |
data: pointer){.cdecl.} |
| 122 |
|
| 123 |
#/ Chipmunk's axis-aligned 2D bounding box type. (left, bottom, right, top) |
| 124 |
PBB* = ptr TBB |
| 125 |
TBB* {.pf.} = object |
| 126 |
l*, b*, r*, t*: CpFloat |
| 127 |
|
| 128 |
#/ Spatial index bounding box callback function type. |
| 129 |
#/ The spatial index calls this function and passes you a pointer to an object you added |
| 130 |
#/ when it needs to get the bounding box associated with that object. |
| 131 |
TSpatialIndexBBFunc* = proc (obj: pointer): TBB{.cdecl.} |
| 132 |
#/ Spatial index/object iterator callback function type. |
| 133 |
TSpatialIndexIteratorFunc* = proc (obj: pointer; data: pointer){.cdecl.} |
| 134 |
#/ Spatial query callback function type. |
| 135 |
TSpatialIndexQueryFunc* = proc (obj1: pointer; obj2: pointer; data: pointer){. |
| 136 |
cdecl.} |
| 137 |
#/ Spatial segment query callback function type. |
| 138 |
TSpatialIndexSegmentQueryFunc* = proc (obj1: pointer; obj2: pointer; |
| 139 |
data: pointer): CpFloat {.cdecl.} |
| 140 |
#/ private |
| 141 |
PSpatialIndex = ptr TSpatialIndex |
| 142 |
TSpatialIndex{.pf.} = object |
| 143 |
klass: PSpatialIndexClass |
| 144 |
bbfun: TSpatialIndexBBFunc |
| 145 |
staticIndex: PSpatialIndex |
| 146 |
dynamicIndex: PSpatialIndex |
| 147 |
|
| 148 |
TSpatialIndexDestroyImpl* = proc (index: PSpatialIndex){.cdecl.} |
| 149 |
TSpatialIndexCountImpl* = proc (index: PSpatialIndex): cint{.cdecl.} |
| 150 |
TSpatialIndexEachImpl* = proc (index: PSpatialIndex; |
| 151 |
fun: TSpatialIndexIteratorFunc; data: pointer){. |
| 152 |
cdecl.} |
| 153 |
TSpatialIndexContainsImpl* = proc (index: PSpatialIndex; obj: pointer; |
| 154 |
hashid: THashValue): Bool32 {.cdecl.} |
| 155 |
TSpatialIndexInsertImpl* = proc (index: PSpatialIndex; obj: pointer; |
| 156 |
hashid: THashValue){.cdecl.} |
| 157 |
TSpatialIndexRemoveImpl* = proc (index: PSpatialIndex; obj: pointer; |
| 158 |
hashid: THashValue){.cdecl.} |
| 159 |
TSpatialIndexReindexImpl* = proc (index: PSpatialIndex){.cdecl.} |
| 160 |
TSpatialIndexReindexObjectImpl* = proc (index: PSpatialIndex; |
| 161 |
obj: pointer; hashid: THashValue){.cdecl.} |
| 162 |
TSpatialIndexReindexQueryImpl* = proc (index: PSpatialIndex; |
| 163 |
fun: TSpatialIndexQueryFunc; data: pointer){.cdecl.} |
| 164 |
TSpatialIndexPointQueryImpl* = proc (index: PSpatialIndex; point: TVector; |
| 165 |
fun: TSpatialIndexQueryFunc; |
| 166 |
data: pointer){.cdecl.} |
| 167 |
TSpatialIndexSegmentQueryImpl* = proc (index: PSpatialIndex; obj: pointer; |
| 168 |
a: TVector; b: TVector; t_exit: CpFloat; fun: TSpatialIndexSegmentQueryFunc; |
| 169 |
data: pointer){.cdecl.} |
| 170 |
TSpatialIndexQueryImpl* = proc (index: PSpatialIndex; obj: pointer; |
| 171 |
bb: TBB; fun: TSpatialIndexQueryFunc; |
| 172 |
data: pointer){.cdecl.} |
| 173 |
PSpatialIndexClass* = ptr TSpatialIndexClass |
| 174 |
TSpatialIndexClass*{.pf.} = object |
| 175 |
destroy*: TSpatialIndexDestroyImpl |
| 176 |
count*: TSpatialIndexCountImpl |
| 177 |
each*: TSpatialIndexEachImpl |
| 178 |
contains*: TSpatialIndexContainsImpl |
| 179 |
insert*: TSpatialIndexInsertImpl |
| 180 |
remove*: TSpatialIndexRemoveImpl |
| 181 |
reindex*: TSpatialIndexReindexImpl |
| 182 |
reindexObject*: TSpatialIndexReindexObjectImpl |
| 183 |
reindexQuery*: TSpatialIndexReindexQueryImpl |
| 184 |
pointQuery*: TSpatialIndexPointQueryImpl |
| 185 |
segmentQuery*: TSpatialIndexSegmentQueryImpl |
| 186 |
query*: TSpatialIndexQueryImpl |
| 187 |
|
| 188 |
PSpaceHash* = ptr TSpaceHash |
| 189 |
TSpaceHash* {.pf.} = object |
| 190 |
PBBTree* = ptr TBBTree |
| 191 |
TBBTree* {.pf.} = object |
| 192 |
PSweep1D* = ptr TSweep1D |
| 193 |
TSweep1D* {.pf.} = object |
| 194 |
|
| 195 |
#/ Bounding box tree velocity callback function. |
| 196 |
#/ This function should return an estimate for the object's velocity. |
| 197 |
TBBTreeVelocityFunc* = proc (obj: pointer): TVector {.cdecl.} |
| 198 |
|
| 199 |
PContactBufferHeader* = ptr TContentBufferHeader |
| 200 |
TContentBufferHeader* {.pf.} = object |
| 201 |
TSpaceArbiterApplyImpulseFunc* = proc (arb: PArbiter){.cdecl.} |
| 202 |
|
| 203 |
PSpace* = ptr TSpace |
| 204 |
TSpace* {.pf.} = object |
| 205 |
iterations*: cint |
| 206 |
gravity*: TVector |
| 207 |
damping*: CpFloat |
| 208 |
idleSpeedThreshold*: CpFloat |
| 209 |
sleepTimeThreshold*: CpFloat |
| 210 |
collisionSlop*: CpFloat |
| 211 |
collisionBias*: CpFloat |
| 212 |
collisionPersistence*: TTimestamp |
| 213 |
enableContactGraph*: cint ##BOOL |
| 214 |
data*: pointer |
| 215 |
staticBody*: PBody |
| 216 |
stamp: TTimestamp |
| 217 |
currDT: CpFloat |
| 218 |
bodies: PArray |
| 219 |
rousedBodies: PArray |
| 220 |
sleepingComponents: PArray |
| 221 |
staticShapes: PSpatialIndex |
| 222 |
activeShapes: PSpatialIndex |
| 223 |
arbiters: PArray |
| 224 |
contactBuffersHead: PContactBufferHeader |
| 225 |
cachedArbiters: PHashSet |
| 226 |
pooledArbiters: PArray |
| 227 |
constraints: PArray |
| 228 |
allocatedBuffers: PArray |
| 229 |
locked: cint |
| 230 |
collisionHandlers: PHashSet |
| 231 |
defaultHandler: TCollisionHandler |
| 232 |
postStepCallbacks: PHashSet |
| 233 |
arbiterApplyImpulse: TSpaceArbiterApplyImpulseFunc |
| 234 |
staticBody2: TBody #_staticBody |
| 235 |
PBody* = ptr TBody |
| 236 |
TBody*{.pf.} = object |
| 237 |
velocityFunc*: TBodyVelocityFunc |
| 238 |
positionFunc*: TBodyPositionFunc |
| 239 |
m*: CpFloat |
| 240 |
mInv*: CpFloat |
| 241 |
i*: CpFloat |
| 242 |
iInv*: CpFloat |
| 243 |
p*: TVector |
| 244 |
v*: TVector |
| 245 |
f*: TVector |
| 246 |
a*: CpFloat |
| 247 |
w*: CpFloat |
| 248 |
t*: CpFloat |
| 249 |
rot*: TVector |
| 250 |
data*: pointer |
| 251 |
vLimit*: CpFloat |
| 252 |
wLimit*: CpFloat |
| 253 |
vBias*: TVector |
| 254 |
wBias*: CpFloat |
| 255 |
space*: PSpace |
| 256 |
shapeList*: PShape |
| 257 |
arbiterList*: PArbiter |
| 258 |
constraintList*: PConstraint |
| 259 |
node*: TComponentNode |
| 260 |
#/ Body/shape iterator callback function type. |
| 261 |
TBodyShapeIteratorFunc* = proc (body: PBody; shape: PShape; |
| 262 |
data: pointer) {.cdecl.} |
| 263 |
#/ Body/constraint iterator callback function type. |
| 264 |
TBodyConstraintIteratorFunc* = proc (body: PBody; |
| 265 |
constraint: PConstraint; |
| 266 |
data: pointer) {.cdecl.} |
| 267 |
#/ Body/arbiter iterator callback function type. |
| 268 |
TBodyArbiterIteratorFunc* = proc (body: PBody; arbiter: PArbiter; |
| 269 |
data: pointer) {.cdecl.} |
| 270 |
|
| 271 |
PNearestPointQueryInfo* = ptr TNearestPointQueryInfo |
| 272 |
#/ Nearest point query info struct. |
| 273 |
TNearestPointQueryInfo*{.pf.} = object |
| 274 |
shape: PShape #/ The nearest shape, NULL if no shape was within range. |
| 275 |
p: TVector #/ The closest point on the shape's surface. (in world space coordinates) |
| 276 |
d: CpFloat #/ The distance to the point. The distance is negative if the point is inside the shape. |
| 277 |
|
| 278 |
PSegmentQueryInfo* = ptr TSegmentQueryInfo |
| 279 |
#/ Segment query info struct. |
| 280 |
TSegmentQueryInfo*{.pf.} = object |
| 281 |
shape*: PShape #/ The shape that was hit, NULL if no collision occurred. |
| 282 |
t*: CpFloat #/ The normalized distance along the query segment in the range [0, 1]. |
| 283 |
n*: TVector #/ The normal of the surface hit. |
| 284 |
TShapeType*{.size: sizeof(cint).} = enum |
| 285 |
CP_CIRCLE_SHAPE, CP_SEGMENT_SHAPE, CP_POLY_SHAPE, CP_NUM_SHAPES |
| 286 |
TShapeCacheDataImpl* = proc (shape: PShape; p: TVector; rot: TVector): TBB{.cdecl.} |
| 287 |
TShapeDestroyImpl* = proc (shape: PShape){.cdecl.} |
| 288 |
TShapePointQueryImpl* = proc (shape: PShape; p: TVector): Bool32 {.cdecl.} |
| 289 |
TShapeSegmentQueryImpl* = proc (shape: PShape; a: TVector; b: TVector; |
| 290 |
info: PSegmentQueryInfo){.cdecl.} |
| 291 |
PShapeClass* = ptr TShapeClass |
| 292 |
TShapeClass*{.pf.} = object |
| 293 |
kind*: TShapeType |
| 294 |
cacheData*: TShapeCacheDataImpl |
| 295 |
destroy*: TShapeDestroyImpl |
| 296 |
pointQuery*: TShapePointQueryImpl |
| 297 |
segmentQuery*: TShapeSegmentQueryImpl |
| 298 |
PShape* = ptr TShape |
| 299 |
TShape*{.pf.} = object |
| 300 |
klass: PShapeClass #/ PRIVATE |
| 301 |
body*: PBody #/ The rigid body this collision shape is attached to. |
| 302 |
bb*: TBB #/ The current bounding box of the shape. |
| 303 |
sensor*: Bool32 #/ Sensor flag. |
| 304 |
#/ Sensor shapes call collision callbacks but don't produce collisions. |
| 305 |
e*: CpFloat #/ Coefficient of restitution. (elasticity) |
| 306 |
u*: CpFloat #/ Coefficient of friction. |
| 307 |
surface_v*: TVector #/ Surface velocity used when solving for friction. |
| 308 |
data*: pointer #/ User definable data pointer. Generally this points to your the game object class so you can access it when given a cpShape reference in a callback. |
| 309 |
collision_type*: TCollisionType #/ Collision type of this shape used when picking collision handlers. |
| 310 |
group*: TGroup #/ Group of this shape. Shapes in the same group don't collide. |
| 311 |
layers*: TLayers #/ Layer bitmask for this shape. Shapes only collide if the bitwise and of their layers is non-zero. |
| 312 |
space: PSpace #PRIVATE |
| 313 |
next: PShape #PRIVATE |
| 314 |
prev: PShape #PRIVATE |
| 315 |
hashid: THashValue #PRIVATE |
| 316 |
PCircleShape* = ptr TCircleShape |
| 317 |
TCircleShape*{.pf.} = object |
| 318 |
shape: PShape |
| 319 |
c, tc: TVector |
| 320 |
r: CpFloat |
| 321 |
PPolyShape* = ptr TPolyShape |
| 322 |
TPolyShape*{.pf.} = object |
| 323 |
shape: PShape |
| 324 |
numVerts: cint |
| 325 |
verts, tVerts: TVector |
| 326 |
planes, tPlanes: PSplittingPlane |
| 327 |
PSegmentShape* = ptr TSegmentShape |
| 328 |
TSegmentShape*{.pf.} = object |
| 329 |
shape: PShape |
| 330 |
a, b, n: TVector |
| 331 |
ta, tb, tn: TVector |
| 332 |
r: CpFloat |
| 333 |
aTangent, bTangent: TVector |
| 334 |
PSplittingPlane* = ptr TSplittingPlane |
| 335 |
TSplittingPlane*{.pf.} = object |
| 336 |
n: TVector |
| 337 |
d: CpFloat |
| 338 |
|
| 339 |
#/ Post Step callback function type. |
| 340 |
TPostStepFunc* = proc (space: PSpace; obj: pointer; data: pointer){.cdecl.} |
| 341 |
#/ Point query callback function type. |
| 342 |
TSpacePointQueryFunc* = proc (shape: PShape; data: pointer){.cdecl.} |
| 343 |
#/ Segment query callback function type. |
| 344 |
TSpaceSegmentQueryFunc* = proc (shape: PShape; t: CpFloat; n: TVector; |
| 345 |
data: pointer){.cdecl.} |
| 346 |
#/ Rectangle Query callback function type. |
| 347 |
TSpaceBBQueryFunc* = proc (shape: PShape; data: pointer){.cdecl.} |
| 348 |
#/ Shape query callback function type. |
| 349 |
TSpaceShapeQueryFunc* = proc (shape: PShape; points: PContactPointSet; |
| 350 |
data: pointer){.cdecl.} |
| 351 |
#/ Space/body iterator callback function type. |
| 352 |
TSpaceBodyIteratorFunc* = proc (body: PBody; data: pointer){.cdecl.} |
| 353 |
#/ Space/body iterator callback function type. |
| 354 |
TSpaceShapeIteratorFunc* = proc (shape: PShape; data: pointer){.cdecl.} |
| 355 |
#/ Space/constraint iterator callback function type. |
| 356 |
TSpaceConstraintIteratorFunc* = proc (constraint: PConstraint; |
| 357 |
data: pointer){.cdecl.} |
| 358 |
#/ Opaque cpConstraint struct. |
| 359 |
PConstraint* = ptr TConstraint |
| 360 |
TConstraint*{.pf.} = object |
| 361 |
klass: PConstraintClass #/PRIVATE |
| 362 |
a*: PBody #/ The first body connected to this constraint. |
| 363 |
b*: PBody #/ The second body connected to this constraint. |
| 364 |
space: PSpace #/PRIVATE |
| 365 |
next_a: PConstraint #/PRIVATE |
| 366 |
next_b: PConstraint #/PRIVATE |
| 367 |
maxForce*: CpFloat #/ The maximum force that this constraint is allowed to use. Defaults to infinity. |
| 368 |
errorBias*: CpFloat #/ The rate at which joint error is corrected. Defaults to pow(1.0 - 0.1, 60.0) meaning that it will correct 10% of the error every 1/60th of a second. |
| 369 |
maxBias*: CpFloat #/ The maximum rate at which joint error is corrected. Defaults to infinity. |
| 370 |
preSolve*: TConstraintPreSolveFunc #/ Function called before the solver runs. Animate your joint anchors, update your motor torque, etc. |
| 371 |
postSolve*: TConstraintPostSolveFunc #/ Function called after the solver runs. Use the applied impulse to perform effects like breakable joints. |
| 372 |
data*: CpDataPointer # User definable data pointer. Generally this points to your the game object class so you can access it when given a cpConstraint reference in a callback. |
| 373 |
TConstraintPreStepImpl = proc (constraint: PConstraint; dt: CpFloat){.cdecl.} |
| 374 |
TConstraintApplyCachedImpulseImpl = proc (constraint: PConstraint; dt_coef: CpFloat){.cdecl.} |
| 375 |
TConstraintApplyImpulseImpl = proc (constraint: PConstraint){.cdecl.} |
| 376 |
TConstraintGetImpulseImpl = proc (constraint: PConstraint): CpFloat{.cdecl.} |
| 377 |
PConstraintClass = ptr TConstraintClass |
| 378 |
TConstraintClass{.pf.} = object |
| 379 |
preStep*: TConstraintPreStepImpl |
| 380 |
applyCachedImpulse*: TConstraintApplyCachedImpulseImpl |
| 381 |
applyImpulse*: TConstraintApplyImpulseImpl |
| 382 |
getImpulse*: TConstraintGetImpulseImpl |
| 383 |
#/ Callback function type that gets called before solving a joint. |
| 384 |
TConstraintPreSolveFunc* = proc (constraint: PConstraint; space: PSpace){. |
| 385 |
cdecl.} |
| 386 |
#/ Callback function type that gets called after solving a joint. |
| 387 |
TConstraintPostSolveFunc* = proc (constraint: PConstraint; space: PSpace){. |
| 388 |
cdecl.} |
| 389 |
|
| 390 |
##cp property emulators |
| 391 |
template defGetter(otype: typedesc, memberType: typedesc, memberName, procName: untyped) = |
| 392 |
proc `get procName`*(obj: otype): memberType {.cdecl.} = |
| 393 |
return obj.memberName |
| 394 |
template defSetter(otype: typedesc, memberType: typedesc, memberName, procName: untyped) = |
| 395 |
proc `set procName`*(obj: otype, value: memberType) {.cdecl.} = |
| 396 |
obj.memberName = value |
| 397 |
template defProp(otype: typedesc, memberType: typedesc, memberName, procName: untyped) = |
| 398 |
defGetter(otype, memberType, memberName, procName) |
| 399 |
defSetter(otype, memberType, memberName, procName) |
| 400 |
|
| 401 |
|
| 402 |
##cpspace.h |
| 403 |
proc allocSpace*(): PSpace {. |
| 404 |
importc: "cpSpaceAlloc", dynlib: Lib.} |
| 405 |
proc Init*(space: PSpace): PSpace {. |
| 406 |
importc: "cpSpaceInit", dynlib: Lib.} |
| 407 |
proc newSpace*(): PSpace {. |
| 408 |
importc: "cpSpaceNew", dynlib: Lib.} |
| 409 |
proc destroy*(space: PSpace) {. |
| 410 |
importc: "cpSpaceDestroy", dynlib: Lib.} |
| 411 |
proc free*(space: PSpace) {. |
| 412 |
importc: "cpSpaceFree", dynlib: Lib.} |
| 413 |
|
| 414 |
defProp(PSpace, cint, iterations, Iterations) |
| 415 |
defProp(PSpace, TVector, gravity, Gravity) |
| 416 |
defProp(PSpace, CpFloat, damping, Damping) |
| 417 |
defProp(PSpace, CpFloat, idleSpeedThreshold, IdleSpeedThreshold) |
| 418 |
defProp(PSpace, CpFloat, sleepTimeThreshold, SleepTimeThreshold) |
| 419 |
defProp(PSpace, CpFloat, collisionSlop, CollisionSlop) |
| 420 |
defProp(PSpace, CpFloat, collisionBias, CollisionBias) |
| 421 |
defProp(PSpace, TTimestamp, collisionPersistence, CollisionPersistence) |
| 422 |
defProp(PSpace, Bool32, enableContactGraph, EnableContactGraph) |
| 423 |
defProp(PSpace, pointer, data, UserData) |
| 424 |
defGetter(PSpace, PBody, staticBody, StaticBody) |
| 425 |
defGetter(PSpace, CpFloat, currDt, CurrentTimeStep) |
| 426 |
|
| 427 |
|
| 428 |
#/ returns true from inside a callback and objects cannot be added/removed. |
| 429 |
proc isLocked*(space: PSpace): bool{.inline.} = |
| 430 |
result = space.locked.bool |
| 431 |
|
| 432 |
#/ Set a default collision handler for this space. |
| 433 |
#/ The default collision handler is invoked for each colliding pair of shapes |
| 434 |
#/ that isn't explicitly handled by a specific collision handler. |
| 435 |
#/ You can pass NULL for any function you don't want to implement. |
| 436 |
proc setDefaultCollisionHandler*(space: PSpace; begin: TCollisionBeginFunc; |
| 437 |
preSolve: TCollisionPreSolveFunc; |
| 438 |
postSolve: TCollisionPostSolveFunc; |
| 439 |
separate: TCollisionSeparateFunc; |
| 440 |
data: pointer){. |
| 441 |
cdecl, importc: "cpSpaceSetDefaultCollisionHandler", dynlib: Lib.} |
| 442 |
#/ Set a collision handler to be used whenever the two shapes with the given collision types collide. |
| 443 |
#/ You can pass NULL for any function you don't want to implement. |
| 444 |
proc addCollisionHandler*(space: PSpace; a, b: TCollisionType; |
| 445 |
begin: TCollisionBeginFunc; |
| 446 |
preSolve: TCollisionPreSolveFunc; |
| 447 |
postSolve: TCollisionPostSolveFunc; |
| 448 |
separate: TCollisionSeparateFunc; data: pointer){. |
| 449 |
cdecl, importc: "cpSpaceAddCollisionHandler", dynlib: Lib.} |
| 450 |
#/ Unset a collision handler. |
| 451 |
proc removeCollisionHandler*(space: PSpace; a: TCollisionType; |
| 452 |
b: TCollisionType){. |
| 453 |
cdecl, importc: "cpSpaceRemoveCollisionHandler", dynlib: Lib.} |
| 454 |
#/ Add a collision shape to the simulation. |
| 455 |
#/ If the shape is attached to a static body, it will be added as a static shape. |
| 456 |
proc addShape*(space: PSpace; shape: PShape): PShape{. |
| 457 |
cdecl, importc: "cpSpaceAddShape", dynlib: Lib.} |
| 458 |
#/ Explicitly add a shape as a static shape to the simulation. |
| 459 |
proc addStaticShape*(space: PSpace; shape: PShape): PShape{. |
| 460 |
cdecl, importc: "cpSpaceAddStaticShape", dynlib: Lib.} |
| 461 |
#/ Add a rigid body to the simulation. |
| 462 |
proc addBody*(space: PSpace; body: PBody): PBody{. |
| 463 |
cdecl, importc: "cpSpaceAddBody", dynlib: Lib.} |
| 464 |
#/ Add a constraint to the simulation. |
| 465 |
proc addConstraint*(space: PSpace; constraint: PConstraint): PConstraint{. |
| 466 |
cdecl, importc: "cpSpaceAddConstraint", dynlib: Lib.} |
| 467 |
#/ Remove a collision shape from the simulation. |
| 468 |
proc removeShape*(space: PSpace; shape: PShape){. |
| 469 |
cdecl, importc: "cpSpaceRemoveShape", dynlib: Lib.} |
| 470 |
#/ Remove a collision shape added using cpSpaceAddStaticShape() from the simulation. |
| 471 |
proc removeStaticShape*(space: PSpace; shape: PShape){. |
| 472 |
cdecl, importc: "cpSpaceRemoveStaticShape", dynlib: Lib.} |
| 473 |
#/ Remove a rigid body from the simulation. |
| 474 |
proc removeBody*(space: PSpace; body: PBody){. |
| 475 |
cdecl, importc: "cpSpaceRemoveBody", dynlib: Lib.} |
| 476 |
#/ Remove a constraint from the simulation. |
| 477 |
proc RemoveConstraint*(space: PSpace; constraint: PConstraint){. |
| 478 |
cdecl, importc: "cpSpaceRemoveConstraint", dynlib: Lib.} |
| 479 |
#/ Test if a collision shape has been added to the space. |
| 480 |
proc containsShape*(space: PSpace; shape: PShape): bool{. |
| 481 |
cdecl, importc: "cpSpaceContainsShape", dynlib: Lib.} |
| 482 |
#/ Test if a rigid body has been added to the space. |
| 483 |
proc containsBody*(space: PSpace; body: PBody): bool{. |
| 484 |
cdecl, importc: "cpSpaceContainsBody", dynlib: Lib.} |
| 485 |
#/ Test if a constraint has been added to the space. |
| 486 |
|
| 487 |
proc containsConstraint*(space: PSpace; constraint: PConstraint): bool{. |
| 488 |
cdecl, importc: "cpSpaceContainsConstraint", dynlib: Lib.} |
| 489 |
#/ Schedule a post-step callback to be called when cpSpaceStep() finishes. |
| 490 |
#/ @c obj is used a key, you can only register one callback per unique value for @c obj |
| 491 |
proc addPostStepCallback*(space: PSpace; fun: TPostStepFunc; |
| 492 |
obj: pointer; data: pointer){. |
| 493 |
cdecl, importc: "cpSpaceAddPostStepCallback", dynlib: Lib.} |
| 494 |
|
| 495 |
#/ Query the space at a point and call @c func for each shape found. |
| 496 |
proc pointQuery*(space: PSpace; point: TVector; layers: TLayers; |
| 497 |
group: TGroup; fun: TSpacePointQueryFunc; data: pointer){. |
| 498 |
cdecl, importc: "cpSpacePointQuery", dynlib: Lib.} |
| 499 |
|
| 500 |
#/ Query the space at a point and return the first shape found. Returns NULL if no shapes were found. |
| 501 |
proc pointQueryFirst*(space: PSpace; point: TVector; layers: TLayers; |
| 502 |
group: TGroup): PShape{. |
| 503 |
cdecl, importc: "cpSpacePointQueryFirst", dynlib: Lib.} |
| 504 |
|
| 505 |
#/ Perform a directed line segment query (like a raycast) against the space calling @c func for each shape intersected. |
| 506 |
proc segmentQuery*(space: PSpace; start: TVector; to: TVector; |
| 507 |
layers: TLayers; group: TGroup; |
| 508 |
fun: TSpaceSegmentQueryFunc; data: pointer){. |
| 509 |
cdecl, importc: "cpSpaceSegmentQuery", dynlib: Lib.} |
| 510 |
#/ Perform a directed line segment query (like a raycast) against the space and return the first shape hit. Returns NULL if no shapes were hit. |
| 511 |
proc segmentQueryFirst*(space: PSpace; start: TVector; to: TVector; |
| 512 |
layers: TLayers; group: TGroup; |
| 513 |
res: PSegmentQueryInfo): PShape{. |
| 514 |
cdecl, importc: "cpSpaceSegmentQueryFirst", dynlib: Lib.} |
| 515 |
|
| 516 |
#/ Perform a fast rectangle query on the space calling @c func for each shape found. |
| 517 |
#/ Only the shape's bounding boxes are checked for overlap, not their full shape. |
| 518 |
proc BBQuery*(space: PSpace; bb: TBB; layers: TLayers; group: TGroup; |
| 519 |
fun: TSpaceBBQueryFunc; data: pointer){. |
| 520 |
cdecl, importc: "cpSpaceBBQuery", dynlib: Lib.} |
| 521 |
|
| 522 |
#/ Query a space for any shapes overlapping the given shape and call @c func for each shape found. |
| 523 |
proc shapeQuery*(space: PSpace; shape: PShape; fun: TSpaceShapeQueryFunc; data: pointer): bool {. |
| 524 |
cdecl, importc: "cpSpaceShapeQuery", dynlib: Lib.} |
| 525 |
#/ Call cpBodyActivate() for any shape that is overlaps the given shape. |
| 526 |
proc activateShapesTouchingShape*(space: PSpace; shape: PShape){. |
| 527 |
cdecl, importc: "cpSpaceActivateShapesTouchingShape", dynlib: Lib.} |
| 528 |
|
| 529 |
#/ Call @c func for each body in the space. |
| 530 |
proc eachBody*(space: PSpace; fun: TSpaceBodyIteratorFunc; data: pointer){. |
| 531 |
cdecl, importc: "cpSpaceEachBody", dynlib: Lib.} |
| 532 |
|
| 533 |
#/ Call @c func for each shape in the space. |
| 534 |
proc eachShape*(space: PSpace; fun: TSpaceShapeIteratorFunc; |
| 535 |
data: pointer){. |
| 536 |
cdecl, importc: "cpSpaceEachShape", dynlib: Lib.} |
| 537 |
#/ Call @c func for each shape in the space. |
| 538 |
proc eachConstraint*(space: PSpace; fun: TSpaceConstraintIteratorFunc; |
| 539 |
data: pointer){. |
| 540 |
cdecl, importc: "cpSpaceEachConstraint", dynlib: Lib.} |
| 541 |
#/ Update the collision detection info for the static shapes in the space. |
| 542 |
proc reindexStatic*(space: PSpace){. |
| 543 |
cdecl, importc: "cpSpaceReindexStatic", dynlib: Lib.} |
| 544 |
#/ Update the collision detection data for a specific shape in the space. |
| 545 |
proc reindexShape*(space: PSpace; shape: PShape){. |
| 546 |
cdecl, importc: "cpSpaceReindexShape", dynlib: Lib.} |
| 547 |
#/ Update the collision detection data for all shapes attached to a body. |
| 548 |
proc reindexShapesForBody*(space: PSpace; body: PBody){. |
| 549 |
cdecl, importc: "cpSpaceReindexShapesForBody", dynlib: Lib.} |
| 550 |
#/ Switch the space to use a spatial has as it's spatial index. |
| 551 |
proc SpaceUseSpatialHash*(space: PSpace; dim: CpFloat; count: cint){. |
| 552 |
cdecl, importc: "cpSpaceUseSpatialHash", dynlib: Lib.} |
| 553 |
#/ Step the space forward in time by @c dt. |
| 554 |
proc step*(space: PSpace; dt: CpFloat) {. |
| 555 |
cdecl, importc: "cpSpaceStep", dynlib: Lib.} |
| 556 |
|
| 557 |
|
| 558 |
#/ Convenience constructor for cpVect structs. |
| 559 |
proc vector*(x, y: CpFloat): TVector {.inline.} = |
| 560 |
result.x = x |
| 561 |
result.y = y |
| 562 |
proc newVector*(x, y: CpFloat): TVector {.inline.} = |
| 563 |
return vector(x, y) |
| 564 |
#let VectorZero* = newVector(0.0, 0.0) |
| 565 |
var VectorZero* = newVector(0.0, 0.0) |
| 566 |
|
| 567 |
#/ Vector dot product. |
| 568 |
proc dot*(v1, v2: TVector): CpFloat {.inline.} = |
| 569 |
result = v1.x * v2.x + v1.y * v2.y |
| 570 |
|
| 571 |
#/ Returns the length of v. |
| 572 |
#proc len*(v: TVector): CpFloat {. |
| 573 |
# cdecl, importc: "cpvlength", dynlib: Lib.} |
| 574 |
proc len*(v: TVector): CpFloat {.inline.} = |
| 575 |
result = v.dot(v).sqrt |
| 576 |
#/ Spherical linearly interpolate between v1 and v2. |
| 577 |
proc slerp*(v1, v2: TVector; t: CpFloat): TVector {. |
| 578 |
cdecl, importc: "cpvslerp", dynlib: Lib.} |
| 579 |
#/ Spherical linearly interpolate between v1 towards v2 by no more than angle a radians |
| 580 |
proc slerpconst*(v1, v2: TVector; a: CpFloat): TVector {. |
| 581 |
cdecl, importc: "cpvslerpconst", dynlib: Lib.} |
| 582 |
#/ Returns the unit length vector for the given angle (in radians). |
| 583 |
#proc vectorForAngle*(a: CpFloat): TVector {. |
| 584 |
# cdecl, importc: "cpvforangle", dynlib: Lib.} |
| 585 |
proc vectorForAngle*(a: CpFloat): TVector {.inline.} = |
| 586 |
result = newVector(math.cos(a), math.sin(a)) |
| 587 |
#/ Returns the angular direction v is pointing in (in radians). |
| 588 |
proc toAngle*(v: TVector): CpFloat {.inline.} = |
| 589 |
result = math.arctan2(v.y, v.x) |
| 590 |
#/ Returns a string representation of v. Intended mostly for debugging purposes and not production use. |
| 591 |
#/ @attention The string points to a static local and is reset every time the function is called. |
| 592 |
#/ If you want to print more than one vector you will have to split up your printing onto separate lines. |
| 593 |
proc `$`*(v: TVector): cstring {.cdecl, importc: "cpvstr", dynlib: Lib.} |
| 594 |
|
| 595 |
|
| 596 |
#/ Check if two vectors are equal. (Be careful when comparing floating point numbers!) |
| 597 |
proc `==`*(v1, v2: TVector): bool {.inline.} = |
| 598 |
result = v1.x == v2.x and v1.y == v2.y |
| 599 |
|
| 600 |
#/ Add two vectors |
| 601 |
proc `+`*(v1, v2: TVector): TVector {.inline.} = |
| 602 |
result = newVector(v1.x + v2.x, v1.y + v2.y) |
| 603 |
proc `+=`*(v1: var TVector; v2: TVector) = |
| 604 |
v1.x = v1.x + v2.x |
| 605 |
v1.y = v1.y + v2.y |
| 606 |
|
| 607 |
#/ Subtract two vectors. |
| 608 |
proc `-`*(v1, v2: TVector): TVector {.inline.} = |
| 609 |
result = newVector(v1.x - v2.x, v1.y - v2.y) |
| 610 |
proc `-=`*(v1: var TVector; v2: TVector) = |
| 611 |
v1.x = v1.x - v2.x |
| 612 |
v1.y = v1.y - v2.y |
| 613 |
|
| 614 |
#/ Negate a vector. |
| 615 |
proc `-`*(v: TVector): TVector {.inline.} = |
| 616 |
result = newVector(- v.x, - v.y) |
| 617 |
|
| 618 |
#/ Scalar multiplication. |
| 619 |
proc `*`*(v: TVector, s: CpFloat): TVector {.inline.} = |
| 620 |
result.x = v.x * s |
| 621 |
result.y = v.y * s |
| 622 |
proc `*=`*(v: var TVector; s: CpFloat) = |
| 623 |
v.x = v.x * s |
| 624 |
v.y = v.y * s |
| 625 |
|
| 626 |
#/ 2D vector cross product analog. |
| 627 |
#/ The cross product of 2D vectors results in a 3D vector with only a z component. |
| 628 |
#/ This function returns the magnitude of the z value. |
| 629 |
proc cross*(v1, v2: TVector): CpFloat {.inline.} = |
| 630 |
result = v1.x * v2.y - v1.y * v2.x |
| 631 |
|
| 632 |
#/ Returns a perpendicular vector. (90 degree rotation) |
| 633 |
proc perp*(v: TVector): TVector {.inline.} = |
| 634 |
result = newVector(- v.y, v.x) |
| 635 |
|
| 636 |
#/ Returns a perpendicular vector. (-90 degree rotation) |
| 637 |
proc rperp*(v: TVector): TVector {.inline.} = |
| 638 |
result = newVector(v.y, - v.x) |
| 639 |
|
| 640 |
#/ Returns the vector projection of v1 onto v2. |
| 641 |
proc project*(v1,v2: TVector): TVector {.inline.} = |
| 642 |
result = v2 * (v1.dot(v2) / v2.dot(v2)) |
| 643 |
|
| 644 |
#/ Uses complex number multiplication to rotate v1 by v2. Scaling will occur if v1 is not a unit vector. |
| 645 |
|
| 646 |
proc rotate*(v1, v2: TVector): TVector {.inline.} = |
| 647 |
result = newVector(v1.x * v2.x - v1.y * v2.y, v1.x * v2.y + v1.y * v2.x) |
| 648 |
#/ Inverse of cpvrotate(). |
| 649 |
proc unrotate*(v1, v2: TVector): TVector {.inline.} = |
| 650 |
result = newVector(v1.x * v2.x + v1.y * v2.y, v1.y * v2.x - v1.x * v2.y) |
| 651 |
#/ Returns the squared length of v. Faster than cpvlength() when you only need to compare lengths. |
| 652 |
proc lenSq*(v: TVector): CpFloat {.inline.} = |
| 653 |
result = v.dot(v) |
| 654 |
#/ Linearly interpolate between v1 and v2. |
| 655 |
proc lerp*(v1, v2: TVector; t: CpFloat): TVector {.inline.} = |
| 656 |
result = (v1 * (1.0 - t)) + (v2 * t) |
| 657 |
#/ Returns a normalized copy of v. |
| 658 |
proc normalize*(v: TVector): TVector {.inline.} = |
| 659 |
result = v * (1.0 / v.len) |
| 660 |
#/ Returns a normalized copy of v or cpvzero if v was already cpvzero. Protects against divide by zero errors. |
| 661 |
proc normalizeSafe*(v: TVector): TVector {.inline.} = |
| 662 |
result = if v.x == 0.0 and v.y == 0.0: VectorZero else: v.normalize |
| 663 |
#/ Clamp v to length len. |
| 664 |
proc clamp*(v: TVector; len: CpFloat): TVector {.inline.} = |
| 665 |
result = if v.dot(v) > len * len: v.normalize * len else: v |
| 666 |
#/ Linearly interpolate between v1 towards v2 by distance d. |
| 667 |
proc lerpconst*(v1, v2: TVector; d: CpFloat): TVector {.inline.} = |
| 668 |
result = v1 + clamp(v2 - v1, d) #vadd(v1 + vclamp(vsub(v2, v1), d)) |
| 669 |
#/ Returns the distance between v1 and v2. |
| 670 |
proc dist*(v1, v2: TVector): CpFloat {.inline.} = |
| 671 |
result = (v1 - v2).len #vlength(vsub(v1, v2)) |
| 672 |
#/ Returns the squared distance between v1 and v2. Faster than cpvdist() when you only need to compare distances. |
| 673 |
proc distsq*(v1, v2: TVector): CpFloat {.inline.} = |
| 674 |
result = (v1 - v2).lenSq #vlengthsq(vsub(v1, v2)) |
| 675 |
#/ Returns true if the distance between v1 and v2 is less than dist. |
| 676 |
proc near*(v1, v2: TVector; dist: CpFloat): bool{.inline.} = |
| 677 |
result = v1.distSq(v2) < dist * dist |
| 678 |
|
| 679 |
|
| 680 |
|
| 681 |
##cpBody.h |
| 682 |
proc allocBody*(): PBody {.importc: "cpBodyAlloc", dynlib: Lib.} |
| 683 |
proc init*(body: PBody; m: CpFloat; i: CpFloat): PBody {. |
| 684 |
importc: "cpBodyInit", dynlib: Lib.} |
| 685 |
proc newBody*(m: CpFloat; i: CpFloat): PBody {. |
| 686 |
importc: "cpBodyNew", dynlib: Lib.} |
| 687 |
|
| 688 |
proc initStaticBody*(body: PBody): PBody{. |
| 689 |
importc: "cpBodyInitStatic", dynlib: Lib.} |
| 690 |
#/ Allocate and initialize a static cpBody. |
| 691 |
proc newStatic*(): PBody{.importc: "cpBodyNewStatic", dynlib: Lib.} |
| 692 |
#/ Destroy a cpBody. |
| 693 |
proc destroy*(body: PBody){.importc: "cpBodyDestroy", dynlib: Lib.} |
| 694 |
#/ Destroy and free a cpBody. |
| 695 |
proc free*(body: PBody){.importc: "cpBodyFree", dynlib: Lib.} |
| 696 |
|
| 697 |
#/ Wake up a sleeping or idle body. |
| 698 |
proc activate*(body: PBody){.importc: "cpBodyActivate", dynlib: Lib.} |
| 699 |
#/ Wake up any sleeping or idle bodies touching a static body. |
| 700 |
proc activateStatic*(body: PBody; filter: PShape){. |
| 701 |
importc: "cpBodyActivateStatic", dynlib: Lib.} |
| 702 |
#/ Force a body to fall asleep immediately. |
| 703 |
proc Sleep*(body: PBody){.importc: "cpBodySleep", dynlib: Lib.} |
| 704 |
#/ Force a body to fall asleep immediately along with other bodies in a group. |
| 705 |
proc SleepWithGroup*(body: PBody; group: PBody){. |
| 706 |
importc: "cpBodySleepWithGroup", dynlib: Lib.} |
| 707 |
#/ Returns true if the body is sleeping. |
| 708 |
proc isSleeping*(body: PBody): bool {.inline.} = |
| 709 |
return body.node.root != nil |
| 710 |
#/ Returns true if the body is static. |
| 711 |
proc isStatic*(body: PBody): bool {.inline.} = |
| 712 |
return body.node.idleTime == CpInfinity |
| 713 |
#/ Returns true if the body has not been added to a space. |
| 714 |
proc isRogue*(body: PBody): bool {.inline.} = |
| 715 |
return body.space == nil |
| 716 |
|
| 717 |
# #define CP_DefineBodyStructGetter(type, member, name) \ |
| 718 |
# static inline type cpBodyGet##name(const cpBody *body){return body->member;} |
| 719 |
# #define CP_DefineBodyStructSetter(type, member, name) \ |
| 720 |
# static inline void cpBodySet##name(cpBody *body, const type value){ \ |
| 721 |
# cpBodyActivate(body); \ |
| 722 |
# cpBodyAssertSane(body); \ |
| 723 |
# body->member = value; \ |
| 724 |
# } |
| 725 |
# #define CP_DefineBodyStructProperty(type, member, name) \ |
| 726 |
# CP_DefineBodyStructGetter(type, member, name) \ |
| 727 |
# CP_DefineBodyStructSetter(type, member, name) |
| 728 |
|
| 729 |
defGetter(PBody, CpFloat, m, Mass) |
| 730 |
#/ Set the mass of a body. |
| 731 |
when defined(MoreNim): |
| 732 |
defSetter(PBody, CpFloat, m, Mass) |
| 733 |
else: |
| 734 |
proc setMass*(body: PBody; m: CpFloat){. |
| 735 |
cdecl, importc: "cpBodySetMass", dynlib: Lib.} |
| 736 |
|
| 737 |
#/ Get the moment of a body. |
| 738 |
defGetter(PBody, CpFloat, i, Moment) |
| 739 |
#/ Set the moment of a body. |
| 740 |
when defined(MoreNim): |
| 741 |
defSetter(PBody, CpFloat, i, Moment) |
| 742 |
else: |
| 743 |
proc SetMoment*(body: PBody; i: CpFloat) {. |
| 744 |
cdecl, importc: "cpBodySetMoment", dynlib: Lib.} |
| 745 |
|
| 746 |
#/ Get the position of a body. |
| 747 |
defGetter(PBody, TVector, p, Pos) |
| 748 |
#/ Set the position of a body. |
| 749 |
when defined(MoreNim): |
| 750 |
defSetter(PBody, TVector, p, Pos) |
| 751 |
else: |
| 752 |
proc setPos*(body: PBody; pos: TVector) {. |
| 753 |
cdecl, importc: "cpBodySetPos", dynlib: Lib.} |
| 754 |
|
| 755 |
defProp(PBody, TVector, v, Vel) |
| 756 |
defProp(PBody, TVector, f, Force) |
| 757 |
|
| 758 |
#/ Get the angle of a body. |
| 759 |
defGetter(PBody, CpFloat, a, Angle) |
| 760 |
#/ Set the angle of a body. |
| 761 |
proc setAngle*(body: PBody; a: CpFloat){. |
| 762 |
cdecl, importc: "cpBodySetAngle", dynlib: Lib.} |
| 763 |
|
| 764 |
defProp(PBody, CpFloat, w, AngVel) |
| 765 |
defProp(PBody, CpFloat, t, Torque) |
| 766 |
defGetter(PBody, TVector, rot, Rot) |
| 767 |
defProp(PBody, CpFloat, v_limit, VelLimit) |
| 768 |
defProp(PBody, CpFloat, w_limit, AngVelLimit) |
| 769 |
defProp(PBody, pointer, data, UserData) |
| 770 |
|
| 771 |
#/ Default Integration functions. |
| 772 |
proc UpdateVelocity*(body: PBody; gravity: TVector; damping: CpFloat; dt: CpFloat){. |
| 773 |
cdecl, importc: "cpBodyUpdateVelocity", dynlib: Lib.} |
| 774 |
proc UpdatePosition*(body: PBody; dt: CpFloat){. |
| 775 |
cdecl, importc: "cpBodyUpdatePosition", dynlib: Lib.} |
| 776 |
#/ Convert body relative/local coordinates to absolute/world coordinates. |
| 777 |
proc Local2World*(body: PBody; v: TVector): TVector{.inline.} = |
| 778 |
result = body.p + v.rotate(body.rot) ##return cpvadd(body.p, cpvrotate(v, body.rot)) |
| 779 |
#/ Convert body absolute/world coordinates to relative/local coordinates. |
| 780 |
proc world2Local*(body: PBody; v: TVector): TVector{.inline.} = |
| 781 |
result = (v - body.p).unrotate(body.rot) |
| 782 |
#/ Set the forces and torque or a body to zero. |
| 783 |
proc resetForces*(body: PBody){. |
| 784 |
cdecl, importc: "cpBodyResetForces", dynlib: Lib.} |
| 785 |
#/ Apply an force (in world coordinates) to the body at a point relative to the center of gravity (also in world coordinates). |
| 786 |
proc applyForce*(body: PBody; f, r: TVector){. |
| 787 |
cdecl, importc: "cpBodyApplyForce", dynlib: Lib.} |
| 788 |
#/ Apply an impulse (in world coordinates) to the body at a point relative to the center of gravity (also in world coordinates). |
| 789 |
proc applyImpulse*(body: PBody; j, r: TVector){. |
| 790 |
cdecl, importc: "cpBodyApplyImpulse", dynlib: Lib.} |
| 791 |
#/ Get the velocity on a body (in world units) at a point on the body in world coordinates. |
| 792 |
|
| 793 |
proc getVelAtWorldPoint*(body: PBody; point: TVector): TVector{. |
| 794 |
cdecl, importc: "cpBodyGetVelAtWorldPoint", dynlib: Lib.} |
| 795 |
#/ Get the velocity on a body (in world units) at a point on the body in local coordinates. |
| 796 |
proc getVelAtLocalPoint*(body: PBody; point: TVector): TVector{. |
| 797 |
cdecl, importc: "cpBodyGetVelAtLocalPoint", dynlib: Lib.} |
| 798 |
#/ Get the kinetic energy of a body. |
| 799 |
# static inline CpFloat cpBodyKineticEnergy(const cpBody *body) |
| 800 |
# { |
| 801 |
# // Need to do some fudging to avoid NaNs |
| 802 |
# cpFloat vsq = cpvdot(body->v, body->v); |
| 803 |
# cpFloat wsq = body->w*body->w; |
| 804 |
# return (vsq ? vsq*body->m : 0.0f) + (wsq ? wsq*body->i : 0.0f); |
| 805 |
# } |
| 806 |
proc kineticEnergy*(body: PBOdy): CpFloat = |
| 807 |
result = (body.v.dot(body.v) * body.m) + (body.w * body.w * body.i) |
| 808 |
|
| 809 |
#/ Call @c func once for each shape attached to @c body and added to the space. |
| 810 |
proc eachShape*(body: PBody; fun: TBodyShapeIteratorFunc; |
| 811 |
data: pointer){. |
| 812 |
cdecl, importc: "cpBodyEachShape", dynlib: Lib.} |
| 813 |
#/ Call @c func once for each constraint attached to @c body and added to the space. |
| 814 |
proc eachConstraint*(body: PBody; fun: TBodyConstraintIteratorFunc; |
| 815 |
data: pointer) {. |
| 816 |
cdecl, importc: "cpBodyEachConstraint", dynlib: Lib.} |
| 817 |
#/ Call @c func once for each arbiter that is currently active on the body. |
| 818 |
proc eachArbiter*(body: PBody; fun: TBodyArbiterIteratorFunc; |
| 819 |
data: pointer){. |
| 820 |
cdecl, importc: "cpBodyEachArbiter", dynlib: Lib.} |
| 821 |
#/ Allocate a spatial hash. |
| 822 |
proc SpaceHashAlloc*(): PSpaceHash{. |
| 823 |
cdecl, importc: "cpSpaceHashAlloc", dynlib: Lib.} |
| 824 |
#/ Initialize a spatial hash. |
| 825 |
proc SpaceHashInit*(hash: PSpaceHash; celldim: CpFloat; numcells: cint; |
| 826 |
bbfun: TSpatialIndexBBFunc; staticIndex: PSpatialIndex): PSpatialIndex{. |
| 827 |
cdecl, importc: "cpSpaceHashInit", dynlib: Lib.} |
| 828 |
#/ Allocate and initialize a spatial hash. |
| 829 |
proc SpaceHashNew*(celldim: CpFloat; cells: cint; bbfun: TSpatialIndexBBFunc; |
| 830 |
staticIndex: PSpatialIndex): PSpatialIndex{. |
| 831 |
cdecl, importc: "cpSpaceHashNew", dynlib: Lib.} |
| 832 |
#/ Change the cell dimensions and table size of the spatial hash to tune it. |
| 833 |
#/ The cell dimensions should roughly match the average size of your objects |
| 834 |
#/ and the table size should be ~10 larger than the number of objects inserted. |
| 835 |
#/ Some trial and error is required to find the optimum numbers for efficiency. |
| 836 |
proc SpaceHashResize*(hash: PSpaceHash; celldim: CpFloat; numcells: cint){. |
| 837 |
cdecl, importc: "cpSpaceHashResize", dynlib: Lib.} |
| 838 |
#MARK: AABB Tree |
| 839 |
|
| 840 |
|
| 841 |
#/ Allocate a bounding box tree. |
| 842 |
proc BBTreeAlloc*(): PBBTree{.cdecl, importc: "cpBBTreeAlloc", dynlib: Lib.} |
| 843 |
#/ Initialize a bounding box tree. |
| 844 |
proc BBTreeInit*(tree: PBBTree; bbfun: TSpatialIndexBBFunc; |
| 845 |
staticIndex: ptr TSpatialIndex): ptr TSpatialIndex{.cdecl, |
| 846 |
importc: "cpBBTreeInit", dynlib: Lib.} |
| 847 |
#/ Allocate and initialize a bounding box tree. |
| 848 |
proc BBTreeNew*(bbfun: TSpatialIndexBBFunc; staticIndex: PSpatialIndex): PSpatialIndex{. |
| 849 |
cdecl, importc: "cpBBTreeNew", dynlib: Lib.} |
| 850 |
#/ Perform a static top down optimization of the tree. |
| 851 |
proc BBTreeOptimize*(index: PSpatialIndex){. |
| 852 |
cdecl, importc: "cpBBTreeOptimize", dynlib: Lib.} |
| 853 |
#/ Set the velocity function for the bounding box tree to enable temporal coherence. |
| 854 |
|
| 855 |
proc BBTreeSetVelocityFunc*(index: PSpatialIndex; fun: TBBTreeVelocityFunc){. |
| 856 |
cdecl, importc: "cpBBTreeSetVelocityFunc", dynlib: Lib.} |
| 857 |
#MARK: Single Axis Sweep |
| 858 |
|
| 859 |
|
| 860 |
#/ Allocate a 1D sort and sweep broadphase. |
| 861 |
|
| 862 |
proc Sweep1DAlloc*(): ptr TSweep1D{.cdecl, importc: "cpSweep1DAlloc", |
| 863 |
dynlib: Lib.} |
| 864 |
#/ Initialize a 1D sort and sweep broadphase. |
| 865 |
|
| 866 |
proc Sweep1DInit*(sweep: ptr TSweep1D; bbfun: TSpatialIndexBBFunc; |
| 867 |
staticIndex: ptr TSpatialIndex): ptr TSpatialIndex{.cdecl, |
| 868 |
importc: "cpSweep1DInit", dynlib: Lib.} |
| 869 |
#/ Allocate and initialize a 1D sort and sweep broadphase. |
| 870 |
|
| 871 |
proc Sweep1DNew*(bbfun: TSpatialIndexBBFunc; staticIndex: ptr TSpatialIndex): ptr TSpatialIndex{. |
| 872 |
cdecl, importc: "cpSweep1DNew", dynlib: Lib.} |
| 873 |
|
| 874 |
|
| 875 |
|
| 876 |
defProp(PArbiter, CpFloat, e, Elasticity) |
| 877 |
defProp(PArbiter, CpFloat, u, Friction) |
| 878 |
defProp(PArbiter, TVector, surface_vr, SurfaceVelocity) |
| 879 |
|
| 880 |
#/ Calculate the total impulse that was applied by this |
| 881 |
#/ This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback. |
| 882 |
proc totalImpulse*(obj: PArbiter): TVector {.cdecl, importc: "cpArbiterTotalImpulse", dynlib: Lib.} |
| 883 |
|
| 884 |
#/ Calculate the total impulse including the friction that was applied by this arbiter. |
| 885 |
#/ This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback. |
| 886 |
proc totalImpulseWithFriction*(obj: PArbiter): TVector {.cdecl, importc: "cpArbiterTotalImpulseWithFriction", dynlib: Lib.} |
| 887 |
|
| 888 |
#/ Calculate the amount of energy lost in a collision including static, but not dynamic friction. |
| 889 |
#/ This function should only be called from a post-solve, post-step or cpBodyEachArbiter callback. |
| 890 |
proc totalKE*(obj: PArbiter): CpFloat {.cdecl, importc: "cpArbiterTotalKE", dynlib: Lib.} |
| 891 |
|
| 892 |
|
| 893 |
#/ Causes a collision pair to be ignored as if you returned false from a begin callback. |
| 894 |
#/ If called from a pre-step callback, you will still need to return false |
| 895 |
#/ if you want it to be ignored in the current step. |
| 896 |
proc ignore*(arb: PArbiter) {.cdecl, importc: "cpArbiterIgnore", dynlib: Lib.} |
| 897 |
|
| 898 |
#/ Return the colliding shapes involved for this arbiter. |
| 899 |
#/ The order of their cpSpace.collision_type values will match |
| 900 |
#/ the order set when the collision handler was registered. |
| 901 |
proc getShapes*(arb: PArbiter, a, b: var PShape) {.inline.} = |
| 902 |
if arb.swappedColl.bool: |
| 903 |
a = arb.b |
| 904 |
b = arb.a |
| 905 |
else: |
| 906 |
a = arb.a |
| 907 |
b = arb.b |
| 908 |
|
| 909 |
#/ A macro shortcut for defining and retrieving the shapes from an arbiter. |
| 910 |
#define CP_ARBITER_GET_SHAPES(arb, a, b) cpShape *a, *b; cpArbiterGetShapes(arb, &a, &b); |
| 911 |
template getShapes*(arb: PArbiter, name1, name2: untyped) = |
| 912 |
var name1, name2: PShape |
| 913 |
getShapes(arb, name1, name2) |
| 914 |
|
| 915 |
|
| 916 |
#/ Return the colliding bodies involved for this arbiter. |
| 917 |
#/ The order of the cpSpace.collision_type the bodies are associated with values will match |
| 918 |
#/ the order set when the collision handler was registered. |
| 919 |
#proc getBodies*(arb: PArbiter, a, b: var PBody) {.inline.} = |
| 920 |
# getShapes(arb, shape1, shape2) |
| 921 |
# a = shape1.body |
| 922 |
# b = shape2.body |
| 923 |
|
| 924 |
#/ A macro shortcut for defining and retrieving the bodies from an arbiter. |
| 925 |
#define CP_ARBITER_GET_BODIES(arb, a, b) cpBody *a, *b; cpArbiterGetBodies(arb, &a, &b); |
| 926 |
template getBodies*(arb: PArbiter, name1, name2: untyped) = |
| 927 |
var name1, name2: PBOdy |
| 928 |
getBodies(arb, name1, name2) |
| 929 |
|
| 930 |
proc isFirstContact*(arb: PArbiter): bool {.inline.} = |
| 931 |
result = arb.state == ArbiterStateFirstColl |
| 932 |
|
| 933 |
proc getCount*(arb: PArbiter): cint {.inline.} = |
| 934 |
result = arb.numContacts |
| 935 |
|
| 936 |
#/ Return a contact set from an arbiter. |
| 937 |
proc getContactPointSet*(arb: PArbiter): TContactPointSet {. |
| 938 |
cdecl, importc: "cpArbiterGetContactPointSet", dynlib: Lib.} |
| 939 |
#/ Get the normal of the @c ith contact point. |
| 940 |
proc getNormal*(arb: PArbiter; i: cint): TVector {. |
| 941 |
cdecl, importc: "cpArbiterGetNormal", dynlib: Lib.} |
| 942 |
#/ Get the position of the @c ith contact point. |
| 943 |
proc getPoint*(arb: PArbiter; i: cint): TVector {. |
| 944 |
cdecl, importc: "cpArbiterGetPoint", dynlib: Lib.} |
| 945 |
#/ Get the depth of the @c ith contact point. |
| 946 |
proc getDepth*(arb: PArbiter; i: cint): CpFloat {. |
| 947 |
cdecl, importc: "cpArbiterGetDepth", dynlib: Lib.} |
| 948 |
|
| 949 |
##Shapes |
| 950 |
template defShapeSetter(memberType: typedesc, memberName: untyped, procName: untyped, activates: bool) = |
| 951 |
proc `set procName`*(obj: PShape, value: memberType) {.cdecl.} = |
| 952 |
if activates and obj.body != nil: obj.body.activate() |
| 953 |
obj.memberName = value |
| 954 |
template defShapeProp(memberType: typedesc, memberName: untyped, procName: untyped, activates: bool) = |
| 955 |
defGetter(PShape, memberType, memberName, procName) |
| 956 |
defShapeSetter(memberType, memberName, procName, activates) |
| 957 |
|
| 958 |
#/ Destroy a shape. |
| 959 |
proc destroy*(shape: PShape) {. |
| 960 |
cdecl, importc: "cpShapeDestroy", dynlib: Lib.} |
| 961 |
#/ Destroy and Free a shape. |
| 962 |
proc free*(shape: PShape){. |
| 963 |
cdecl, importc: "cpShapeFree", dynlib: Lib.} |
| 964 |
#/ Update, cache and return the bounding box of a shape based on the body it's attached to. |
| 965 |
proc cacheBB*(shape: PShape): TBB{. |
| 966 |
cdecl, importc: "cpShapeCacheBB", dynlib: Lib.} |
| 967 |
#/ Update, cache and return the bounding box of a shape with an explicit transformation. |
| 968 |
proc update*(shape: PShape; pos: TVector; rot: TVector): TBB {. |
| 969 |
cdecl, importc: "cpShapeUpdate", dynlib: Lib.} |
| 970 |
#/ Test if a point lies within a shape. |
| 971 |
proc pointQuery*(shape: PShape; p: TVector): Bool32 {. |
| 972 |
cdecl, importc: "cpShapePointQuery", dynlib: Lib.} |
| 973 |
|
| 974 |
#/ Perform a nearest point query. It finds the closest point on the surface of shape to a specific point. |
| 975 |
#/ The value returned is the distance between the points. A negative distance means the point is inside the shape. |
| 976 |
proc nearestPointQuery*(shape: PShape; p: TVector; res: PNearestPointQueryInfo): CpFloat {. |
| 977 |
cdecl, importc: "cpShapeNearestPointQuery", dynlib: Lib.} |
| 978 |
#/ Perform a segment query against a shape. @c info must be a pointer to a valid cpSegmentQueryInfo structure. |
| 979 |
proc segmentQuery*(shape: PShape, a, b: TVector, info: PSegmentQueryInfo): bool {. |
| 980 |
cdecl, importc: "cpShapeSegmentQuery", dynlib: Lib.} |
| 981 |
|
| 982 |
#/ Get the hit point for a segment query. |
| 983 |
## Possibly change; info to PSegmentQueryInfo |
| 984 |
proc queryHitPoint*(start, to: TVector, info: TSegmentQueryInfo): TVector {.inline.} = |
| 985 |
result = start.lerp(to, info.t) |
| 986 |
|
| 987 |
#/ Get the hit distance for a segment query. |
| 988 |
proc queryHitDist*(start, to: TVector, info: TSegmentQueryInfo): CpFloat {.inline.} = |
| 989 |
result = start.dist(to) * info.t |
| 990 |
|
| 991 |
defGetter(PShape, PSpace, space, Space) |
| 992 |
|
| 993 |
defGetter(PShape, PBody, body, Body) |
| 994 |
proc setBody*(shape: PShape, value: PBody) {. |
| 995 |
cdecl, importc: "cpShapeSetBody", dynlib: Lib.} |
| 996 |
|
| 997 |
|
| 998 |
defGetter(PShape, TBB, bb, BB) |
| 999 |
defShapeProp(Bool32, sensor, Sensor, true) |
| 1000 |
defShapeProp(CpFloat, e, Elasticity, false) |
| 1001 |
defShapeProp(CpFloat, u, Friction, true) |
| 1002 |
defShapeProp(TVector, surface_v, SurfaceVelocity, true) |
| 1003 |
defShapeProp(pointer, data, UserData, false) |
| 1004 |
defShapeProp(TCollisionType, collision_type, CollisionType, true) |
| 1005 |
defShapeProp(TGroup, group, Group, true) |
| 1006 |
defShapeProp(TLayers, layers, Layers, true) |
| 1007 |
|
| 1008 |
#/ When initializing a shape, it's hash value comes from a counter. |
| 1009 |
#/ Because the hash value may affect iteration order, you can reset the shape ID counter |
| 1010 |
#/ when recreating a space. This will make the simulation be deterministic. |
| 1011 |
proc resetShapeIdCounter*(): void {.cdecl, importc: "cpResetShapeIdCounter", dynlib: Lib.} |
| 1012 |
#/ Allocate a circle shape. |
| 1013 |
proc CircleShapeAlloc*(): PCircleShape {.cdecl, importc: "cpCircleShapeAlloc", dynlib: Lib.} |
| 1014 |
#/ Initialize a circle shape. |
| 1015 |
proc init*(circle: PCircleShape, body: PBody, radius: CpFloat, offset: TVector): PCircleShape {. |
| 1016 |
cdecl, importc: "cpCircleShapeInit", dynlib: Lib.} |
| 1017 |
#/ Allocate and initialize a circle shape. |
| 1018 |
proc newCircleShape*(body: PBody, radius: CpFloat, offset: TVector): PShape {. |
| 1019 |
cdecl, importc: "cpCircleShapeNew", dynlib: Lib.} |
| 1020 |
|
| 1021 |
proc getCircleOffset*(shape: PShape): TVector {. |
| 1022 |
cdecl, importc: "cpCircleShapeGetOffset", dynlib: Lib.} |
| 1023 |
proc getCircleRadius*(shape: PShape): CpFloat {. |
| 1024 |
cdecl, importc: "cpCircleShapeGetRadius", dynlib: Lib.} |
| 1025 |
|
| 1026 |
|
| 1027 |
#/ Allocate a polygon shape. |
| 1028 |
proc allocPolyShape*(): PPolyShape {. |
| 1029 |
cdecl, importc: "cpPolyShapeAlloc", dynlib: Lib.} |
| 1030 |
#/ Initialize a polygon shape. |
| 1031 |
#/ A convex hull will be created from the vertices. |
| 1032 |
proc init*(poly: PPolyShape; body: PBody, numVerts: cint; |
| 1033 |
verts: ptr TVector; offset: TVector): PPolyShape {. |
| 1034 |
cdecl, importc: "cpPolyShapeInit", dynlib: Lib.} |
| 1035 |
#/ Allocate and initialize a polygon shape. |
| 1036 |
#/ A convex hull will be created from the vertices. |
| 1037 |
proc newPolyShape*(body: PBody; numVerts: cint; verts: ptr TVector; |
| 1038 |
offset: TVector): PShape {. |
| 1039 |
cdecl, importc: "cpPolyShapeNew", dynlib: Lib.} |
| 1040 |
#/ Initialize a box shaped polygon shape. |
| 1041 |
proc init*(poly: PPolyShape; body: PBody; width, height: CpFloat): PPolyShape {. |
| 1042 |
cdecl, importc: "cpBoxShapeInit", dynlib: Lib.} |
| 1043 |
#/ Initialize an offset box shaped polygon shape. |
| 1044 |
proc init*(poly: PPolyShape; body: PBody; box: TBB): PPolyShape {. |
| 1045 |
cdecl, importc: "cpBoxShapeInit2", dynlib: Lib.} |
| 1046 |
#/ Allocate and initialize a box shaped polygon shape. |
| 1047 |
proc newBoxShape*(body: PBody; width, height: CpFloat): PShape {. |
| 1048 |
cdecl, importc: "cpBoxShapeNew", dynlib: Lib.} |
| 1049 |
#/ Allocate and initialize an offset box shaped polygon shape. |
| 1050 |
proc newBoxShape*(body: PBody; box: TBB): PShape {. |
| 1051 |
cdecl, importc: "cpBoxShapeNew2", dynlib: Lib.} |
| 1052 |
|
| 1053 |
#/ Check that a set of vertices is convex and has a clockwise winding. |
| 1054 |
#/ NOTE: Due to floating point precision issues, hulls created with cpQuickHull() are not guaranteed to validate! |
| 1055 |
proc validatePoly*(verts: ptr TVector; numVerts: cint): bool {. |
| 1056 |
cdecl, importc: "cpPolyValidate", dynlib: Lib.} |
| 1057 |
#/ Get the number of verts in a polygon shape. |
| 1058 |
proc getNumVerts*(shape: PShape): cint {. |
| 1059 |
cdecl, importc: "cpPolyShapeGetNumVerts", dynlib: Lib.} |
| 1060 |
#/ Get the @c ith vertex of a polygon shape. |
| 1061 |
proc getVert*(shape: PShape; index: cint): TVector {. |
| 1062 |
cdecl, importc: "cpPolyShapeGetVert", dynlib: Lib.} |
| 1063 |
|
| 1064 |
#/ Allocate a segment shape. |
| 1065 |
proc allocSegmentShape*(): PSegmentShape {. |
| 1066 |
cdecl, importc: "cpSegmentShapeAlloc", dynlib: Lib.} |
| 1067 |
#/ Initialize a segment shape. |
| 1068 |
proc init*(seg: PSegmentShape, body: PBody, a, b: TVector, radius: CpFloat): PSegmentShape {. |
| 1069 |
cdecl, importc: "cpSegmentShapeInit", dynlib: Lib.} |
| 1070 |
#/ Allocate and initialize a segment shape. |
| 1071 |
proc newSegmentShape*(body: PBody, a, b: TVector, radius: CpFloat): PShape {. |
| 1072 |
cdecl, importc: "cpSegmentShapeNew", dynlib: Lib.} |
| 1073 |
|
| 1074 |
proc setSegmentNeighbors*(shape: PShape, prev, next: TVector) {. |
| 1075 |
cdecl, importc: "cpSegmentShapeSetNeighbors", dynlib: Lib.} |
| 1076 |
proc getSegmentA*(shape: PShape): TVector {. |
| 1077 |
cdecl, importc: "cpSegmentShapeGetA", dynlib: Lib.} |
| 1078 |
proc getSegmentB*(shape: PShape): TVector {. |
| 1079 |
cdecl, importc: "cpSegmentShapeGetB", dynlib: Lib.} |
| 1080 |
proc getSegmentNormal*(shape: PShape): TVector {. |
| 1081 |
cdecl, importc: "cpSegmentShapeGetNormal", dynlib: Lib.} |
| 1082 |
proc getSegmentRadius*(shape: PShape): CpFloat {. |
| 1083 |
cdecl, importc: "cpSegmentShapeGetRadius", dynlib: Lib.} |
| 1084 |
|
| 1085 |
|
| 1086 |
#/ Version string. |
| 1087 |
#var VersionString*{.importc: "cpVersionString", dynlib: Lib.}: cstring |
| 1088 |
#/ Calculate the moment of inertia for a circle. |
| 1089 |
#/ @c r1 and @c r2 are the inner and outer diameters. A solid circle has an inner diameter of 0. |
| 1090 |
when defined(MoreNim): |
| 1091 |
proc momentForCircle*(m, r1, r2: CpFloat; offset: TVector): CpFloat {.cdecl.} = |
| 1092 |
result = m * (0.5 * (r1 * r1 + r2 * r2) + lenSq(offset)) |
| 1093 |
else: |
| 1094 |
proc momentForCircle*(m, r1, r2: CpFloat; offset: TVector): CpFloat {. |
| 1095 |
cdecl, importc: "cpMomentForCircle", dynlib: Lib.} |
| 1096 |
|
| 1097 |
#/ Calculate area of a hollow circle. |
| 1098 |
#/ @c r1 and @c r2 are the inner and outer diameters. A solid circle has an inner diameter of 0. |
| 1099 |
proc AreaForCircle*(r1: CpFloat; r2: CpFloat): CpFloat {. |
| 1100 |
cdecl, importc: "cpAreaForCircle", dynlib: Lib.} |
| 1101 |
#/ Calculate the moment of inertia for a line segment. |
| 1102 |
#/ Beveling radius is not supported. |
| 1103 |
proc MomentForSegment*(m: CpFloat; a, b: TVector): CpFloat {. |
| 1104 |
cdecl, importc: "cpMomentForSegment", dynlib: Lib.} |
| 1105 |
#/ Calculate the area of a fattened (capsule shaped) line segment. |
| 1106 |
proc AreaForSegment*(a, b: TVector; r: CpFloat): CpFloat {. |
| 1107 |
cdecl, importc: "cpAreaForSegment", dynlib: Lib.} |
| 1108 |
#/ Calculate the moment of inertia for a solid polygon shape assuming it's center of gravity is at it's centroid. The offset is added to each vertex. |
| 1109 |
proc MomentForPoly*(m: CpFloat; numVerts: cint; verts: ptr TVector; offset: TVector): CpFloat {. |
| 1110 |
cdecl, importc: "cpMomentForPoly", dynlib: Lib.} |
| 1111 |
#/ Calculate the signed area of a polygon. A Clockwise winding gives positive area. |
| 1112 |
#/ This is probably backwards from what you expect, but matches Chipmunk's the winding for poly shapes. |
| 1113 |
proc AreaForPoly*(numVerts: cint; verts: ptr TVector): CpFloat {. |
| 1114 |
cdecl, importc: "cpAreaForPoly", dynlib: Lib.} |
| 1115 |
#/ Calculate the natural centroid of a polygon. |
| 1116 |
proc CentroidForPoly*(numVerts: cint; verts: ptr TVector): TVector {. |
| 1117 |
cdecl, importc: "cpCentroidForPoly", dynlib: Lib.} |
| 1118 |
#/ Center the polygon on the origin. (Subtracts the centroid of the polygon from each vertex) |
| 1119 |
proc RecenterPoly*(numVerts: cint; verts: ptr TVector) {. |
| 1120 |
cdecl, importc: "cpRecenterPoly", dynlib: Lib.} |
| 1121 |
#/ Calculate the moment of inertia for a solid box. |
| 1122 |
proc MomentForBox*(m, width, height: CpFloat): CpFloat {. |
| 1123 |
cdecl, importc: "cpMomentForBox", dynlib: Lib.} |
| 1124 |
#/ Calculate the moment of inertia for a solid box. |
| 1125 |
proc MomentForBox2*(m: CpFloat; box: TBB): CpFloat {. |
| 1126 |
cdecl, importc: "cpMomentForBox2", dynlib: Lib.} |
| 1127 |
|
| 1128 |
|
| 1129 |
|
| 1130 |
##constraints |
| 1131 |
type |
| 1132 |
#TODO: all these are private |
| 1133 |
#TODO: defConstraintProp() |
| 1134 |
PPinJoint = ptr TPinJoint |
| 1135 |
TPinJoint{.pf.} = object |
| 1136 |
constraint: PConstraint |
| 1137 |
anchr1: TVector |
| 1138 |
anchr2: TVector |
| 1139 |
dist: CpFloat |
| 1140 |
r1: TVector |
| 1141 |
r2: TVector |
| 1142 |
n: TVector |
| 1143 |
nMass: CpFloat |
| 1144 |
jnAcc: CpFloat |
| 1145 |
jnMax: CpFloat |
| 1146 |
bias: CpFloat |
| 1147 |
PSlideJoint = ptr TSlideJoint |
| 1148 |
TSlideJoint{.pf.} = object |
| 1149 |
constraint: PConstraint |
| 1150 |
anchr1: TVector |
| 1151 |
anchr2: TVector |
| 1152 |
min: CpFloat |
| 1153 |
max: CpFloat |
| 1154 |
r1: TVector |
| 1155 |
r2: TVector |
| 1156 |
n: TVector |
| 1157 |
nMass: CpFloat |
| 1158 |
jnAcc: CpFloat |
| 1159 |
jnMax: CpFloat |
| 1160 |
bias: CpFloat |
| 1161 |
PPivotJoint = ptr TPivotJoint |
| 1162 |
TPivotJoint{.pf.} = object |
| 1163 |
constraint: PConstraint |
| 1164 |
anchr1: TVector |
| 1165 |
anchr2: TVector |
| 1166 |
r1: TVector |
| 1167 |
r2: TVector |
| 1168 |
k1: TVector |
| 1169 |
k2: TVector |
| 1170 |
jAcc: TVector |
| 1171 |
jMaxLen: CpFloat |
| 1172 |
bias: TVector |
| 1173 |
PGrooveJoint = ptr TGrooveJoint |
| 1174 |
TGrooveJoint{.pf.} = object |
| 1175 |
constraint: PConstraint |
| 1176 |
grv_n: TVector |
| 1177 |
grv_a: TVector |
| 1178 |
grv_b: TVector |
| 1179 |
anchr2: TVector |
| 1180 |
grv_tn: TVector |
| 1181 |
clamp: CpFloat |
| 1182 |
r1: TVector |
| 1183 |
r2: TVector |
| 1184 |
k1: TVector |
| 1185 |
k2: TVector |
| 1186 |
jAcc: TVector |
| 1187 |
jMaxLen: CpFloat |
| 1188 |
bias: TVector |
| 1189 |
PDampedSpring = ptr TDampedSpring |
| 1190 |
TDampedSpring{.pf.} = object |
| 1191 |
constraint: PConstraint |
| 1192 |
anchr1: TVector |
| 1193 |
anchr2: TVector |
| 1194 |
restLength: CpFloat |
| 1195 |
stiffness: CpFloat |
| 1196 |
damping: CpFloat |
| 1197 |
springForceFunc: TDampedSpringForceFunc |
| 1198 |
target_vrn: CpFloat |
| 1199 |
v_coef: CpFloat |
| 1200 |
r1: TVector |
| 1201 |
r2: TVector |
| 1202 |
nMass: CpFloat |
| 1203 |
n: TVector |
| 1204 |
PDampedRotarySpring = ptr TDampedRotarySpring |
| 1205 |
TDampedRotarySpring{.pf.} = object |
| 1206 |
constraint: PConstraint |
| 1207 |
restAngle: CpFloat |
| 1208 |
stiffness: CpFloat |
| 1209 |
damping: CpFloat |
| 1210 |
springTorqueFunc: TDampedRotarySpringTorqueFunc |
| 1211 |
target_wrn: CpFloat |
| 1212 |
w_coef: CpFloat |
| 1213 |
iSum: CpFloat |
| 1214 |
PRotaryLimitJoint = ptr TRotaryLimitJoint |
| 1215 |
TRotaryLimitJoint{.pf.} = object |
| 1216 |
constraint: PConstraint |
| 1217 |
min: CpFloat |
| 1218 |
max: CpFloat |
| 1219 |
iSum: CpFloat |
| 1220 |
bias: CpFloat |
| 1221 |
jAcc: CpFloat |
| 1222 |
jMax: CpFloat |
| 1223 |
PRatchetJoint = ptr TRatchetJoint |
| 1224 |
TRatchetJoint{.pf.} = object |
| 1225 |
constraint: PConstraint |
| 1226 |
angle: CpFloat |
| 1227 |
phase: CpFloat |
| 1228 |
ratchet: CpFloat |
| 1229 |
iSum: CpFloat |
| 1230 |
bias: CpFloat |
| 1231 |
jAcc: CpFloat |
| 1232 |
jMax: CpFloat |
| 1233 |
PGearJoint = ptr TGearJoint |
| 1234 |
TGearJoint{.pf.} = object |
| 1235 |
constraint: PConstraint |
| 1236 |
phase: CpFloat |
| 1237 |
ratio: CpFloat |
| 1238 |
ratio_inv: CpFloat |
| 1239 |
iSum: CpFloat |
| 1240 |
bias: CpFloat |
| 1241 |
jAcc: CpFloat |
| 1242 |
jMax: CpFloat |
| 1243 |
PSimpleMotor = ptr TSimpleMotor |
| 1244 |
TSimpleMotor{.pf.} = object |
| 1245 |
constraint: PConstraint |
| 1246 |
rate: CpFloat |
| 1247 |
iSum: CpFloat |
| 1248 |
jAcc: CpFloat |
| 1249 |
jMax: CpFloat |
| 1250 |
TDampedSpringForceFunc* = proc (spring: PConstraint; dist: CpFloat): CpFloat{. |
| 1251 |
cdecl.} |
| 1252 |
TDampedRotarySpringTorqueFunc* = proc (spring: PConstraint; |
| 1253 |
relativeAngle: CpFloat): CpFloat {.cdecl.} |
| 1254 |
#/ Destroy a constraint. |
| 1255 |
proc destroy*(constraint: PConstraint){. |
| 1256 |
cdecl, importc: "cpConstraintDestroy", dynlib: Lib.} |
| 1257 |
#/ Destroy and free a constraint.111 |
| 1258 |
proc free*(constraint: PConstraint){. |
| 1259 |
cdecl, importc: "cpConstraintFree", dynlib: Lib.} |
| 1260 |
|
| 1261 |
#/ @private |
| 1262 |
proc activateBodies(constraint: PConstraint) {.inline.} = |
| 1263 |
if not constraint.a.isNil: constraint.a.activate() |
| 1264 |
if not constraint.b.isNil: constraint.b.activate() |
| 1265 |
|
| 1266 |
# /// @private |
| 1267 |
# #define CP_DefineConstraintStructGetter(type, member, name) \ |
| 1268 |
# static inline type cpConstraint##Get##name(const cpConstraint *constraint){return constraint->member;} |
| 1269 |
# /// @private |
| 1270 |
# #define CP_DefineConstraintStructSetter(type, member, name) \ |
| 1271 |
# static inline void cpConstraint##Set##name(cpConstraint *constraint, type value){ \ |
| 1272 |
# cpConstraintActivateBodies(constraint); \ |
| 1273 |
# constraint->member = value; \ |
| 1274 |
# } |
| 1275 |
template defConstraintSetter(memberType: typedesc, member, name: untyped) = |
| 1276 |
proc `set name`*(constraint: PConstraint, value: memberType) {.cdecl.} = |
| 1277 |
activateBodies(constraint) |
| 1278 |
constraint.member = value |
| 1279 |
template defConstraintProp(memberType: typedesc, member, name: untyped) = |
| 1280 |
defGetter(PConstraint, memberType, member, name) |
| 1281 |
defConstraintSetter(memberType, member, name) |
| 1282 |
# CP_DefineConstraintStructGetter(cpSpace*, CP_PRIVATE(space), Space) |
| 1283 |
defGetter(PConstraint, PSpace, space, Space) |
| 1284 |
defGetter(PConstraint, PBody, a, A) |
| 1285 |
defGetter(PConstraint, PBody, a, B) |
| 1286 |
defGetter(PConstraint, CpFloat, maxForce, MaxForce) |
| 1287 |
defGetter(PConstraint, CpFloat, errorBias, ErrorBias) |
| 1288 |
defGetter(PConstraint, CpFloat, maxBias, MaxBias) |
| 1289 |
defGetter(PConstraint, TConstraintPreSolveFunc, preSolve, PreSolveFunc) |
| 1290 |
defGetter(PConstraint, TConstraintPostSolveFunc, postSolve, PostSolveFunc) |
| 1291 |
defGetter(PConstraint, CpDataPointer, data, UserData) |
| 1292 |
# Get the last impulse applied by this constraint. |
| 1293 |
proc getImpulse*(constraint: PConstraint): CpFloat {.inline.} = |
| 1294 |
return constraint.klass.getImpulse(constraint) |
| 1295 |
|
| 1296 |
# #define cpConstraintCheckCast(constraint, struct) \ |
| 1297 |
# cpAssertHard(constraint->CP_PRIVATE(klass) == struct##GetClass(), "Constraint is not a "#struct) |
| 1298 |
# #define CP_DefineConstraintGetter(struct, type, member, name) \ |
| 1299 |
# static inline type struct##Get##name(const cpConstraint *constraint){ \ |
| 1300 |
# cpConstraintCheckCast(constraint, struct); \ |
| 1301 |
# return ((struct *)constraint)->member; \ |
| 1302 |
# } |
| 1303 |
# #define CP_DefineConstraintSetter(struct, type, member, name) \ |
| 1304 |
# static inline void struct##Set##name(cpConstraint *constraint, type value){ \ |
| 1305 |
# cpConstraintCheckCast(constraint, struct); \ |
| 1306 |
# cpConstraintActivateBodies(constraint); \ |
| 1307 |
# ((struct *)constraint)->member = value; \ |
| 1308 |
# } |
| 1309 |
template constraintCheckCast(constraint: PConstraint, ctype: untyped) = |
| 1310 |
assert(constraint.klass == `ctype getClass`(), "Constraint is the wrong class") |
| 1311 |
template defCGetter(ctype: untyped, memberType: typedesc, member, name: untyped) = |
| 1312 |
proc `get ctype name`*(constraint: PConstraint): memberType {.cdecl.} = |
| 1313 |
constraintCheckCast(constraint, ctype) |
| 1314 |
result = cast[`P ctype`](constraint).member |
| 1315 |
template defCSetter(ctype: untyped, memberType: typedesc, member, name: untyped) = |
| 1316 |
proc `set ctype name`*(constraint: PConstraint, value: memberType) {.cdecl.} = |
| 1317 |
constraintCheckCast(constraint, ctype) |
| 1318 |
activateBodies(constraint) |
| 1319 |
cast[`P ctype`](constraint).member = value |
| 1320 |
template defCProp(ctype: untyped, memberType: typedesc, member, name: untyped) = |
| 1321 |
defCGetter(ctype, memberType, member, name) |
| 1322 |
defCSetter(ctype, memberType, member, name) |
| 1323 |
|
| 1324 |
proc PinJointGetClass*(): PConstraintClass{. |
| 1325 |
cdecl, importc: "cpPinJointGetClass", dynlib: Lib.} |
| 1326 |
#/ @private |
| 1327 |
|
| 1328 |
#/ Allocate a pin joint. |
| 1329 |
proc AllocPinJoint*(): PPinJoint{. |
| 1330 |
cdecl, importc: "cpPinJointAlloc", dynlib: Lib.} |
| 1331 |
#/ Initialize a pin joint. |
| 1332 |
proc PinJointInit*(joint: PPinJoint; a: PBody; b: PBody; anchr1: TVector; |
| 1333 |
anchr2: TVector): PPinJoint{. |
| 1334 |
cdecl, importc: "cpPinJointInit", dynlib: Lib.} |
| 1335 |
#/ Allocate and initialize a pin joint. |
| 1336 |
proc newPinJoint*(a: PBody; b: PBody; anchr1: TVector; anchr2: TVector): PConstraint{. |
| 1337 |
cdecl, importc: "cpPinJointNew", dynlib: Lib.} |
| 1338 |
# CP_DefineConstraintProperty(cpPinJoint, cpVect, anchr1, Anchr1) |
| 1339 |
defCProp(PinJoint, TVector, anchr1, Anchr1) |
| 1340 |
defCProp(PinJoint, TVector, anchr2, Anchr2) |
| 1341 |
defCProp(PinJoint, CpFloat, dist, Dist) |
| 1342 |
|
| 1343 |
proc SlideJointGetClass*(): PConstraintClass{. |
| 1344 |
cdecl, importc: "cpSlideJointGetClass", dynlib: Lib.} |
| 1345 |
#/ Allocate a slide joint. |
| 1346 |
proc AllocSlideJoint*(): PSlideJoint{. |
| 1347 |
cdecl, importc: "cpSlideJointAlloc", dynlib: Lib.} |
| 1348 |
#/ Initialize a slide joint. |
| 1349 |
proc init*(joint: PSlideJoint; a, b: PBody; anchr1, anchr2: TVector; |
| 1350 |
min, max: CpFloat): PSlideJoint{. |
| 1351 |
cdecl, importc: "cpSlideJointInit", dynlib: Lib.} |
| 1352 |
#/ Allocate and initialize a slide joint. |
| 1353 |
proc newSlideJoint*(a, b: PBody; anchr1, anchr2: TVector; min, max: CpFloat): PConstraint{. |
| 1354 |
cdecl, importc: "cpSlideJointNew", dynlib: Lib.} |
| 1355 |
|
| 1356 |
defCProp(SlideJoint, TVector, anchr1, Anchr1) |
| 1357 |
defCProp(SlideJoint, TVector, anchr2, Anchr2) |
| 1358 |
defCProp(SlideJoint, CpFloat, min, Min) |
| 1359 |
defCProp(SlideJoint, CpFloat, max, Max) |
| 1360 |
|
| 1361 |
proc PivotJointGetClass*(): PConstraintClass {. |
| 1362 |
cdecl, importc: "cpPivotJointGetClass", dynlib: Lib.} |
| 1363 |
|
| 1364 |
#/ Allocate a pivot joint |
| 1365 |
proc allocPivotJoint*(): PPivotJoint{. |
| 1366 |
cdecl, importc: "cpPivotJointAlloc", dynlib: Lib.} |
| 1367 |
#/ Initialize a pivot joint. |
| 1368 |
proc init*(joint: PPivotJoint; a, b: PBody; anchr1, anchr2: TVector): PPivotJoint{. |
| 1369 |
cdecl, importc: "cpPivotJointInit", dynlib: Lib.} |
| 1370 |
#/ Allocate and initialize a pivot joint. |
| 1371 |
proc newPivotJoint*(a, b: PBody; pivot: TVector): PConstraint{. |
| 1372 |
cdecl, importc: "cpPivotJointNew", dynlib: Lib.} |
| 1373 |
#/ Allocate and initialize a pivot joint with specific anchors. |
| 1374 |
proc newPivotJoint*(a, b: PBody; anchr1, anchr2: TVector): PConstraint{. |
| 1375 |
cdecl, importc: "cpPivotJointNew2", dynlib: Lib.} |
| 1376 |
|
| 1377 |
defCProp(PivotJoint, TVector, anchr1, Anchr1) |
| 1378 |
defCProp(PivotJoint, TVector, anchr2, Anchr2) |
| 1379 |
|
| 1380 |
|
| 1381 |
proc GrooveJointGetClass*(): PConstraintClass{. |
| 1382 |
cdecl, importc: "cpGrooveJointGetClass", dynlib: Lib.} |
| 1383 |
#/ Allocate a groove joint. |
| 1384 |
proc GrooveJointAlloc*(): ptr TGrooveJoint{. |
| 1385 |
cdecl, importc: "cpGrooveJointAlloc", dynlib: Lib.} |
| 1386 |
#/ Initialize a groove joint. |
| 1387 |
proc Init*(joint: PGrooveJoint; a, b: PBody; groove_a, groove_b, anchr2: TVector): PGrooveJoint{. |
| 1388 |
cdecl, importc: "cpGrooveJointInit", dynlib: Lib.} |
| 1389 |
#/ Allocate and initialize a groove joint. |
| 1390 |
proc newGrooveJoint*(a, b: PBody; groove_a, groove_b, anchr2: TVector): PConstraint{. |
| 1391 |
cdecl, importc: "cpGrooveJointNew", dynlib: Lib.} |
| 1392 |
|
| 1393 |
defCGetter(GrooveJoint, TVector, grv_a, GrooveA) |
| 1394 |
defCGetter(GrooveJoint, TVector, grv_b, GrooveB) |
| 1395 |
# /// Set endpoint a of a groove joint's groove |
| 1396 |
proc SetGrooveA*(constraint: PConstraint, value: TVector) {. |
| 1397 |
cdecl, importc: "cpGrooveJointSetGrooveA", dynlib: Lib.} |
| 1398 |
# /// Set endpoint b of a groove joint's groove |
| 1399 |
proc SetGrooveB*(constraint: PConstraint, value: TVector) {. |
| 1400 |
cdecl, importc: "cpGrooveJointSetGrooveB", dynlib: Lib.} |
| 1401 |
defCProp(GrooveJoint, TVector, anchr2, Anchr2) |
| 1402 |
|
| 1403 |
proc DampedSpringGetClass*(): PConstraintClass{. |
| 1404 |
cdecl, importc: "cpDampedSpringGetClass", dynlib: Lib.} |
| 1405 |
#/ Allocate a damped spring. |
| 1406 |
proc AllocDampedSpring*(): PDampedSpring{. |
| 1407 |
cdecl, importc: "cpDampedSpringAlloc", dynlib: Lib.} |
| 1408 |
#/ Initialize a damped spring. |
| 1409 |
proc init*(joint: PDampedSpring; a, b: PBody; anchr1, anchr2: TVector; |
| 1410 |
restLength, stiffness, damping: CpFloat): PDampedSpring{. |
| 1411 |
cdecl, importc: "cpDampedSpringInit", dynlib: Lib.} |
| 1412 |
#/ Allocate and initialize a damped spring. |
| 1413 |
proc newDampedSpring*(a, b: PBody; anchr1, anchr2: TVector; |
| 1414 |
restLength, stiffness, damping: CpFloat): PConstraint{. |
| 1415 |
cdecl, importc: "cpDampedSpringNew", dynlib: Lib.} |
| 1416 |
|
| 1417 |
# CP_DefineConstraintProperty(cpDampedSpring, cpVect, anchr1, Anchr1) |
| 1418 |
defCProp(DampedSpring, TVector, anchr1, Anchr1) |
| 1419 |
defCProp(DampedSpring, TVector, anchr2, Anchr2) |
| 1420 |
defCProp(DampedSpring, CpFloat, restLength, RestLength) |
| 1421 |
defCProp(DampedSpring, CpFloat, stiffness, Stiffness) |
| 1422 |
defCProp(DampedSpring, CpFloat, damping, Damping) |
| 1423 |
defCProp(DampedSpring, TDampedSpringForceFunc, springForceFunc, SpringForceFunc) |
| 1424 |
|
| 1425 |
|
| 1426 |
proc DampedRotarySpringGetClass*(): PConstraintClass{. |
| 1427 |
cdecl, importc: "cpDampedRotarySpringGetClass", dynlib: Lib.} |
| 1428 |
|
| 1429 |
#/ Allocate a damped rotary spring. |
| 1430 |
proc DampedRotarySpringAlloc*(): PDampedRotarySpring{. |
| 1431 |
cdecl, importc: "cpDampedRotarySpringAlloc", dynlib: Lib.} |
| 1432 |
#/ Initialize a damped rotary spring. |
| 1433 |
proc init*(joint: PDampedRotarySpring; a, b: PBody; |
| 1434 |
restAngle, stiffness, damping: CpFloat): PDampedRotarySpring{. |
| 1435 |
cdecl, importc: "cpDampedRotarySpringInit", dynlib: Lib.} |
| 1436 |
#/ Allocate and initialize a damped rotary spring. |
| 1437 |
proc DampedRotarySpringNew*(a, b: PBody; restAngle, stiffness, damping: CpFloat): PConstraint{. |
| 1438 |
cdecl, importc: "cpDampedRotarySpringNew", dynlib: Lib.} |
| 1439 |
|
| 1440 |
defCProp(DampedRotarySpring, CpFloat, restAngle, RestAngle) |
| 1441 |
defCProp(DampedRotarySpring, CpFloat, stiffness, Stiffness) |
| 1442 |
defCProp(DampedRotarySpring, CpFloat, damping, Damping) |
| 1443 |
defCProp(DampedRotarySpring, TDampedRotarySpringTorqueFunc, springTorqueFunc, SpringTorqueFunc) |
| 1444 |
|
| 1445 |
|
| 1446 |
proc RotaryLimitJointGetClass*(): PConstraintClass{. |
| 1447 |
cdecl, importc: "cpRotaryLimitJointGetClass", dynlib: Lib.} |
| 1448 |
#/ Allocate a damped rotary limit joint. |
| 1449 |
proc allocRotaryLimitJoint*(): PRotaryLimitJoint{. |
| 1450 |
cdecl, importc: "cpRotaryLimitJointAlloc", dynlib: Lib.} |
| 1451 |
#/ Initialize a damped rotary limit joint. |
| 1452 |
proc init*(joint: PRotaryLimitJoint; a, b: PBody; min, max: CpFloat): PRotaryLimitJoint{. |
| 1453 |
cdecl, importc: "cpRotaryLimitJointInit", dynlib: Lib.} |
| 1454 |
#/ Allocate and initialize a damped rotary limit joint. |
| 1455 |
proc newRotaryLimitJoint*(a, b: PBody; min, max: CpFloat): PConstraint{. |
| 1456 |
cdecl, importc: "cpRotaryLimitJointNew", dynlib: Lib.} |
| 1457 |
|
| 1458 |
defCProp(RotaryLimitJoint, CpFloat, min, Min) |
| 1459 |
defCProp(RotaryLimitJoint, CpFloat, max, Max) |
| 1460 |
|
| 1461 |
|
| 1462 |
proc RatchetJointGetClass*(): PConstraintClass{. |
| 1463 |
cdecl, importc: "cpRatchetJointGetClass", dynlib: Lib.} |
| 1464 |
#/ Allocate a ratchet joint. |
| 1465 |
proc AllocRatchetJoint*(): PRatchetJoint{. |
| 1466 |
cdecl, importc: "cpRatchetJointAlloc", dynlib: Lib.} |
| 1467 |
#/ Initialize a ratched joint. |
| 1468 |
proc init*(joint: PRatchetJoint; a, b: PBody; phase, ratchet: CpFloat): PRatchetJoint{. |
| 1469 |
cdecl, importc: "cpRatchetJointInit", dynlib: Lib.} |
| 1470 |
#/ Allocate and initialize a ratchet joint. |
| 1471 |
proc NewRatchetJoint*(a, b: PBody; phase, ratchet: CpFloat): PConstraint{. |
| 1472 |
cdecl, importc: "cpRatchetJointNew", dynlib: Lib.} |
| 1473 |
|
| 1474 |
defCProp(RatchetJoint, CpFloat, angle, Angle) |
| 1475 |
defCProp(RatchetJoint, CpFloat, phase, Phase) |
| 1476 |
defCProp(RatchetJoint, CpFloat, ratchet, Ratchet) |
| 1477 |
|
| 1478 |
|
| 1479 |
proc GearJointGetClass*(): PConstraintClass{.cdecl, |
| 1480 |
importc: "cpGearJointGetClass", dynlib: Lib.} |
| 1481 |
#/ Allocate a gear joint. |
| 1482 |
proc AllocGearJoint*(): PGearJoint{. |
| 1483 |
cdecl, importc: "cpGearJointAlloc", dynlib: Lib.} |
| 1484 |
#/ Initialize a gear joint. |
| 1485 |
proc init*(joint: PGearJoint; a, b: PBody, phase, ratio: CpFloat): PGearJoint{. |
| 1486 |
cdecl, importc: "cpGearJointInit", dynlib: Lib.} |
| 1487 |
#/ Allocate and initialize a gear joint. |
| 1488 |
proc NewGearJoint*(a, b: PBody; phase, ratio: CpFloat): PConstraint{. |
| 1489 |
cdecl, importc: "cpGearJointNew", dynlib: Lib.} |
| 1490 |
|
| 1491 |
defCProp(GearJoint, CpFloat, phase, Phase) |
| 1492 |
defCGetter(GearJoint, CpFloat, ratio, Ratio) |
| 1493 |
#/ Set the ratio of a gear joint. |
| 1494 |
proc GearJointSetRatio*(constraint: PConstraint; value: CpFloat){. |
| 1495 |
cdecl, importc: "cpGearJointSetRatio", dynlib: Lib.} |
| 1496 |
|
| 1497 |
|
| 1498 |
proc SimpleMotorGetClass*(): PConstraintClass{. |
| 1499 |
cdecl, importc: "cpSimpleMotorGetClass", dynlib: Lib.} |
| 1500 |
#/ Allocate a simple motor. |
| 1501 |
proc AllocSimpleMotor*(): PSimpleMotor{. |
| 1502 |
cdecl, importc: "cpSimpleMotorAlloc", dynlib: Lib.} |
| 1503 |
#/ initialize a simple motor. |
| 1504 |
proc init*(joint: PSimpleMotor; a, b: PBody; |
| 1505 |
rate: CpFloat): PSimpleMotor{. |
| 1506 |
cdecl, importc: "cpSimpleMotorInit", dynlib: Lib.} |
| 1507 |
#/ Allocate and initialize a simple motor. |
| 1508 |
proc newSimpleMotor*(a, b: PBody; rate: CpFloat): PConstraint{. |
| 1509 |
cdecl, importc: "cpSimpleMotorNew", dynlib: Lib.} |
| 1510 |
|
| 1511 |
defCProp(SimpleMotor, CpFloat, rate, Rate) |
| 1512 |
|
| 1513 |
|
| 1514 |
|