php-bullet/bullet3_bridge.h at master · phpgl/php-bullet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
#ifndef BULLET3_BRIDGE_H
#define BULLET3_BRIDGE_H

#include "glfw/linmath.h"
#include "glfw/phpglfw_buffer.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct btDynamicsWorldWrapper btDynamicsWorldWrapper;
typedef struct btRigidBodyWrapper btRigidBodyWrapper;
typedef struct btCollisionShapeWrapper btCollisionShapeWrapper;
typedef struct btTypedConstraintWrapper btTypedConstraintWrapper;
typedef struct btDebugRendererWrapper btDebugRendererWrapper;

/**
 * Physics world
 *
 * ----------------------------------------------------------------------------
 */
btDynamicsWorldWrapper *btDynamicsWorld_create();
void btDynamicsWorld_destroy(btDynamicsWorldWrapper *world);

// methods
void btDynamicsWorld_setGravity(btDynamicsWorldWrapper *world, vec3 *gravity);
void btDynamicsWorld_getGravity(btDynamicsWorldWrapper *world, vec3 *gravity);
void btDynamicsWorld_addRigidBody(btDynamicsWorldWrapper *world, btRigidBodyWrapper *body);

void btDynamicsWorld_addConstraint(btDynamicsWorldWrapper *world, btTypedConstraintWrapper *constraint, bool noclip);
void btDynamicsWorld_removeConstraint(btDynamicsWorldWrapper *world, btTypedConstraintWrapper *constraint);

void btDynamicsWorld_stepSimulation(btDynamicsWorldWrapper *world, float timeStep);

// attach debug renderer
void btDynamicsWorld_setDebugRenderer(btDynamicsWorldWrapper *world, btDebugRendererWrapper *renderer);
void btDynamicsWorld_debugDrawWorld(btDynamicsWorldWrapper *world);
void btDynamicsWorld_enableDebugDrawing(btDynamicsWorldWrapper *world);
void btDynamicsWorld_setDebugDrawVP(btDynamicsWorldWrapper *world, mat4x4 *vpMatrix);

/**
 * Collision shape
 *
 * ----------------------------------------------------------------------------
 */
void btCollisionShape_destroy(btCollisionShapeWrapper *shape);

// shpere
btCollisionShapeWrapper *btCollisionShape_create_sphere(float radius);

// box
btCollisionShapeWrapper *btCollisionShape_create_box(vec3 *halfExtents);

// cylinder
btCollisionShapeWrapper *btCollisionShape_create_cylinder(vec3 *halfExtents);
btCollisionShapeWrapper *btCollisionShape_create_cylinderX(vec3 *halfExtents);
btCollisionShapeWrapper *btCollisionShape_create_cylinderZ(vec3 *halfExtents);

// static plane
btCollisionShapeWrapper *btCollisionShape_create_static_plane(vec3 *normal, float constant);

/**
 * Contraints
 *
 * ----------------------------------------------------------------------------
 */
void btTypedConstraint_destroy(btTypedConstraintWrapper *constraint);

// -- Point to point
btTypedConstraintWrapper *btPoint2PointConstraint_create(btRigidBodyWrapper *bodyA, btRigidBodyWrapper *bodyB, vec3 *pivotA, vec3 *pivotB);

// -- Hinge
btTypedConstraintWrapper *btHingeConstraint_create(btRigidBodyWrapper *bodyA, btRigidBodyWrapper *bodyB, vec3 *pivotA, vec3 *pivotB, vec3 *axisA, vec3 *axisB);

void btHingeConstraint_setLimit(btTypedConstraintWrapper *constraint, float low, float high, float softness, float biasFactor, float relaxationFactor);

// -- Slider
btTypedConstraintWrapper *btSliderConstraint_create(btRigidBodyWrapper *bodyA, btRigidBodyWrapper *bodyB, mat4x4 *frameInA, mat4x4 *frameInB, bool useLinearReferenceFrameA);

// -- Generic6DofSpring
btTypedConstraintWrapper *btGeneric6DofSpringConstraint_create(btRigidBodyWrapper *bodyA, btRigidBodyWrapper *bodyB, mat4x4 *frameInA, mat4x4 *frameInB, bool useLinearReferenceFrameA);

// -- Generic6DofSpring2
btTypedConstraintWrapper *btGeneric6DofSpring2Constraint_create(btRigidBodyWrapper *bodyA, btRigidBodyWrapper *bodyB, mat4x4 *frameInA, mat4x4 *frameInB);

void btGeneric6DofSpring2Constraint_setFrames(btTypedConstraintWrapper *constraint, mat4x4 *frameInA, mat4x4 *frameInB);

void btGeneric6DofSpring2Constraint_setLinearLowerLimit(btTypedConstraintWrapper *constraint, const vec3 *linearLower);

void btGeneric6DofSpring2Constraint_setLinearUpperLimit(btTypedConstraintWrapper *constraint, const vec3 *linearUpper);

void btGeneric6DofSpring2Constraint_setAngularLowerLimit(btTypedConstraintWrapper *constraint, const vec3 *angularLower);
void btGeneric6DofSpring2Constraint_setAngularLowerLimitReversed(btTypedConstraintWrapper *constraint, const vec3 *angularLower);

void btGeneric6DofSpring2Constraint_setAngularUpperLimit(btTypedConstraintWrapper *constraint, const vec3 *angularUpper);
void btGeneric6DofSpring2Constraint_setAngularUpperLimitReversed(btTypedConstraintWrapper *constraint, const vec3 *angularUpper);

void btGeneric6DofSpring2Constraint_setLimit(btTypedConstraintWrapper *constraint, int axis, float lo, float hi);
void btGeneric6DofSpring2Constraint_setLimitReversed(btTypedConstraintWrapper *constraint, int axis, float lo, float hi);

void btGeneric6DofSpring2Constraint_setAxis(btTypedConstraintWrapper *constraint, vec3 *axis1, vec3 *axis2);

void btGeneric6DofSpring2Constraint_setBounce(btTypedConstraintWrapper *constraint, int index, float bounce);

void btGeneric6DofSpring2Constraint_enableMotor(btTypedConstraintWrapper *constraint, int index, bool onOff);
void btGeneric6DofSpring2Constraint_setServo(btTypedConstraintWrapper *constraint, int index, bool onOff);
void btGeneric6DofSpring2Constraint_setTargetVelocity(btTypedConstraintWrapper *constraint, int index, float velocity);
void btGeneric6DofSpring2Constraint_setServoTarget(btTypedConstraintWrapper *constraint, int index, float target);
void btGeneric6DofSpring2Constraint_setMaxMotorForce(btTypedConstraintWrapper *constraint, int index, float force);

void btGeneric6DofSpring2Constraint_enableSpring(btTypedConstraintWrapper *constraint, int index, bool onOff);
void btGeneric6DofSpring2Constraint_setStiffness(btTypedConstraintWrapper *constraint, int index, float stiffness, bool limitIfNeeded);
void btGeneric6DofSpring2Constraint_setDamping(btTypedConstraintWrapper *constraint, int index, float damping, bool limitIfNeeded);

void btGeneric6DofSpring2Constraint_setEquilibriumPoint(btTypedConstraintWrapper *constraint);

/**
 * Rigid body
 *
 * ----------------------------------------------------------------------------
 */
btRigidBodyWrapper *btRigidBody_create(btCollisionShapeWrapper* shape, float mass);
void btRigidBody_destroy(btRigidBodyWrapper *body);

// methods
void btRigidBody_setPosition(btRigidBodyWrapper *body, vec3 *position);
void btRigidBody_setQuaternion(btRigidBodyWrapper *body, quat *quaternion);
void btRigidBody_setMass(btRigidBodyWrapper *body, float mass);
void btRigidBody_setRestitution(btRigidBodyWrapper *body, float restitution);
void btRigidBody_setFriction(btRigidBodyWrapper *body, float friction);
void btRigidBody_setRollingFriction(btRigidBodyWrapper *body, float friction);
void btRigidBody_setSpinningFriction(btRigidBodyWrapper *body, float friction);
void btRigidBody_setContactStiffnessAndDamping(btRigidBodyWrapper *body, float stiffness, float damping);

void btRigidBody_getPosition(btRigidBodyWrapper *bodyWrapper, vec3 *position);
void btRigidBody_getLinearVelocity(btRigidBodyWrapper *bodyWrapper, vec3 *velocity);
void btRigidBody_getAngularVelocity(btRigidBodyWrapper *bodyWrapper, vec3 *velocity);

void btRigidBody_getQuaternion(btRigidBodyWrapper *bodyWrapper, quat *quaternion);
void btRigidBody_getOpenGLMatrix(btRigidBodyWrapper *bodyWrapper, mat4x4 *matrix);

void btRigidBody_applyForce(btRigidBodyWrapper *body, vec3 *force, vec3 *rel_pos);
void btRigidBody_applyCentralForce(btRigidBodyWrapper *body, vec3 *force);
void btRigidBody_applyTorque(btRigidBodyWrapper *body, vec3 *torque);
void btRigidBody_applyImpulse(btRigidBodyWrapper *body, vec3 *impulse, vec3 *rel_pos);
void btRigidBody_applyCentralImpulse(btRigidBodyWrapper *body, vec3 *impulse);
void btRigidBody_applyTorqueImpulse(btRigidBodyWrapper *body, vec3 *torque);

void btRigidBody_activate(btRigidBodyWrapper *body);
void btRigidBody_disableDeactivation(btRigidBodyWrapper *body);

/**
 * Debug renderer
 *
 * ----------------------------------------------------------------------------
 */
btDebugRendererWrapper *btDebugRenderer_create();
void btDebugRenderer_destroy(btDebugRendererWrapper *renderer);

// methods
void btDebugRenderer_setVP(btDebugRendererWrapper *renderer, mat4x4 *vpMatrix);


#ifdef __cplusplus
}
#endif

#endif // BULLET3_BRIDGE_H