Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

share more data structures and code between OpenCL kernels and C/C++ code on CPU (non-OpenCL)

Browse Source 
integrateSingleTransform
fix bug in registerRigidBody (could lead to random crashes, especially when performing picking/adding rigid bodies afterwards)
This commit is contained in:
erwin coumans
2013-11-07 15:49:57 -08:00
parent e20cb22832
commit e85bae5fe3
19 changed files with 270 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/Bullet3OpenCL/RigidBody/kernels/batchingKernels.h
View File

@@ -26,6 +26,9 @@ static const char* batchingKernelsCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"

3
src/Bullet3OpenCL/RigidBody/kernels/batchingKernelsNew.h
View File

@@ -26,6 +26,9 @@ static const char* batchingKernelsNewCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"

59
src/Bullet3OpenCL/RigidBody/kernels/integrateKernel.cl
View File

@@ -16,19 +16,7 @@ subject to the following restrictions:
#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h"
float4 quatMult(float4 q1, float4 q2)
{
float4 q;
q.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
q.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
q.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
q.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
return q;
}
#include "Bullet3Dynamics/shared/b3IntegrateTransforms.h"
@@ -36,48 +24,9 @@ __kernel void
integrateTransformsKernel( __global b3RigidBodyData_t* bodies,const int numNodes, float timeStep, float angularDamping, float4 gravityAcceleration)
{
int nodeID = get_global_id(0);
float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);
if( nodeID < numNodes && (bodies[nodeID].m_invMass != 0.f))
if( nodeID < numNodes)
{
//angular velocity
{
float4 axis;
//add some hardcoded angular damping
bodies[nodeID].m_angVel.x *= angularDamping;
bodies[nodeID].m_angVel.y *= angularDamping;
bodies[nodeID].m_angVel.z *= angularDamping;
float4 angvel = bodies[nodeID].m_angVel;
float fAngle = native_sqrt(dot(angvel, angvel));
//limit the angular motion
if(fAngle*timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)
{
fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;
}
if(fAngle < 0.001f)
{
// use Taylor's expansions of sync function
axis = angvel * (0.5f*timeStep-(timeStep*timeStep*timeStep)*0.020833333333f * fAngle * fAngle);
}
else
{
// sync(fAngle) = sin(c*fAngle)/t
axis = angvel * ( native_sin(0.5f * fAngle * timeStep) / fAngle);
}
float4 dorn = axis;
dorn.w = native_cos(fAngle * timeStep * 0.5f);
float4 orn0 = bodies[nodeID].m_quat;
float4 predictedOrn = quatMult(dorn, orn0);
predictedOrn = b3QuatNormalize(predictedOrn);
bodies[nodeID].m_quat=predictedOrn;
}
//linear velocity
bodies[nodeID].m_pos += bodies[nodeID].m_linVel * timeStep;
//apply gravity
bodies[nodeID].m_linVel += gravityAcceleration * timeStep;
integrateSingleTransform(bodies,nodeID, timeStep, angularDamping,gravityAcceleration);
}
}

113
src/Bullet3OpenCL/RigidBody/kernels/integrateKernel.h
View File

@@ -26,6 +26,9 @@ static const char* integrateKernelCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"
@@ -79,7 +82,7 @@ static const char* integrateKernelCL= \
"}\n"
" \n"
"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in);\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
@@ -91,8 +94,10 @@ static const char* integrateKernelCL= \
" ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
" return ans;\n"
"}\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in)\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
"{\n"
" b3Quat q;\n"
" q=in;\n"
" //return b3FastNormalize4(in);\n"
" float len = native_sqrt(dot(q, q));\n"
" if(len > 0.f)\n"
@@ -273,32 +278,26 @@ static const char* integrateKernelCL= \
"};\n"
"#endif //B3_RIGIDBODY_DATA_H\n"
" \n"
"float4 quatMult(float4 q1, float4 q2)\n"
"#ifndef B3_RIGIDBODY_DATA_H\n"
"#endif //B3_RIGIDBODY_DATA_H\n"
" \n"
"inline void integrateSingleTransform( __global b3RigidBodyData_t* bodies,int nodeID, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)\n"
"{\n"
" float4 q;\n"
" q.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;\n"
" q.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;\n"
" q.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;\n"
" q.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z; \n"
" return q;\n"
"}\n"
"__kernel void \n"
" integrateTransformsKernel( __global b3RigidBodyData_t* bodies,const int numNodes, float timeStep, float angularDamping, float4 gravityAcceleration)\n"
"{\n"
" int nodeID = get_global_id(0);\n"
" float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);\n"
" if( nodeID < numNodes && (bodies[nodeID].m_invMass != 0.f))\n"
" \n"
" if (bodies[nodeID].m_invMass != 0.f)\n"
" {\n"
" float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);\n"
" //angular velocity\n"
" {\n"
" float4 axis;\n"
" b3Float4 axis;\n"
" //add some hardcoded angular damping\n"
" bodies[nodeID].m_angVel.x *= angularDamping;\n"
" bodies[nodeID].m_angVel.y *= angularDamping;\n"
" bodies[nodeID].m_angVel.z *= angularDamping;\n"
" \n"
" float4 angvel = bodies[nodeID].m_angVel;\n"
" float fAngle = native_sqrt(dot(angvel, angvel));\n"
" b3Float4 angvel = bodies[nodeID].m_angVel;\n"
" float fAngle = b3Sqrt(b3Dot3F4(angvel, angvel));\n"
" \n"
" //limit the angular motion\n"
" if(fAngle*timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)\n"
" {\n"
@@ -312,13 +311,17 @@ static const char* integrateKernelCL= \
" else\n"
" {\n"
" // sync(fAngle) = sin(c*fAngle)/t\n"
" axis = angvel * ( native_sin(0.5f * fAngle * timeStep) / fAngle);\n"
" axis = angvel * ( b3Sin(0.5f * fAngle * timeStep) / fAngle);\n"
" }\n"
" float4 dorn = axis;\n"
" dorn.w = native_cos(fAngle * timeStep * 0.5f);\n"
" float4 orn0 = bodies[nodeID].m_quat;\n"
" float4 predictedOrn = quatMult(dorn, orn0);\n"
" predictedOrn = b3QuatNormalize(predictedOrn);\n"
" \n"
" b3Quat dorn;\n"
" dorn.x = axis.x;\n"
" dorn.y = axis.y;\n"
" dorn.z = axis.z;\n"
" dorn.w = b3Cos(fAngle * timeStep * 0.5f);\n"
" b3Quat orn0 = bodies[nodeID].m_quat;\n"
" b3Quat predictedOrn = b3QuatMul(dorn, orn0);\n"
" predictedOrn = b3QuatNormalized(predictedOrn);\n"
" bodies[nodeID].m_quat=predictedOrn;\n"
" }\n"
" //linear velocity \n"
@@ -328,5 +331,65 @@ static const char* integrateKernelCL= \
" bodies[nodeID].m_linVel += gravityAcceleration * timeStep;\n"
" \n"
" }\n"
" \n"
"}\n"
"inline void b3IntegrateTransform( __global b3RigidBodyData_t* body, float timeStep, float angularDamping, b3Float4ConstArg gravityAcceleration)\n"
"{\n"
" float BT_GPU_ANGULAR_MOTION_THRESHOLD = (0.25f * 3.14159254f);\n"
" \n"
" if( (body->m_invMass != 0.f))\n"
" {\n"
" //angular velocity\n"
" {\n"
" b3Float4 axis;\n"
" //add some hardcoded angular damping\n"
" body->m_angVel.x *= angularDamping;\n"
" body->m_angVel.y *= angularDamping;\n"
" body->m_angVel.z *= angularDamping;\n"
" \n"
" b3Float4 angvel = body->m_angVel;\n"
" float fAngle = b3Sqrt(b3Dot(angvel, angvel));\n"
" //limit the angular motion\n"
" if(fAngle*timeStep > BT_GPU_ANGULAR_MOTION_THRESHOLD)\n"
" {\n"
" fAngle = BT_GPU_ANGULAR_MOTION_THRESHOLD / timeStep;\n"
" }\n"
" if(fAngle < 0.001f)\n"
" {\n"
" // use Taylor's expansions of sync function\n"
" axis = angvel * (0.5f*timeStep-(timeStep*timeStep*timeStep)*0.020833333333f * fAngle * fAngle);\n"
" }\n"
" else\n"
" {\n"
" // sync(fAngle) = sin(c*fAngle)/t\n"
" axis = angvel * ( b3Sin(0.5f * fAngle * timeStep) / fAngle);\n"
" }\n"
" b3Quat dorn;\n"
" dorn.x = axis.x;\n"
" dorn.y = axis.y;\n"
" dorn.z = axis.z;\n"
" dorn.w = b3Cos(fAngle * timeStep * 0.5f);\n"
" b3Quat orn0 = body->m_quat;\n"
" b3Quat predictedOrn = b3QuatMul(dorn, orn0);\n"
" predictedOrn = b3QuatNormalized(predictedOrn);\n"
" body->m_quat=predictedOrn;\n"
" }\n"
" //apply gravity\n"
" body->m_linVel += gravityAcceleration * timeStep;\n"
" //linear velocity \n"
" body->m_pos += body->m_linVel * timeStep;\n"
" \n"
" }\n"
" \n"
"}\n"
"__kernel void \n"
" integrateTransformsKernel( __global b3RigidBodyData_t* bodies,const int numNodes, float timeStep, float angularDamping, float4 gravityAcceleration)\n"
"{\n"
" int nodeID = get_global_id(0);\n"
" \n"
" if( nodeID < numNodes)\n"
" {\n"
" integrateSingleTransform(bodies,nodeID, timeStep, angularDamping,gravityAcceleration);\n"
" }\n"
"}\n"
;

9
src/Bullet3OpenCL/RigidBody/kernels/solverSetup.h
View File

@@ -26,6 +26,9 @@ static const char* solverSetupCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"
@@ -141,7 +144,7 @@ static const char* solverSetupCL= \
"}\n"
" \n"
"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in);\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
@@ -153,8 +156,10 @@ static const char* solverSetupCL= \
" ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
" return ans;\n"
"}\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in)\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
"{\n"
" b3Quat q;\n"
" q=in;\n"
" //return b3FastNormalize4(in);\n"
" float len = native_sqrt(dot(q, q));\n"
" if(len > 0.f)\n"

3
src/Bullet3OpenCL/RigidBody/kernels/solverSetup2.h
View File

@@ -26,6 +26,9 @@ static const char* solverSetup2CL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"

3
src/Bullet3OpenCL/RigidBody/kernels/solverUtils.h
View File

@@ -26,6 +26,9 @@ static const char* solverUtilsCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"

9
src/Bullet3OpenCL/RigidBody/kernels/updateAabbsKernel.h
View File

@@ -16,6 +16,9 @@ static const char* updateAabbsKernelCL= \
"#else\n"
"#define b3AtomicInc atomic_inc\n"
"#define b3Fabs fabs\n"
"#define b3Sqrt native_sqrt\n"
"#define b3Sin native_sin\n"
"#define b3Cos native_cos\n"
"#endif\n"
"#endif\n"
"#ifdef __cplusplus\n"
@@ -71,7 +74,7 @@ static const char* updateAabbsKernelCL= \
"}\n"
" \n"
"inline b3Quat b3QuatMul(b3Quat a, b3Quat b);\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in);\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in);\n"
"inline b3Quat b3QuatRotate(b3QuatConstArg q, b3QuatConstArg vec);\n"
"inline b3Quat b3QuatInvert(b3QuatConstArg q);\n"
"inline b3Quat b3QuatMul(b3QuatConstArg a, b3QuatConstArg b)\n"
@@ -83,8 +86,10 @@ static const char* updateAabbsKernelCL= \
" ans.w = a.w*b.w - b3Dot3F4(a, b);\n"
" return ans;\n"
"}\n"
"inline b3Quat b3QuatNormalize(b3QuatConstArg in)\n"
"inline b3Quat b3QuatNormalized(b3QuatConstArg in)\n"
"{\n"
" b3Quat q;\n"
" q=in;\n"
" //return b3FastNormalize4(in);\n"
" float len = native_sqrt(dot(q, q));\n"
" if(len > 0.f)\n"