ackphysx.dll community version

Gamestudio Links

Zorro Links

Newest Posts

tradeUpdatePool() but for only exiting positions
by AndrewAMD. 05/03/24 15:20

FOSS C++ DLL framework with a Python subsystem and git hooks.
by firatv. 05/02/24 09:40

Help with plotting multiple ZigZag
by degenerate_762. 04/30/24 23:23

M1 Oversampling
by 11honza11. 04/30/24 08:16

Texture/Sprite animation tool. Someone interested in ?
by NeoDumont. 04/29/24 02:20

Trading Journey
by howardR. 04/28/24 09:55

Zorro Trader GPT
by TipmyPip. 04/27/24 13:50

Data from CSV not parsed correctly
by jcl. 04/26/24 11:18

AUM Magazine

Latest Screens

Who's Online Now

1 registered members (AndrewAMD), 959 guests, and 8 spiders.

Key: Admin, Global Mod, Mod

Newest Members

firatv, wandaluciaia, Mega_Rod, EternallyCurious, howardR
19050 Registered Users

Print Thread

Rate Thread

Page 6 of 6

Re: ackphysx.dll community version [Re: HeelX] #387604 11/21/11 12:41 11/21/11 12:41
Joined: Jul 2001 Posts: 6,904 H HeelX OP Senior Expert
HeelX OP Senior Expert H 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: Code: typedef VECTOR 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 Quote: // 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
Rackscha 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 H HeelX OP Senior Expert
HeelX OP Senior Expert H 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 Click to reveal.. // 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 Click to reveal.. 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 H HeelX OP Senior Expert
HeelX OP Senior Expert H 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: Click to reveal.. 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: Click to reveal.. // 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: Click to reveal.. // 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: Click to reveal.. // 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: HeelX] #397988 03/26/12 09:11 03/26/12 09:11
Joined: May 2008 Posts: 2,113 NRW/Germany alibaba Expert
alibaba Expert Joined: May 2008 Posts: 2,113 NRW/Germany	Okay, so i tried to compile it, but it�s asking me for a "NxWheel.h" Professional Edition A8.47.1 -------------------- http://www.yueklet.de

Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...) [Re: alibaba] #405570 08/02/12 13:44 08/02/12 13:44
Joined: Feb 2009 Posts: 3,207 Germany, Magdeburg Rei_Ayanami Expert
Rei_Ayanami Expert Joined: Feb 2009 Posts: 3,207 Germany, Magdeburg	If you want to use PhysX in Gamestudio (and especially Joints) - use this version! MarianFrische.com

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 H HeelX OP Senior Expert
HeelX OP Senior Expert H Joined: Jul 2001 Posts: 6,904	Originally Posted By: alibaba 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. Originally Posted By: Rei_Ayanami 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-... G gameplan Member
gameplan Member G 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

Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...) [Re: gameplan] #406442 08/20/12 08:30 08/20/12 08:30
Joined: Jul 2001 Posts: 6,904 H HeelX OP Senior Expert
HeelX OP Senior Expert H Joined: Jul 2001 Posts: 6,904	Hi gameplan. This happens only when PhysX can't be initialized at all. Do not overwrite the original files, but put the dll and the h file aside your project.

Re: ackphysx.dll (new: 3x4 matrices, spheres, planes, ...) [Re: HeelX] #406443 08/20/12 08:31 08/20/12 08:31
Joined: Jul 2001 Posts: 6,904 H HeelX OP Senior Expert
HeelX OP Senior Expert H Joined: Jul 2001 Posts: 6,904	I also see, that you use A8 free. You can use Plugin extensions only with A8 Extra or higher, I think.

Page 6 of 6

Moderated by Captain_Kiyaku, checkbutton, ISG, Realspawn