1 registered members (AbrahamR),
717
guests, and 4
spiders. |
Key:
Admin,
Global Mod,
Mod
|
|
|
Re: ackphysx.dll community version
[Re: HeelX]
#387604
11/21/11 12:41
11/21/11 12:41
|
Joined: Jul 2001
Posts: 6,904
HeelX
OP
Senior Expert
|
OP
Senior Expert
Joined: Jul 2001
Posts: 6,904
|
Update! Whole PhysX vector library was enabled for Lite-C. PhysX has an own class for vectors, called NxVec3 - for enabling it in Lite-C, I typedef'ed VECTORS as NxVec3: The rest (conversion, etc.) is done in my dll-backyard, so you can simply pass regular Lite-C vectors to the following functions. But if you are cool and sort of an NVidia hipster, you can also write always NxVec3 I just invented the typedef, because other basic datatypes will follow soon, like NxMat33 (rotation matrices), NxQuat (quaternions), etc. Here are the new, bulletproof functions from NVidia for you. Some of them are really cool, even if it is just vector math // constructors NxVec3* pXvecCreate (); // new uninitialized v NxVec3* pXvecCreateScalar (float); // v = a,a,a NxVec3* pXvecCreateXYZ (float, float, float); // v = x,y,z NxVec3* pXvecCreateCopy (NxVec3*); // makes copy of another vector v NxVec3* pXvecCreateArr (float* arr); // from array: v = [0],[1],[2]
// assignment NxVec3* pXvecSet (NxVec3*, NxVec3* a); // v = a NxVec3* pXvecSetXYZ (NxVec3*, float, float, float); // v = (x,y,z) NxVec3* pXvecSetX (NxVec3*, float); // v.x = x NxVec3* pXvecSetY (NxVec3*, float); // v.y = y NxVec3* pXvecSetZ (NxVec3*, float); // v.z = z NxVec3* pXvecSetS (NxVec3*, float); // v = (s,s,s) NxVec3* pXvecZero (NxVec3*); // v = (0,0,0)
// writes out the 3 values to dest array NxVec3* pXvecGetArr (NxVec3*, float* dest);
// gets element by index float pXvecGet (NxVec3*, int);
// true if all the components of v are smaller BOOL pXvecIsLesser (NxVec3*, NxVec3* greater);
// true if the vectors are -exactly- (un)equal BOOL pXvecEqual (NxVec3*, NxVec3*); BOOL pXvecUnequal (NxVec3*, NxVec3*);
// true if a and b's elems are within epsilon of each other BOOL pXvecEqualEps (NxVec3*, NxVec3*, float eps);
// inverse NxVec3* pXvecInv (NxVec3*); // v = -v NxVec3* pXvecSetInv (NxVec3*, NxVec3* a); // v = -a
// v = (0,0,0) NxVec3* pXvecZero (NxVec3*);
// tests for exact zero vector BOOL pXvecIsZero (NxVec3*);
// sets minus/plus infinity NxVec3* pXvecSetPlusInfinity (NxVec3*); NxVec3* pXvecSetMinusInfinity (NxVec3*);
// v = element wise min(v,a) / max(v,a) NxVec3* pXvecSetMin (NxVec3*, NxVec3* a); NxVec3* pXvecSetMax (NxVec3*, NxVec3* a);
// arithmetics NxVec3* pXvecAdd (NxVec3*, NxVec3* a); // v = v + a NxVec3* pXvecSub (NxVec3*, NxVec3* a); // v = v - a NxVec3* pXvecScale (NxVec3*, float s); // v = v * s NxVec3* pXvecMul (NxVec3*, NxVec3* s); // element wise v = v * s NxVec3* pXvecMulAdd (NxVec3*, float s, NxVec3* a); // v = v * s + a
// normalizes to length = 1 NxVec3* pXvecNormalize (NxVec3*);
// sets the vector's length to s NxVec3* pXvecSetLength (NxVec3*, float);
// returns the length and squared length float pXvecLength (NxVec3*); float pXvecLengthSq (NxVec3*);
// returns the distance (and squared distance) between v and a float pXvecDist (NxVec3*, NxVec3*); float pXvecDistSq (NxVec3*, NxVec3*);
// returns the number of closest axis: 0 = x.., 1 = y.., 2 = z axis int pXvecClosestAxis (NxVec3*);
// snaps to closest axis and normalizes vector NxVec3* pXvecSnapToClosestAxis (NxVec3*);
// returns true if all 3 elems of the vector are finite (not NAN or INF, etc.) BOOL pXvecIsFinite (NxVec3*);
// returns the scalar product of v and a float pXvecDot (NxVec3*, NxVec3*);
// calculates the cross product of v and a: n = v X a NxVec3* pXvecCross (NxVec3* n, NxVec3* v, NxVec3* a);
// compares orientations BOOL pXvecSameDirection (NxVec3*, NxVec3*);
Download the dll + header + lib here: ackphysx.20111121_2.dll.h.lib.rar and checkout the whole as always on SVN. Cheers! -Christian P.S: is anyone interested into swizzling functions for vectors?
|
|
|
Re: ackphysx.dll community version
[Re: HeelX]
#387608
11/21/11 15:48
11/21/11 15:48
|
Joined: Dec 2008
Posts: 1,218 Germany
Rackscha
Serious User
|
Serious User
Joined: Dec 2008
Posts: 1,218
Germany
|
really cool stuff, thanks
MY Website with news of my projects: (for example my current Muliplayer Bomberman, GenesisPrecompiler for LiteC and TileMaster, an easy to use Tile editor) Sparetime-Development
|
|
|
Re: ackphysx.dll (new: quaternions + 3x3 matrices)
[Re: Rackscha]
#388038
11/27/11 13:49
11/27/11 13:49
|
Joined: Jul 2001
Posts: 6,904
HeelX
OP
Senior Expert
|
OP
Senior Expert
Joined: Jul 2001
Posts: 6,904
|
- new: whole quaternion library enabled for Lite-C - new: whole 3x3 rotation matrix library enabled for Lite-C - new: some PI constants (single, double, inverted...) quaternion library functions // quaternion typedef struct NxQuat { float x, y, z, w; } NxQuat;
//...
// constructors NxQuat* pXquatCreate (); // uninitialized quaternion NxQuat* pXquatCreateCopy (NxQuat*); // from another quaternion (copy) NxQuat* pXquatCreateVec0 (NxVec3* v); // from v = x,y,z and w = 0 NxQuat* pXquatCreateVecW (NxVec3* v, float w); // from v = x,y,z and w NxQuat* pXquatCreateAngAxis (float angle, NxVec3* axis); // from angle-axis representation NxQuat* pXquatCreateAngle (ANGLE* a); // from euler angle NxQuat* pXquatCreateMat (NxMat33* m); // from orientation matrix
// setters NxQuat* pXquatSet (NxQuat*, NxQuat* other); // from other quaternion NxQuat* pXquatSetWXYZ (NxQuat*, float w, float x, float y, float z); NxQuat* pXquatSetArrWXYZ (NxQuat*, float* wxyz); // from array NxQuat* pXquatSetXYZW (NxQuat*, float x, float y, float z, float w); NxQuat* pXquatSetArrXYZW (NxQuat*, float* xyzw); // from array NxQuat* pXquatSetX (NxQuat*, float); NxQuat* pXquatSetY (NxQuat*, float); NxQuat* pXquatSetZ (NxQuat*, float); NxQuat* pXquatSetW (NxQuat*, float);
// getters NxQuat* pXquatGetWXYZ (NxQuat*, float* wxyz); // to array NxQuat* pXquatGetXYZW (NxQuat*, float* xyzw); // to array
// sets q to the identity rotation NxQuat* pXquatId (NxQuat* q);
// sets q to the quaternion to [0,0,0,1] NxQuat* pXquatZero (NxQuat* q);
// randomizes q as unit quaternion NxQuat* pXquatRandom (NxQuat* q);
// sets the quaterion to the opposite rotation NxQuat* pXquatInvert (NxQuat*);
// creates from angle-axis representation, euler angle, or rotation matrix NxQuat* pXquatFromAngleAxis (NxQuat*, float angle, NxVec3* axis); NxQuat* pXquatFromAngleAxisFast (NxQuat*, float angle, NxVec3* axis); NxQuat* pXquatFromMat (NxQuat*, NxMat33* m); NxQuat* pXquatFromAngle (NxQuat* q, ANGLE* a);
// fetches the angle/axis or euler angle given by the NxQuat NxQuat* pXquatGetAngleAxis (NxQuat*, float* angle, NxVec3* axis);
// gets the angle between the quat and another quat or the identity quaternion float pXquatGetAngleIdentity (NxQuat*); float pXquatGetAngle (NxQuat*, NxQuat* other);
// squared 4D vector length, should be 1 for unit quaternions float pXquatGetLengthSq (NxQuat*);
// returns the scalar product of two quaternions float pXquatDot (NxQuat*, NxQuat*);
// maps to the closest unit quaternion NxQuat* pXquatNormalize (NxQuat*);
// conjugates q NxQuat* pXquatConjugate (NxQuat* q);
// multiplies a with b/v NxQuat* pXquatMultiply (NxQuat* a, NxQuat* b); NxQuat* pXquatMultiplyVec (NxQuat* a, NxVec3* v);
// spherical linear interpolation between a and b by t percent (0...100) // result is stored in q: q = slerp(t, a, b) NxQuat* pXquatSlerp (NxQuat* q, float t, NxQuat* a, NxQuat* b);
// rotates a vector NxVec3* pXquatRotate (NxQuat*, NxVec3* v); NxVec3* pXquatInvRotate (NxQuat*, NxVec3* v);
// transforms a vector at position p NxQuat* pXquatTransform (NxQuat*, NxVec3* v, NxVec3* p); NxQuat* pXquatInvTransform (NxQuat*, NxVec3* v, NxVec3* p);
// negates q NxQuat* pXquatNegate (NxQuat* q);
// arithmethics NxQuat* pXquatSub (NxQuat* q, NxQuat* other); NxQuat* pXquatMul (NxQuat* q, NxQuat* other); NxQuat* pXquatMulS (NxQuat* q, float s); NxQuat* pXquatAdd (NxQuat* q, NxQuat* other);
// tests BOOL pXquatIsIdentityRotation (NxQuat*); BOOL pXquatIsFinite (NxQuat*); rotation matrix library functions typedef struct NxMat33 { float m[3][3]; } NxMat33;
typedef int NxMatrixType; #define NX_ZERO_MATRIX 0 // all zeros #define NX_IDENTITY_MATRIX 1 // identity matrix
//...
// constructors NxMat33* pXmatCreate (); NxMat33* pXmatCreateType (NxMatrixType type); NxMat33* pXmatCreateRows (NxVec3* row0, NxVec3* row1, NxVec3* row2); NxMat33* pXmatCreateCopy (NxMat33* m); NxMat33* pXmatCreateQuat (NxQuat* q); NxMat33* pXmatCreateAngle (ANGLE* a);
// setters NxMat33* pXmatSet (NxMat33* m, int row, int col, float value); NxMat33* pXmatSetRow (NxMat33* m, int row, NxVec3* v); NxMat33* pXmatSetRowMajor (NxMat33* m, float* v); NxMat33* pXmatSetRowMajorStride4 (NxMat33* m, float* v); NxMat33* pXmatSetColumn (NxMat33* m, int col, NxVec3* v); NxMat33* pXmatSetColumnMajor (NxMat33* m, float* v); NxMat33* pXmatSetColumnMajorStride4 (NxMat33* m, float* v);
// getters float pXmatGet (NxMat33* m, int row, int col); NxVec3* pXmatGetRow (NxMat33* m, int row, NxVec3* v); NxMat33* pXmatGetRowMajor (NxMat33* m, float* v); NxMat33* pXmatGetRowMajorStride4 (NxMat33* m, float* v); NxVec3* pXmatGetColumn (NxMat33* m, int col, NxVec3* v); NxMat33* pXmatGetColumnMajor (NxMat33* m, float* v); NxMat33* pXmatGetColumnMajorStride4 (NxMat33* m, float* v);
// returns true for identity matrix BOOL pXmatIsIdentity (NxMat33* m);
// returns true for zero matrix BOOL pXmatIsZero (NxMat33* m);
// returns true if all elems are finite (not NAN or INF, etc.) BOOL pXmatIsFinite (NxMat33* m);
// sets this matrix to the zero matrix NxMat33* pXmatZero (NxMat33* m);
// sets this matrix to the identity matrix NxMat33* pXmatId (NxMat33* m);
// m = -m NxMat33* pXmatSetNegative (NxMat33* m);
// sets this matrix to the diagonal matrix NxMat33* pXmatDiagonal (NxMat33* m, NxVec3* d);
// sets this matrix to the star (skew symmetric) matrix NxMat33* pXmatStar (NxMat33* m, NxVec3* v);
NxMat33* pXmatFromQuat (NxMat33* m, NxQuat* q); NxQuat* pXmatToQuat (NxMat33* m, NxQuat* q);
NxMat33* pXmatFromAngle (NxMat33* m, ANGLE* a); ANGLE* pXmatToAngle (NxMat33* m, ANGLE* a);
NxMat33* pXmatAdd (NxMat33* m, NxMat33* other); NxMat33* pXmatAddDest (NxMat33* m, NxMat33* other, NxMat33* dest); NxMat33* pXmatSub (NxMat33* m, NxMat33* other); NxMat33* pXmatSubDest (NxMat33* m, NxMat33* other, NxMat33* dest); NxMat33* pXmatScale (NxMat33* m, float s); // m = m * s NxMat33* pXmatScaleDest (NxMat33* m, float s, NxMat33* dest); // dest = m * s NxMat33* pXmatMultiply (NxMat33* m, NxMat33* other); // m = m * other NxMat33* pXmatMultiplyDest (NxMat33* m, NxMat33* other, NxMat33* dest); // dest = m * other NxVec3* pXmatMultiplyVec (NxMat33* m, NxVec3* v); NxVec3* pXmatMultiplyVecDest (NxMat33* m, NxVec3* v, NxVec3* dest); NxMat33* pXmatMultiplyTransposeLeft (NxMat33* m, NxMat33* left, NxMat33* right); // m = transpose(left) * right NxMat33* pXmatMultiplyTransposeRight (NxMat33* m, NxMat33* left, NxMat33* right); // m = left * transpose(right) NxMat33* pXmatMultiplyTransposeRightVec (NxMat33* m, NxVec3* left, NxVec3* right); // m = left * transpose(right) NxMat33* pXmatDiv (NxMat33* m, float s);
// returns determinant float pXmatDeterminant (NxMat33* m);
// assigns inverse to dest BOOL pXmatGetInverse (NxMat33* m, NxMat33* dest);
// m = transpose(other) NxMat33* pXmatSetTransposed (NxMat33* m, NxMat33* other);
// m = transpose(m) NxMat33* pXmatTranspose (NxMat33* m);
// m = m * [ d.x 0 0; 0 d.y 0; 0 0 d.z ] NxMat33* pXmatMultiplyDiagonal (NxMat33* m, NxVec3* d);
// dest = m * [ d.x 0 0; 0 d.y 0; 0 0 d.z ] NxMat33* pXmatMultiplyDiagonalDest (NxMat33* m, NxVec3* d, NxMat33* dest);
// m = transpose(m) * [ d.x 0 0; 0 d.y 0; 0 0 d.z ] NxMat33* pXmatMultiplyDiagonalTranspose (NxMat33* m, NxVec3* d);
// dest = transpose(m) * [ d.x 0 0; 0 d.y 0; 0 0 d.z ] NxMat33* pXmatMultiplyDiagonalTransposeDest (NxMat33* m, NxVec3* d, NxMat33* dest);
// rotate m around x, y or z axis NxMat33* pXmatRotX (NxMat33* m, float angle); NxMat33* pXmatRotY (NxMat33* m, float angle); NxMat33* pXmatRotZ (NxMat33* m, float angle);
// returns if matrix rows and columns are normalized BOOL pXmatIsNormalized (NxMat33* m);
// returns if matrix rows and columns are orthogonal BOOL pXmatIsOrthogonal (NxMat33* m);
// returns if matrix is rotation matrix BOOL pXmatIsRotation (NxMat33* m); Download lib, dll and header here: ackphysx.20111126.dll.h.lib.rar and on SVN the whole source code as always. Have fun, -Christian
Last edited by HeelX; 11/27/11 13:50.
|
|
|
Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...)
[Re: HeelX]
#388940
12/08/11 21:56
12/08/11 21:56
|
Joined: Jul 2001
Posts: 6,904
HeelX
OP
Senior Expert
|
OP
Senior Expert
Joined: Jul 2001
Posts: 6,904
|
Hi folks, since my PhysX-related contract work is now finished (I will soon write about this in the projects forum, when I find some spare time), development time for the PhysX plugin is rare now, since I concentrate now on other tasks (its a commercial project, I am working on a level editor). Rojart sent me some code for cloth physics and as soon as I enabled the most of the PhysX foundation, I will work on it and fluid particles. Here are the news about the last commit I made today: - change: all pXmat... functions were renamed to pXmat33..., since they deal with 3x3 rotation matrices and PhysX knows also 3x4 matrices (see below)
- new: 3x4 matrix datatype NxMat34 (+functions). Combination of a 3x3 rotation matrix and a translation vector. Homogenous transform composed of a matrix and a vector. See functions below.
- new: plane datatype NxPlane (+functions)
- new: sphere datatype NxSphere (+functions)
- added: NxSphericalJointFlag's
- added: specific functions for manipulating spherical joints and its rotation axis, limits, etc. Can be used to simulate arm joints for ragdolls.
- new: I was **SO** annoyed of not having trinary operators in Lite-C, so I added a custom function to the dll: float pXtrinary (BOOL b, float fTrue, float fFalse); NOTE: This is not part of the official PhysX SDK, but is quiet handy
- new: pXvecDeb (NxVec3*, char* name, char* str) prints 'vec "name" xyz=(...)' into str (for debugging)
- new: pXquatGetAngle (NxQuat* q, ANGLE* angle) converts a quaternion into a Gamestudio Euler-angle
- new: pXquatDeb (NxQuat*, char* name, char* str) prints 'quat "name" xyzw=(%.3f, %.3f, %.3f, %.3f)' into str (for debugging)
- internal: to mainstream the conversions between Gamestudio and PhysX and due to the introduction of Gamestudio structs that are data facades to the PhysX classes, new conversion classes have been introduced, which should bridge the gap between plain numeric conversions (Plain) from and to Gamestudio and conversions from Gamestudio worldspace to PhysX world space (World; X/Z swap of axis and rotation matrices) and percentages (Percent). Overloaded static member functions ::fromGs and ::toGs should serve the purpose. Seems to be more elegant than my previous approaches and definitely than the previous approaches by the original author of the plugin. Use this from now on!
- internal: because of the renaming of the exported pXmat functions, the file pXmat.h/cpp was also renamed to pXmat33.h/cpp
New spherical joint functions: NxJoint* pXconAddSphericalJoint (ENTITY* eFrom, VECTOR* pos, VECTOR* axis, ENTITY* eTo, BOOL collision, float swingLimit, float swingRestitution, float twistLowLimit, float twistLowRestitution, float twistHighLimit, float twistHighRestitution);
// swing limit axis defined in the joint space of the first actor NxJoint* pXconSetSphericalJointSwingAxis (NxJoint*, NxVec3* axis);
// distance above which to project joint NxJoint* pXconSetSphericalJointProjectionDistance (NxJoint*, float dist);
// limits rotation around twist and swing axis NxJoint* pXconSetSphericalJointTwistLimit (NxJoint*, float lowAngle, float lowRestitution, float highAngle, float highRestitution); NxJoint* pXconSetSphericalJointSwingLimit (NxJoint*, float angle, float restitution);
// spring that works against twisting / swinging NxJoint* pXconSetSphericalJointTwistSpring (NxJoint*, float spring, float damper, float targetAngle); NxJoint* pXconSetSphericalJointSwingSpring (NxJoint*, float spring, float damper, float targetAngle);
// spring that lets the joint get pulled apart NxJoint* pXconSetSphericalJointSpring (NxJoint*, float spring, float damper, float targetDistance);
// sets/gets the flags to enable/disable the spring/motor/limit (see NxSphericalJointFlag) NxJoint* pXconSetSphericalJointFlags (NxJoint*, NxSphericalJointFlag flags); long pXconGetSphericalJointFlags (NxJoint*);
// use this to set/get the joint projection mode NxJoint* pXconSetSphericalJointProjectionMode (NxJoint*, NxJointProjectionMode projectionMode); NxJointProjectionMode pXconGetSphericalJointProjectionMode (NxJoint*); New 3x4 matrix (homogenous transform) functions: // by default m is inited and t isn't. Use bInitialized = true to init in full NxMat34* pXmat34create (BOOL bInitialized); NxMat34* pXmat34createRT (NxMat33* rot, NxVec3* trans);
NxMat34* pXmat34zero (NxMat34* m);
NxMat34* pXmat34id (NxMat34* m);
// returns true for identity matrix BOOL pXmat34isIdentity (NxMat34* m);
// returns true if all elems are finite (not NAN or INF, etc.) BOOL pXmat34isFinite (NxMat34* m);
// assigns inverse to dest NxMat34* pXmat34isFinite (NxMat34* m, NxMat34* dest);
// same as pXmat34getInverse, but assumes that M is orthonormal BOOL pXmat34getInverseRT (NxMat34* m, NxMat34* dest);
// m = left * right NxMat34* pXmat34multiply (NxMat34* m, NxMat34* left, NxMat34* right);
// dst = m * src NxVec3* pXmat34multiplyVec (NxMat34* m, NxVec3* src, NxVec3* dst);
// dst = inverse(this) * src - assumes that m is rotation matrix!!! NxVec3* pXmat34multiplyByInverseRT (NxMat34* m, NxVec3* src, NxVec3* dst);
// this = inverse(left) * right - assumes m is rotation matrix!!! NxMat34* pXmat34multiplyInverseRTLeft (NxMat34* m, NxMat34* left, NxMat34* right);
// this = left * inverse(right) -- assumes m is rotation matrix!!! NxMat34* pXmat34multiplyInverseRTRight (NxMat34* m, NxMat34* left, NxMat34* right);
// convert from a matrix format appropriate for rendering NxMat34* pXmat34setColumnMajor44 (NxMat34* m, float* f); float* pXmat34getColumnMajor44 (NxMat34* m, float* f);
// set the matrix given a row major matrix NxMat34* pXmat34setRowMajor44 (NxMat34* m, float* f); float* pXmat34getRowMajor44 (NxMat34* m, float* f); New plane functions: // constructors NxPlane* pXplaneCreate (); NxPlane* pXplaneCreateNormalDist (NxVec3* n, float d); // normal & dist NxPlane* pXplaneCreateNormalXYZDist (float nx, float ny, float nz, float d); // normal & dist NxPlane* pXplaneCreatePointNormal (NxVec3* p, NxVec3* n); // point on the plane & normal NxPlane* pXplaneCreatePoints (NxVec3* p0, NxVec3* p1, NxVec3* p2); // from 3 points NxPlane* pXplaneCreateCopy (NxPlane* p); // copy constructor
// sets plane to zero NxPlane* pXplaneZero (NxPlane* p);
NxPlane* pXplaneSetNormalDist (NxPlane* p, NxVec3* n, float d); NxPlane* pXplaneSetNormalXYZDist (NxPlane* p, float nx, float ny, float nz, float d); NxPlane* pXplaneSetPointNormal (NxPlane* p, NxVec3* pt, NxVec3* n); NxPlane* pXplaneSetPoints (NxPlane* p, NxVec3* p0, NxVec3* p1, NxVec3* p2);
float pXplaneDistance (NxPlane* p, NxVec3* pt);
BOOL pXplaneBelongs (NxPlane* p, NxVec3* pt); // projects p into the plane NxVec3* pXplaneProject (NxPlane* p, NxVec3* pt);
// find an arbitrary point in the plane NxVec3* pXplaneFindPoint (NxPlane* p, NxVec3* pt);
NxPlane* pXplaneNormalize (NxPlane* p); NxPlane* pXplaneTransform (NxPlane* p, NxMat34* transform, NxPlane* transformed); NxPlane* pXplaneInverseTransform (NxPlane* p, NxMat34* transform, NxPlane* transformed); New sphere functions: // constructors NxSphere* pXsphereCreate (); NxSphere* pXsphereCreateInit (NxVec3* center, float radius); NxSphere* pXsphereCreateCopy (NxSphere* s);
// checks the sphere is valid BOOL pXsphereIsValid (NxSphere* s);
// tests if a point is contained within the sphere BOOL pXsphereContainsVec (NxSphere* s, NxVec3* p);
// tests if another sphere is contained within the sphere BOOL pXsphereContainsSphere (NxSphere* s, NxSphere* other);
// tests if a box is contained within the sphere BOOL pXsphereContainsBox (NxSphere* s, NxVec3* vMin, NxVec3* vMax);
// tests if the sphere intersects another sphere BOOL pXsphereIntersect (NxSphere* s, NxSphere* other); You can download the dll + lib + header here: ackphysx.20111208.dll.h.lib.rar; you'll find the source as always on SVN. So, this is essentially not a "big" release, but I hope you understand. I hope to make another release this year with the rest of the PhysX foundation and that it is useful for anyone. Best regards, -Christian
Last edited by HeelX; 12/08/11 21:58.
|
|
|
Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...)
[Re: Rei_Ayanami]
#405572
08/02/12 13:49
08/02/12 13:49
|
Joined: Jul 2001
Posts: 6,904
HeelX
OP
Senior Expert
|
OP
Senior Expert
Joined: Jul 2001
Posts: 6,904
|
Okay, so i tried to compile it, but it´s asking me for a "NxWheel.h" I'm sorry that I forgot to answer to this, but I was in the US at that time. Answer: Make sure that you added the include paths from the NVidia SDK and the demos for that. The SDK code files are not included. If you want to use PhysX in Gamestudio (and especially Joints) - use this version! Thanks! As I use VisualStudio 2010 from now on, I will eventually update the repository for that. If JCL updates the PhysX Plugin Source download to the state of A8.40, I will eventually add the cloth support and so on, too.
|
|
|
Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...)
[Re: HeelX]
#406428
08/19/12 21:50
08/19/12 21:50
|
Joined: Aug 2011
Posts: 133 Germany, Supergeheimes Hinter-...
gameplan
Member
|
Member
Joined: Aug 2011
Posts: 133
Germany, Supergeheimes Hinter-...
|
Hi,
I replaced the dll, h and lib file in the gamestudio programm folder, but now I get the errormessage "cant initialize physx". Did I something wrong?
Last edited by gameplan; 08/19/12 23:46.
Version: A8 free OS: Windows 10
|
|
|
|