[Scummvm-git-logs] scummvm master -> c0351fe88d96a35d5238cfa07df70158a85083e5
grisenti
noreply at scummvm.org
Fri Dec 23 22:11:48 UTC 2022
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
c0351fe88d HPL1: replace assert macro in newton code
Commit: c0351fe88d96a35d5238cfa07df70158a85083e5
https://github.com/scummvm/scummvm/commit/c0351fe88d96a35d5238cfa07df70158a85083e5
Author: grisenti (emanuele at grisenti.net)
Date: 2022-12-23T23:11:15+01:00
Commit Message:
HPL1: replace assert macro in newton code
Changed paths:
engines/hpl1/engine/libraries/newton/Newton.cpp
engines/hpl1/engine/libraries/newton/NewtonClass.cpp
engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
engines/hpl1/engine/libraries/newton/core/dgArray.h
engines/hpl1/engine/libraries/newton/core/dgCRC.cpp
engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.h
engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
engines/hpl1/engine/libraries/newton/core/dgGeneralMatrix.h
engines/hpl1/engine/libraries/newton/core/dgGeneralVector.h
engines/hpl1/engine/libraries/newton/core/dgGoogol.cpp
engines/hpl1/engine/libraries/newton/core/dgHeap.h
engines/hpl1/engine/libraries/newton/core/dgIntersections.cpp
engines/hpl1/engine/libraries/newton/core/dgList.h
engines/hpl1/engine/libraries/newton/core/dgMatrix.cpp
engines/hpl1/engine/libraries/newton/core/dgMatrix.h
engines/hpl1/engine/libraries/newton/core/dgMemory.cpp
engines/hpl1/engine/libraries/newton/core/dgMemory.h
engines/hpl1/engine/libraries/newton/core/dgNode.cpp
engines/hpl1/engine/libraries/newton/core/dgPolygonSoupBuilder.cpp
engines/hpl1/engine/libraries/newton/core/dgPolygonSoupDatabase.h
engines/hpl1/engine/libraries/newton/core/dgPolyhedra.cpp
engines/hpl1/engine/libraries/newton/core/dgPolyhedra.h
engines/hpl1/engine/libraries/newton/core/dgQuaternion.cpp
engines/hpl1/engine/libraries/newton/core/dgQuaternion.h
engines/hpl1/engine/libraries/newton/core/dgRef.h
engines/hpl1/engine/libraries/newton/core/dgRefCounter.h
engines/hpl1/engine/libraries/newton/core/dgSPDMatrix.cpp
engines/hpl1/engine/libraries/newton/core/dgSphere.cpp
engines/hpl1/engine/libraries/newton/core/dgStack.h
engines/hpl1/engine/libraries/newton/core/dgThreads.cpp
engines/hpl1/engine/libraries/newton/core/dgTree.cpp
engines/hpl1/engine/libraries/newton/core/dgTree.h
engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
engines/hpl1/engine/libraries/newton/core/dgTypes.h
engines/hpl1/engine/libraries/newton/core/dgVector.h
engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.h
engines/hpl1/engine/libraries/newton/physics/dgBody.cpp
engines/hpl1/engine/libraries/newton/physics/dgBody.h
engines/hpl1/engine/libraries/newton/physics/dgBodyMasterList.cpp
engines/hpl1/engine/libraries/newton/physics/dgBroadPhaseCollision.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollision.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollision.h
engines/hpl1/engine/libraries/newton/physics/dgCollisionBVH.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionBox.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionCapsule.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionChamferCylinder.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionCompound.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionCompoundBreakable.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionCone.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionConvex.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexHull.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexModifier.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionCylinder.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionEllipse.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionHeightField.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionMesh.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionNull.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionScene.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionSphere.cpp
engines/hpl1/engine/libraries/newton/physics/dgCollisionUserMesh.cpp
engines/hpl1/engine/libraries/newton/physics/dgConnectorConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgConstraint.h
engines/hpl1/engine/libraries/newton/physics/dgContact.cpp
engines/hpl1/engine/libraries/newton/physics/dgCorkscrewConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgHingeConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgMeshEffect.cpp
engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
engines/hpl1/engine/libraries/newton/physics/dgMeshEffect3.cpp
engines/hpl1/engine/libraries/newton/physics/dgMeshEffectSolidTree.cpp
engines/hpl1/engine/libraries/newton/physics/dgMinkowskiConv.cpp
engines/hpl1/engine/libraries/newton/physics/dgNarrowPhaseCollision.cpp
engines/hpl1/engine/libraries/newton/physics/dgPointToCurveConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgSlidingConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgUniversalConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgUpVectorConstraint.cpp
engines/hpl1/engine/libraries/newton/physics/dgWorld.cpp
engines/hpl1/engine/libraries/newton/physics/dgWorldDynamicUpdate.cpp
engines/hpl1/engine/libraries/newton/physics/dgWorldDynamicUpdate.h
diff --git a/engines/hpl1/engine/libraries/newton/Newton.cpp b/engines/hpl1/engine/libraries/newton/Newton.cpp
index 9a40fa83900..d8bc2b29390 100644
--- a/engines/hpl1/engine/libraries/newton/Newton.cpp
+++ b/engines/hpl1/engine/libraries/newton/Newton.cpp
@@ -650,7 +650,7 @@ void NewtonUpdate(NewtonWorld *const newtonWorld, dFloat timestep) {
__try {
world->UpdatePhysics(time);
} __except (ExecptionHandler(_exception_info())) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// world->UpdatePhysics (time);
}
#else
@@ -708,7 +708,7 @@ void NewtonSetMinimumFrameRate(NewtonWorld *const newtonWorld,
world = (Newton *)newtonWorld;
TRACE_FUNTION(__FUNCTION__);
- _ASSERTE(
+ NEWTON_ASSERT(
dgFloat32(1.0f) / dgFloat32(MAX_TIMESTEP) < dgFloat32(1.0f) / dgFloat32(MIN_TIMESTEP));
frameRate = ClampValue(frameRate, dgFloat32(1.0f) / dgFloat32(MAX_TIMESTEP),
dgFloat32(1.0f) / dgFloat32(MIN_TIMESTEP));
@@ -899,7 +899,7 @@ NewtonBody *NewtonWorldGetFirstBody(const NewtonWorld *const newtonWorld) {
const dgBodyMasterList &masterList = *world;
TRACE_FUNTION(__FUNCTION__);
- _ASSERTE(
+ NEWTON_ASSERT(
masterList.GetFirst()->GetInfo().GetBody() == world->GetSentinelBody());
node = masterList.GetFirst()->GetNext();
// body = node->GetInfo().GetBody();
@@ -1135,7 +1135,7 @@ int NewtonWorldGetBodyCount(const NewtonWorld *const newtonWorld) {
world = (const Newton *)newtonWorld;
// dgBodyMasterList &masterList = *world;
- // _ASSERTE (masterList.GetFirst()->GetInfo().GetBody() == world->GetSentinelBody());
+ // NEWTON_ASSERT (masterList.GetFirst()->GetInfo().GetBody() == world->GetSentinelBody());
// return masterList.GetCount() - 1;
return world->GetBodiesCount();
}
@@ -1379,7 +1379,7 @@ int NewtonMaterialCreateGroupID(NewtonWorld *const newtonWorld) {
void NewtonMaterialDestroyAllGroupID(NewtonWorld *const newtonWorld) {
Newton *world;
- // _ASSERTE (0);
+ // NEWTON_ASSERT (0);
world = (Newton *)newtonWorld;
TRACE_FUNTION(__FUNCTION__);
@@ -1388,13 +1388,13 @@ void NewtonMaterialDestroyAllGroupID(NewtonWorld *const newtonWorld) {
// int NewtonGetActiveBodiesCount()
//{
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// return 0;
// }
// int NewtonGetActiveConstraintsCount()
//{
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// return 0;
// }
@@ -1840,7 +1840,7 @@ unsigned NewtonMaterialGetContactFaceAttribute(
dgContactMaterial* const material = (dgContactMaterial*) materialHandle;
// return material->m_currTimestep;
- _ASSERTE (material->m_body0);
+ NEWTON_ASSERT (material->m_body0);
return material->m_body0->GetWorld()->GetTimeStep();
}
*/
@@ -1858,7 +1858,7 @@ unsigned NewtonMaterialGetContactFaceAttribute(
// See also: NewtonMaterialSetCollisionCallback
dFloat NewtonMaterialGetContactNormalSpeed(
const NewtonMaterial *const materialHandle) {
- // _ASSERTE (0);
+ // NEWTON_ASSERT (0);
TRACE_FUNTION(__FUNCTION__);
const dgContactMaterial *const material = (const dgContactMaterial *)materialHandle;
@@ -1893,7 +1893,7 @@ dFloat NewtonMaterialGetContactNormalSpeed(
// See also: NewtonMaterialSetCollisionCallback
dFloat NewtonMaterialGetContactTangentSpeed(
const NewtonMaterial *const materialHandle, int index) {
- // _ASSERTE (0);
+ // NEWTON_ASSERT (0);
TRACE_FUNTION(__FUNCTION__);
const dgContactMaterial *const material = (const dgContactMaterial *)materialHandle;
@@ -2278,7 +2278,7 @@ void NewtonMaterialSetContactNormalDirection(
dgContactMaterial *const material = (dgContactMaterial *)materialHandle;
dgVector normal(direction[0], direction[1], direction[2], dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(
(dgAbsf(normal % material->m_normal) - dgFloat32(1.0f)) < dgFloat32(0.01f));
if ((normal % material->m_normal) < dgFloat32(0.0f)) {
normal = normal.Scale(-dgFloat32(1.0f));
@@ -3518,7 +3518,7 @@ void NewtonTreeCollisionBeginBuild(NewtonCollision *treeCollision) {
TRACE_FUNTION(__FUNCTION__);
dgCollisionBVH *const collision = (dgCollisionBVH *)treeCollision;
- _ASSERTE(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
+ NEWTON_ASSERT(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
collision->BeginBuild();
}
@@ -3545,7 +3545,7 @@ void NewtonTreeCollisionAddFace(NewtonCollision *const treeCollision,
int faceAttribute) {
TRACE_FUNTION(__FUNCTION__);
dgCollisionBVH *const collision = (dgCollisionBVH *)treeCollision;
- _ASSERTE(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
+ NEWTON_ASSERT(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
collision->AddFace(vertexCount, vertexPtr, strideInBytes, faceAttribute);
}
@@ -3571,7 +3571,7 @@ void NewtonTreeCollisionEndBuild(NewtonCollision *const treeCollision,
int optimize) {
TRACE_FUNTION(__FUNCTION__);
dgCollisionBVH *const collision = (dgCollisionBVH *)treeCollision;
- _ASSERTE(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
+ NEWTON_ASSERT(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
collision->EndBuild(optimize);
}
@@ -3592,7 +3592,7 @@ int NewtonTreeCollisionGetFaceAtribute(
const NewtonCollision *const treeCollision, const int *const faceIndexArray) {
TRACE_FUNTION(__FUNCTION__);
const dgCollisionBVH *const collision = (const dgCollisionBVH *)treeCollision;
- _ASSERTE(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
+ NEWTON_ASSERT(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
return int(collision->GetTagId(faceIndexArray));
}
@@ -3619,7 +3619,7 @@ void NewtonTreeCollisionSetFaceAtribute(
int attribute) {
TRACE_FUNTION(__FUNCTION__);
dgCollisionBVH *const collision = (dgCollisionBVH *)treeCollision;
- _ASSERTE(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
+ NEWTON_ASSERT(collision->IsType(dgCollision::dgCollisionBVH_RTTI));
collision->SetTagId(faceIndexArray, dgUnsigned32(attribute));
}
@@ -3759,7 +3759,7 @@ NewtonSceneProxy *NewtonSceneCollisionCreateProxy(NewtonCollision *const scene,
matrix.m_posit.m_w = dgFloat32(1.0f);
dgCollisionScene *const newtonScene = (dgCollisionScene *)scene;
- _ASSERTE(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
+ NEWTON_ASSERT(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
return (NewtonSceneProxy *)newtonScene->AddProxy((dgCollision *)collision,
matrix);
}
@@ -3767,7 +3767,7 @@ NewtonSceneProxy *NewtonSceneCollisionCreateProxy(NewtonCollision *const scene,
void NewtonSceneCollisionDestroyProxy(NewtonCollision *const scene,
NewtonSceneProxy *const proxy) {
dgCollisionScene *const newtonScene = (dgCollisionScene *)scene;
- _ASSERTE(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
+ NEWTON_ASSERT(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
newtonScene->RemoveProxy(proxy);
}
@@ -3822,7 +3822,7 @@ NewtonSceneProxy *NewtonSceneGetNextProxy(NewtonCollision *const scene,
void NewtonSceneCollisionOptimize(NewtonCollision *const scene) {
dgCollisionScene *const newtonScene = (dgCollisionScene *)scene;
- _ASSERTE(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
+ NEWTON_ASSERT(newtonScene->IsType(dgCollision::dgCollisionScene_RTTI));
newtonScene->ImproveTotalFitness();
}
@@ -4033,7 +4033,7 @@ void NewtonCollisionSupportVertex(const NewtonCollision *collisionPtr,
TRACE_FUNTION(__FUNCTION__);
collision = (const dgCollisionConvex *)collisionPtr;
- // _ASSERTE (collision->IsType (dgCollision::dgConvexCollision_RTTI));
+ // NEWTON_ASSERT (collision->IsType (dgCollision::dgConvexCollision_RTTI));
const dgMatrix &matrix = collision->GetOffsetMatrix();
dgVector searchDir(
@@ -4351,7 +4351,7 @@ void NewtonCollisionGetInfo(const NewtonCollision *const collision,
TRACE_FUNTION(__FUNCTION__);
- _ASSERTE(sizeof(dgCollisionInfo) <= sizeof(NewtonCollisionInfoRecord));
+ NEWTON_ASSERT(sizeof(dgCollisionInfo) <= sizeof(NewtonCollisionInfoRecord));
coll->GetCollisionInfo((dgCollisionInfo *)collisionInfo);
}
@@ -4447,7 +4447,7 @@ dFloat NewtonCalculateSpringDamperAcceleration(dFloat dt, dFloat ks, dFloat x,
dgFloat32 ksd = dt * ks;
dgFloat32 num = ks * x + kd * s + ksd * s;
dgFloat32 den = dgFloat32(1.0f) + dt * kd + dt * ksd;
- _ASSERTE(den > 0.0f);
+ NEWTON_ASSERT(den > 0.0f);
accel = -num / den;
// dgCheckFloat (accel);
return accel;
@@ -6252,7 +6252,7 @@ void NewtonBallSetConeLimits(NewtonJoint *ball, const dFloat *pin,
if (dgAbsf(tmp % coneAxis) > dgFloat32(0.999f)) {
tmp = dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(1.0f),
dgFloat32(0.0f));
- _ASSERTE(dgAbsf(tmp % coneAxis) < dgFloat32(0.999f));
+ NEWTON_ASSERT(dgAbsf(tmp % coneAxis) < dgFloat32(0.999f));
}
}
dgVector lateral(tmp * coneAxis);
@@ -7257,7 +7257,7 @@ void NewtonUserJointAddLinearRow(NewtonJoint *joint,
TRACE_FUNTION(__FUNCTION__);
dgVector direction(dir[0], dir[1], dir[2], dgFloat32(0.0f));
direction = direction.Scale(dgRsqrt(direction % direction));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(direction % direction - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
dgVector pivotPoint0(pivot0[0], pivot0[1], pivot0[2], dgFloat32(0.0f));
dgVector pivotPoint1(pivot1[0], pivot1[1], pivot1[2], dgFloat32(0.0f));
@@ -7294,7 +7294,7 @@ void NewtonUserJointAddAngularRow(NewtonJoint *joint,
userJoint = (NewtonUserJoint *)joint;
dgVector direction(pin[0], pin[1], pin[2], dgFloat32(0.0f));
direction = direction.Scale(dgRsqrt(direction % direction));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(direction % direction - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
userJoint->AddAngularRowJacobian(direction, relativeAngleError);
@@ -8139,7 +8139,7 @@ void NewtonMeshGetIndirectVertexStreams(const NewtonMesh *const mesh,
dFloat *const uv0, int *const uvIndices0, int *const uvCount0,
int uvStrideInByte1, dFloat *const uv1, int *const uvIndices1,
int *const uvCount1) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
const dgMeshEffect* const meshEffect = (const dgMeshEffect*) mesh;
@@ -8249,7 +8249,7 @@ NewtonMesh *NewtonMeshCreateNextSingleSegment(const NewtonMesh *const mesh,
const dgMeshEffect *const effectMesh = (const dgMeshEffect *)mesh;
dgPolyhedra nextSegment(effectMesh->GetAllocator());
- _ASSERTE(segment);
+ NEWTON_ASSERT(segment);
dgInt32 moreSegments = effectMesh->GetConectedSurface(nextSegment);
dgMeshEffect *solid;
diff --git a/engines/hpl1/engine/libraries/newton/NewtonClass.cpp b/engines/hpl1/engine/libraries/newton/NewtonClass.cpp
index b9b896e9780..b3c8f0f7e65 100644
--- a/engines/hpl1/engine/libraries/newton/NewtonClass.cpp
+++ b/engines/hpl1/engine/libraries/newton/NewtonClass.cpp
@@ -128,10 +128,10 @@ NewtonUserJoint::NewtonUserJoint(dgWorld *world, dgInt32 maxDof,
m_jacobianFnt = callback;
m_getInfoCallback = getInfo;
- _ASSERTE(world);
+ NEWTON_ASSERT(world);
m_forceArray = m_jointForce;
if (m_maxDOF > 24) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
m_forceArray = (dgFloat32 *) world->GetAllocator()->Malloc(
dgInt32(m_maxDOF * sizeof(dgFloat32)));
}
@@ -163,7 +163,7 @@ void NewtonUserJoint::AddLinearRowJacobian(const dgVector &pivot0,
CalculatePointDerivative(m_rows, *m_param, dir, pointData,
&m_forceArray[m_rows]);
m_rows++;
- _ASSERTE(m_rows <= dgInt32(m_maxDOF));
+ NEWTON_ASSERT(m_rows <= dgInt32(m_maxDOF));
}
void NewtonUserJoint::AddAngularRowJacobian(const dgVector &dir,
@@ -176,7 +176,7 @@ void NewtonUserJoint::AddAngularRowJacobian(const dgVector &dir,
CalculateAngularDerivative(m_rows, *m_param, dir, m_stiffness, relAngle,
&m_forceArray[m_rows]);
m_rows++;
- _ASSERTE(m_rows <= dgInt32(m_maxDOF));
+ NEWTON_ASSERT(m_rows <= dgInt32(m_maxDOF));
}
void NewtonUserJoint::AddGeneralRowJacobian(const dgFloat32 *jacobian0,
@@ -190,7 +190,7 @@ void NewtonUserJoint::AddGeneralRowJacobian(const dgFloat32 *jacobian0,
SetJacobianDerivative(m_rows, *m_param, jacobian0, jacobian1,
&m_forceArray[m_rows]);
m_rows++;
- _ASSERTE(m_rows <= dgInt32(m_maxDOF));
+ NEWTON_ASSERT(m_rows <= dgInt32(m_maxDOF));
}
void NewtonUserJoint::SetAcceleration(dgFloat32 acceleration) {
@@ -210,7 +210,7 @@ void NewtonUserJoint::SetSpringDamperAcceleration(dFloat springK,
dgFloat32 accel;
accel = CalculateSpringDamperAcceleration(index, *m_param, m_lastJointAngle,
m_lastPosit0, m_lastPosit1, springK, springD);
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// m_param->m_jointAccel[index] = accel;
SetMotorAcceleration(index, accel, *m_param);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp b/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
index 5c03464fe6f..3db1d34697a 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgAABBPolygonSoup.cpp
@@ -48,12 +48,12 @@ class dgAABBTree {
public:
inline TreeNode() {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
inline TreeNode(dgUnsigned32 node) {
m_node = node;
- _ASSERTE(!IsLeaf());
+ NEWTON_ASSERT(!IsLeaf());
}
inline dgUnsigned32 IsLeaf() const {
@@ -61,18 +61,18 @@ class dgAABBTree {
}
inline dgUnsigned32 GetCount() const {
- _ASSERTE(IsLeaf());
+ NEWTON_ASSERT(IsLeaf());
return (m_node & (~0x80000000)) >> (32 - DG_INDEX_COUNT_BITS - 1);
}
inline dgUnsigned32 GetIndex() const {
- _ASSERTE(IsLeaf());
+ NEWTON_ASSERT(IsLeaf());
return m_node & (~(-(1 << (32 - DG_INDEX_COUNT_BITS - 1))));
}
inline TreeNode(dgUnsigned32 faceIndexCount, dgUnsigned32 faceIndexStart) {
- _ASSERTE(faceIndexCount < (1 << DG_INDEX_COUNT_BITS));
+ NEWTON_ASSERT(faceIndexCount < (1 << DG_INDEX_COUNT_BITS));
m_node = 0x80000000 | (faceIndexCount << (32 - DG_INDEX_COUNT_BITS - 1))
| faceIndexStart;
}
@@ -190,7 +190,7 @@ public:
if (parentNode) {
*parentNode = boxCopy[node->m_boxIndex].m_back;
} else {
- //_ASSERTE(boxCount == 1);
+ //NEWTON_ASSERT(boxCount == 1);
dgAABBTree *const newNode = &boxArray[index];
*newNode = boxCopy[node->m_boxIndex];
index++;
@@ -259,8 +259,8 @@ public:
maxDepth = GetMax(maxDepth, depth);
if (node->m_boxIndex == -1) {
- _ASSERTE(node->m_back);
- _ASSERTE(node->m_front);
+ NEWTON_ASSERT(node->m_back);
+ NEWTON_ASSERT(node->m_front);
depth++;
depthPool[stack] = depth;
@@ -302,8 +302,8 @@ public:
}
void ImproveNodeFitness(dgConstructionTree *const node) const {
- _ASSERTE(node->m_back);
- _ASSERTE(node->m_front);
+ NEWTON_ASSERT(node->m_back);
+ NEWTON_ASSERT(node->m_front);
if (node->m_parent) {
if (node->m_parent->m_back == node) {
@@ -319,7 +319,7 @@ public:
if (parent->m_parent->m_back == parent) {
parent->m_parent->m_back = node;
} else {
- _ASSERTE(parent->m_parent->m_front == parent);
+ NEWTON_ASSERT(parent->m_parent->m_front == parent);
parent->m_parent->m_front = node;
}
}
@@ -338,7 +338,7 @@ public:
if (parent->m_parent->m_back == parent) {
parent->m_parent->m_back = node;
} else {
- _ASSERTE(parent->m_parent->m_front == parent);
+ NEWTON_ASSERT(parent->m_parent->m_front == parent);
parent->m_parent->m_front = node;
}
}
@@ -364,7 +364,7 @@ public:
if (parent->m_parent->m_back == parent) {
parent->m_parent->m_back = node;
} else {
- _ASSERTE(parent->m_parent->m_front == parent);
+ NEWTON_ASSERT(parent->m_parent->m_front == parent);
parent->m_parent->m_front = node;
}
}
@@ -383,7 +383,7 @@ public:
if (parent->m_parent->m_back == parent) {
parent->m_parent->m_back = node;
} else {
- _ASSERTE(parent->m_parent->m_front == parent);
+ NEWTON_ASSERT(parent->m_parent->m_front == parent);
parent->m_parent->m_front = node;
}
}
@@ -519,7 +519,7 @@ public:
}
}
- _ASSERTE (bestProxi != -1);
+ NEWTON_ASSERT (bestProxi != -1);
dgHeapNodePair pair;
pair.m_nodeA = i;
@@ -557,7 +557,7 @@ public:
}
}
- _ASSERTE (newCount < count);
+ NEWTON_ASSERT (newCount < count);
count = newCount;
}
@@ -571,8 +571,8 @@ public:
dgInt32 firstBox, dgInt32 lastBox, dgAABBTree *const boxArray,
const dgTriplex *const vertexArray, dgConstructionTree *parent) {
dgConstructionTree *const tree = new (allocator) dgConstructionTree();
- _ASSERTE(firstBox >= 0);
- _ASSERTE(lastBox >= 0);
+ NEWTON_ASSERT(firstBox >= 0);
+ NEWTON_ASSERT(lastBox >= 0);
tree->m_parent = parent;
@@ -710,9 +710,9 @@ public:
m_axis = i0 + 1;
}
- _ASSERTE(maxP.m_x - minP.m_x >= dgFloat32(0.0f));
- _ASSERTE(maxP.m_y - minP.m_y >= dgFloat32(0.0f));
- _ASSERTE(maxP.m_z - minP.m_z >= dgFloat32(0.0f));
+ NEWTON_ASSERT(maxP.m_x - minP.m_x >= dgFloat32(0.0f));
+ NEWTON_ASSERT(maxP.m_y - minP.m_y >= dgFloat32(0.0f));
+ NEWTON_ASSERT(maxP.m_z - minP.m_z >= dgFloat32(0.0f));
m_p0 = minP;
m_p1 = maxP;
}
@@ -902,7 +902,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_back.GetNode(this);
stack++;
}
@@ -916,7 +916,7 @@ public:
return;
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_front.GetNode(this);
stack++;
}
@@ -948,7 +948,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_back.GetNode(this);
stack++;
}
@@ -961,7 +961,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_front.GetNode(this);
stack++;
}
@@ -992,7 +992,7 @@ public:
dgFloat32 param = callback(context, vertexArray, sizeof(dgTriplex),
&indexArray[index + 1], vCount);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
maxParam = param;
if (maxParam == dgFloat32(0.0f)) {
@@ -1003,7 +1003,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_back.GetNode(this);
stack++;
}
@@ -1014,7 +1014,7 @@ public:
dgInt32 index = dgInt32(me->m_front.GetIndex());
dgFloat32 param = callback(context, vertexArray, sizeof(dgTriplex),
&indexArray[index + 1], vCount);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
maxParam = param;
if (maxParam == dgFloat32(0.0f)) {
@@ -1025,7 +1025,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_front.GetNode(this);
stack++;
}
@@ -1054,7 +1054,7 @@ public:
dgInt32 index = dgInt32(me->m_back.GetIndex());
dgFloat32 param = callback(context, vertexArray, sizeof(dgTriplex),
&indexArray[index + 1], vCount);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
maxParam = param;
if (maxParam == dgFloat32(0.0f)) {
@@ -1065,7 +1065,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_back.GetNode(this);
stack++;
}
@@ -1076,7 +1076,7 @@ public:
dgInt32 index = dgInt32(me->m_front.GetIndex());
dgFloat32 param = callback(context, vertexArray, sizeof(dgTriplex),
&indexArray[index + 1], vCount);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
maxParam = param;
if (maxParam == dgFloat32(0.0f)) {
@@ -1087,7 +1087,7 @@ public:
}
} else {
- _ASSERTE(stack < DG_STACK_DEPTH);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH);
stackPool[stack] = me->m_front.GetNode(this);
stack++;
}
@@ -1514,7 +1514,7 @@ dgIntersectStatus dgAABBPolygonSoup::CalculateAllFaceEdgeNormals(void *context,
adjacentFaces.m_normal = dgPlane(n, -(n % p));
}
- _ASSERTE(indexCount < dgInt32(sizeof(adjacentFaces.m_edgeMap) / sizeof(adjacentFaces.m_edgeMap[0])));
+ NEWTON_ASSERT(indexCount < dgInt32(sizeof(adjacentFaces.m_edgeMap) / sizeof(adjacentFaces.m_edgeMap[0])));
dgInt32 edgeIndex = indexCount - 1;
dgInt32 i0 = indexArray[indexCount - 1];
diff --git a/engines/hpl1/engine/libraries/newton/core/dgArray.h b/engines/hpl1/engine/libraries/newton/core/dgArray.h
index 128d9d2fa61..5dd7b295363 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgArray.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgArray.h
@@ -67,7 +67,7 @@ dgArray<T>::~dgArray() {
template<class T>
const T &dgArray<T>::operator[](dgInt32 i) const {
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i >= 0);
while (i >= m_maxSize) {
Resize(i);
}
@@ -77,7 +77,7 @@ const T &dgArray<T>::operator[](dgInt32 i) const {
template<class T>
T &dgArray<T>::operator[](dgInt32 i) {
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i >= 0);
while (i >= m_maxSize) {
Resize(i);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgCRC.cpp b/engines/hpl1/engine/libraries/newton/core/dgCRC.cpp
index fa55bd923f9..9a733af5787 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgCRC.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgCRC.cpp
@@ -324,14 +324,14 @@ dgUnsigned32 dgApi dgCRC(const char *const name) {
crc = (crc << 8) ^ val;
}
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// InternalCRC::GetDatabase().AddString (crc, name);
return crc;
}
dgUnsigned32 dgApi dgCRC(const void *const buffer, dgInt32 size,
dgUnsigned32 crcAcc) {
- _ASSERTE(buffer);
+ NEWTON_ASSERT(buffer);
const unsigned char *const ptr = (const unsigned char *) buffer;
for (dgInt32 i = 0; i < size; i++) {
dgUnsigned32 c = ptr[i];
@@ -342,7 +342,7 @@ dgUnsigned32 dgApi dgCRC(const void *const buffer, dgInt32 size,
}
const char *dgApi dgInverseCRC(dgUnsigned32 crc) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return NULL;
// return InternalCRC::GetDatabase().FindString (crc);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp b/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
index fb45e4aac23..e7e21dedb3b 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgConvexHull3d.cpp
@@ -162,7 +162,7 @@ dgInt32 dgConvexHull3d::ConvexCompareVertex(const dgHullVertex *const A, const
dgAABBPointTree3d *dgConvexHull3d::BuildTree(dgAABBPointTree3d *const parent, dgHullVertex *const points, dgInt32 count, dgInt32 baseIndex, dgInt8 **memoryPool, dgInt32 &maxMemSize) const {
dgAABBPointTree3d *tree = NULL;
- _ASSERTE(count);
+ NEWTON_ASSERT(count);
dgBigVector minP(dgFloat32(1.0e15f), dgFloat32(1.0e15f), dgFloat32(1.0e15f), dgFloat32(0.0f));
dgBigVector maxP(-dgFloat32(1.0e15f), -dgFloat32(1.0e15f), -dgFloat32(1.0e15f), dgFloat32(0.0f));
if (count <= DG_VERTEX_CLUMP_SIZE_3D) {
@@ -170,7 +170,7 @@ dgAABBPointTree3d *dgConvexHull3d::BuildTree(dgAABBPointTree3d *const parent, dg
dgAABBPointTree3dClump *const clump = new (*memoryPool) dgAABBPointTree3dClump;
*memoryPool += sizeof(dgAABBPointTree3dClump);
maxMemSize -= sizeof(dgAABBPointTree3dClump);
- _ASSERTE(maxMemSize >= 0);
+ NEWTON_ASSERT(maxMemSize >= 0);
clump->m_count = count;
@@ -256,16 +256,16 @@ dgAABBPointTree3d *dgConvexHull3d::BuildTree(dgAABBPointTree3d *const parent, dg
tree = new (*memoryPool) dgAABBPointTree3d;
*memoryPool += sizeof(dgAABBPointTree3d);
maxMemSize -= sizeof(dgAABBPointTree3d);
- _ASSERTE(maxMemSize >= 0);
+ NEWTON_ASSERT(maxMemSize >= 0);
- _ASSERTE(i0);
- _ASSERTE(count - i0);
+ NEWTON_ASSERT(i0);
+ NEWTON_ASSERT(count - i0);
tree->m_left = BuildTree(tree, points, i0, baseIndex, memoryPool, maxMemSize);
tree->m_right = BuildTree(tree, &points[i0], count - i0, i0 + baseIndex, memoryPool, maxMemSize);
}
- _ASSERTE(tree);
+ NEWTON_ASSERT(tree);
tree->m_parent = parent;
tree->m_box[0] = minP - dgBigVector(dgFloat64(1.0e-3f), dgFloat64(1.0e-3f), dgFloat64(1.0e-3f), dgFloat64(1.0f));
tree->m_box[1] = maxP + dgBigVector(dgFloat64(1.0e-3f), dgFloat64(1.0e-3f), dgFloat64(1.0e-3f), dgFloat64(1.0f));
@@ -283,7 +283,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
dgInt32 index = i * stride;
dgBigVector &vertex = points[i];
vertex = dgBigVector(vertexCloud[index], vertexCloud[index + 1], vertexCloud[index + 2], vertexCloud[index + 3]);
- _ASSERTE(dgCheckVector(vertex));
+ NEWTON_ASSERT(dgCheckVector(vertex));
points[i].m_index = 0;
}
} else {
@@ -291,7 +291,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
dgInt32 index = i * stride;
dgBigVector &vertex = points[i];
vertex = dgBigVector(vertexCloud[index], vertexCloud[index + 1], vertexCloud[index + 2], dgFloat64(0.0f));
- _ASSERTE(dgCheckVector(vertex));
+ NEWTON_ASSERT(dgCheckVector(vertex));
points[i].m_index = 0;
}
}
@@ -331,7 +331,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
dgBigVector e1(dgFloat64(0.0f), dgFloat64(0.0f), dgFloat64(0.0f), dgFloat64(0.0f)) ;
for (dgInt32 i = 1; i < normalCount; i ++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
+ NEWTON_ASSERT(indexSV >= 0);
e1 = points[indexSV] - m_points[0];
dgFloat64 error2 = e1 % e1;
@@ -344,7 +344,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
}
if (!validTetrahedrum) {
m_count = 0;
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return count;
}
@@ -353,7 +353,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
dgBigVector normal(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f));
for (dgInt32 i = 2; i < normalCount; i ++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
+ NEWTON_ASSERT(indexSV >= 0);
e2 = points[indexSV] - m_points[0];
normal = e1 * e2;
dgFloat64 error2 = sqrt(normal % normal);
@@ -367,7 +367,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
if (!validTetrahedrum) {
m_count = 0;
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return count;
}
@@ -399,7 +399,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
if (!validTetrahedrum) {
for (dgInt32 i = 3; i < normalCount; i ++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
+ NEWTON_ASSERT(indexSV >= 0);
//make sure the volume of the fist tetrahedral is no negative
e3 = points[indexSV] - m_points[0];
@@ -416,7 +416,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
if (!validTetrahedrum) {
// the points do not form a convex hull
m_count = 0;
- //_ASSERTE (0);
+ //NEWTON_ASSERT (0);
return count;
}
@@ -425,7 +425,7 @@ dgInt32 dgConvexHull3d::InitVertexArray(dgHullVertex *const points, const dgFloa
if (volume > dgFloat64(0.0f)) {
Swap(m_points[2], m_points[3]);
}
- _ASSERTE(TetrahedrumVolume(m_points[0], m_points[1], m_points[2], m_points[3]) < dgFloat64(0.0f));
+ NEWTON_ASSERT(TetrahedrumVolume(m_points[0], m_points[1], m_points[2], m_points[3]) < dgFloat64(0.0f));
return count;
}
@@ -440,9 +440,9 @@ dgFloat64 dgConvexHull3d::TetrahedrumVolume(const dgBigVector &p0, const dgBigVe
void dgConvexHull3d::TessellateTriangle(dgInt32 level, const dgVector &p0, const dgVector &p1, const dgVector &p2, dgInt32 &count, dgBigVector *const ouput, dgInt32 &start) const {
if (level) {
- _ASSERTE(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
dgVector p01(p0 + p1);
dgVector p12(p1 + p2);
dgVector p20(p2 + p0);
@@ -451,9 +451,9 @@ void dgConvexHull3d::TessellateTriangle(dgInt32 level, const dgVector &p0, const
p12 = p12.Scale(dgFloat32(1.0f) / dgSqrt(p12 % p12));
p20 = p20.Scale(dgFloat32(1.0f) / dgSqrt(p20 % p20));
- _ASSERTE(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
TessellateTriangle(level - 1, p0, p01, p20, count, ouput, start);
TessellateTriangle(level - 1, p1, p12, p01, count, ouput, start);
@@ -483,7 +483,7 @@ dgInt32 dgConvexHull3d::SupportVertex(dgAABBPointTree3d **const treePointer, con
index = i;
}
}
- _ASSERTE (index != -1);
+ NEWTON_ASSERT (index != -1);
return index;
*/
@@ -517,32 +517,32 @@ dgInt32 dgConvexHull3d::SupportVertex(dgAABBPointTree3d **const treePointer, con
aabbProjection[stack] = leftSupportDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_3D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_3D);
aabbProjection[stack] = rightSupportDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_3D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_3D);
} else {
aabbProjection[stack] = rightSupportDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_3D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_3D);
aabbProjection[stack] = leftSupportDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_3D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_3D);
}
} else {
dgAABBPointTree3dClump *const clump = (dgAABBPointTree3dClump *) me;
for (dgInt32 i = 0; i < clump->m_count; i ++) {
const dgHullVertex &p = points[clump->m_indices[i]];
- _ASSERTE(p.m_x >= clump->m_box[0].m_x);
- _ASSERTE(p.m_x <= clump->m_box[1].m_x);
- _ASSERTE(p.m_y >= clump->m_box[0].m_y);
- _ASSERTE(p.m_y <= clump->m_box[1].m_y);
- _ASSERTE(p.m_z >= clump->m_box[0].m_z);
- _ASSERTE(p.m_z <= clump->m_box[1].m_z);
+ NEWTON_ASSERT(p.m_x >= clump->m_box[0].m_x);
+ NEWTON_ASSERT(p.m_x <= clump->m_box[1].m_x);
+ NEWTON_ASSERT(p.m_y >= clump->m_box[0].m_y);
+ NEWTON_ASSERT(p.m_y <= clump->m_box[1].m_y);
+ NEWTON_ASSERT(p.m_z >= clump->m_box[0].m_z);
+ NEWTON_ASSERT(p.m_z <= clump->m_box[1].m_z);
if (!p.m_index) {
dgFloat64 dist = p % dir;
if (dist > maxProj) {
@@ -560,7 +560,7 @@ dgInt32 dgConvexHull3d::SupportVertex(dgAABBPointTree3d **const treePointer, con
dgAABBPointTree3d *const parent = clump->m_parent;
if (parent) {
dgAABBPointTree3d *const sibling = (parent->m_left != clump) ? parent->m_left : parent->m_right;
- _ASSERTE(sibling != clump);
+ NEWTON_ASSERT(sibling != clump);
dgAABBPointTree3d *const grandParent = parent->m_parent;
if (grandParent) {
sibling->m_parent = grandParent;
@@ -579,7 +579,7 @@ dgInt32 dgConvexHull3d::SupportVertex(dgAABBPointTree3d **const treePointer, con
}
}
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
return index;
}
@@ -717,9 +717,9 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
dgFloat64 dist = planeEquation.Evalue(p);
if ((dist >= distTol) && (face->Evalue(&m_points[0], p) > dgFloat64(0.0f))) {
- _ASSERTE(Sanity());
+ NEWTON_ASSERT(Sanity());
- _ASSERTE(faceNode);
+ NEWTON_ASSERT(faceNode);
stack[0] = faceNode;
dgInt32 stackIndex = 1;
@@ -733,22 +733,22 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
if (!stackFace->m_mark && (stackFace->Evalue(&m_points[0], p) > dgFloat64(0.0f))) {
#ifdef _DEBUG
for (dgInt32 i = 0; i < deletedCount; i ++) {
- _ASSERTE(deleteList[i] != stackNode);
+ NEWTON_ASSERT(deleteList[i] != stackNode);
}
#endif
deleteList[deletedCount] = stackNode;
deletedCount ++;
- _ASSERTE(deletedCount < dgInt32(deleteListPool.GetElementsCount()));
+ NEWTON_ASSERT(deletedCount < dgInt32(deleteListPool.GetElementsCount()));
stackFace->m_mark = 1;
for (dgInt32 i = 0; i < 3; i ++) {
dgListNode *const twinNode = (dgListNode *)stackFace->m_twin[i];
- _ASSERTE(twinNode);
+ NEWTON_ASSERT(twinNode);
dgConvexHull3DFace *const twinFace = &twinNode->GetInfo();
if (!twinFace->m_mark) {
stack[stackIndex] = twinNode;
stackIndex ++;
- _ASSERTE(stackIndex < dgInt32(stackPool.GetElementsCount()));
+ NEWTON_ASSERT(stackIndex < dgInt32(stackPool.GetElementsCount()));
}
}
}
@@ -762,7 +762,7 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
for (dgInt32 i = 0; i < deletedCount; i ++) {
dgListNode *const deleteNode = deleteList[i];
dgConvexHull3DFace *const deleteFace = &deleteNode->GetInfo();
- _ASSERTE(deleteFace->m_mark == 1);
+ NEWTON_ASSERT(deleteFace->m_mark == 1);
for (dgInt32 j0 = 0; j0 < 3; j0 ++) {
dgListNode *const twinNode = deleteFace->m_twin[j0];
dgConvexHull3DFace *const twinFace = &twinNode->GetInfo();
@@ -780,7 +780,7 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
}
coneList[newCount] = newNode;
newCount ++;
- _ASSERTE(newCount < dgInt32(coneListPool.GetElementsCount()));
+ NEWTON_ASSERT(newCount < dgInt32(coneListPool.GetElementsCount()));
}
}
}
@@ -788,11 +788,11 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
for (dgInt32 i = 0; i < newCount - 1; i ++) {
dgListNode *const nodeA = coneList[i];
dgConvexHull3DFace *const faceA = &nodeA->GetInfo();
- _ASSERTE(faceA->m_mark == 0);
+ NEWTON_ASSERT(faceA->m_mark == 0);
for (dgInt32 j = i + 1; j < newCount; j ++) {
dgListNode *const nodeB = coneList[j];
dgConvexHull3DFace *const faceB = &nodeB->GetInfo();
- _ASSERTE(faceB->m_mark == 0);
+ NEWTON_ASSERT(faceB->m_mark == 0);
if (faceA->m_index[2] == faceB->m_index[1]) {
faceA->m_twin[2] = nodeB;
faceB->m_twin[0] = nodeA;
@@ -803,7 +803,7 @@ void dgConvexHull3d::CalculateConvexHull(dgAABBPointTree3d *vertexTree, dgHullVe
for (dgInt32 j = i + 1; j < newCount; j ++) {
dgListNode *const nodeB = coneList[j];
dgConvexHull3DFace *const faceB = &nodeB->GetInfo();
- _ASSERTE(faceB->m_mark == 0);
+ NEWTON_ASSERT(faceB->m_mark == 0);
if (faceA->m_index[1] == faceB->m_index[2]) {
faceA->m_twin[0] = nodeB;
faceB->m_twin[2] = nodeA;
@@ -844,7 +844,7 @@ void dgConvexHull3d::CalculateVolumeAndSurfaceArea(dgFloat64 &volume, dgFloat64
areaAcc = sqrt(normal % normal);
volumeAcc += (p0 * p1) % p2;
}
- _ASSERTE(volumeAcc >= dgFloat64(0.0f));
+ NEWTON_ASSERT(volumeAcc >= dgFloat64(0.0f));
volume = volumeAcc;
surfaceArea = areaAcc;
}
@@ -912,7 +912,7 @@ dgFloat64 dgConvexHull3d::RayCastBruteForce(const dgBigVector &localP0, const dg
return dgFloat64(1.2f);
}
} else {
- _ASSERTE(D >= dgFloat64(0.0f));
+ NEWTON_ASSERT(D >= dgFloat64(0.0f));
tL = GetMin(tL, t);
if (tL < tE) {
return dgFloat64(1.2f);
@@ -941,7 +941,7 @@ public:
dgFloat64 dgConvexHull3d::RayCast(const dgBigVector &localP0, const dgBigVector &localP1, const dgConvexHull3DFace **firstFaceGuess) const {
//return RayCastBruteForce(localP0, localP1);
//dgFloat64 xxx = RayCastBruteForce(localP0, localP1);
-//_ASSERTE (xxx <= 1.0f);
+//NEWTON_ASSERT (xxx <= 1.0f);
m_mark ++;
const dgConvexHull3DFace *face = &GetFirst()->GetInfo();
if (firstFaceGuess && *firstFaceGuess) {
@@ -978,7 +978,7 @@ dgFloat64 dgConvexHull3d::RayCast(const dgBigVector &localP0, const dgBigVector
if (t0 > t1) {
#ifdef DG_SANITY_CHECK_RAYCAST
dgFloat64 t2 = RayCastBruteForce(localP0, localP1);
- _ASSERTE(fabs(1.2 - t2) < 1.0e-6f);
+ NEWTON_ASSERT(fabs(1.2 - t2) < 1.0e-6f);
#endif
return dgFloat64(1.2f);
}
@@ -1010,7 +1010,7 @@ dgFloat64 dgConvexHull3d::RayCast(const dgBigVector &localP0, const dgBigVector
if ((t0 >= dgFloat64(0.0f)) && (t0 <= dgFloat64(1.0f))) {
#ifdef DG_SANITY_CHECK_RAYCAST
dgFloat64 t2 = RayCastBruteForce(localP0, localP1);
- _ASSERTE(fabs(t0 - t2) < 1.0e-6f);
+ NEWTON_ASSERT(fabs(t0 - t2) < 1.0e-6f);
#endif
if (firstFaceGuess) {
*firstFaceGuess = heapFace;
@@ -1023,7 +1023,7 @@ dgFloat64 dgConvexHull3d::RayCast(const dgBigVector &localP0, const dgBigVector
#ifdef DG_SANITY_CHECK_RAYCAST
dgFloat64 t2 = RayCastBruteForce(localP0, localP1);
- _ASSERTE(fabs(1.2f - t2) < 1.0e-6f);
+ NEWTON_ASSERT(fabs(1.2f - t2) < 1.0e-6f);
#endif
return dgFloat64(1.2f);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
index 54adbbf2eeb..4634d5ca3c1 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.cpp
@@ -58,7 +58,7 @@ dgConvexHull4dTetraherum::dgTetrahedrumPlane::dgTetrahedrumPlane(
const dgBigVector &p3) :
dgBigVector(p1.Sub4(p0).CrossProduct4(p2.Sub4(p0), p3.Sub4(p0))) {
dgBigVector &me = *this;
-// _ASSERTE (me.DotProduct4(me) > dgFloat64 (1.0e-64f));
+// NEWTON_ASSERT (me.DotProduct4(me) > dgFloat64 (1.0e-64f));
dgFloat64 invMag2 = dgFloat32(0.0f);
// if (me.DotProduct4(me) > dgFloat64 (1.0e-64)) {
if (me.DotProduct4(me) > dgFloat64(1.0e-38)) {
@@ -126,7 +126,7 @@ void dgConvexHull4dTetraherum::Init(const dgHullVector *const points,
dgBigVector p3p0(points[v3].Sub4(points[v0]));
dgBigVector normal(p1p0.CrossProduct4(p2p0, p3p0));
dgFloat64 volume = normal.DotProduct4(normal);
- _ASSERTE(volume > dgFloat64(0.0f));
+ NEWTON_ASSERT(volume > dgFloat64(0.0f));
#endif
}
@@ -251,7 +251,7 @@ dgConvexHull4d::dgConvexHull4d(dgMemoryAllocator *const allocator,
count = InitVertexArray(&convexPoints[0], &points[0], vertexCloud, count);
if (m_count >= 4) {
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
// CalculateConvexHull (distTol);
}
@@ -298,9 +298,9 @@ void dgConvexHull4d::TessellateTriangle(dgInt32 level, const dgVector &p0,
const dgVector &p1, const dgVector &p2, dgInt32 &count,
dgBigVector *const ouput, dgInt32 &start) const {
if (level) {
- _ASSERTE(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
dgVector p01(p0 + p1);
dgVector p12(p1 + p2);
dgVector p20(p2 + p0);
@@ -309,9 +309,9 @@ void dgConvexHull4d::TessellateTriangle(dgInt32 level, const dgVector &p0,
p12 = p12.Scale(dgFloat32(1.0f) / dgSqrt(p12 % p12));
p20 = p20.Scale(dgFloat32(1.0f) / dgSqrt(p20 % p20));
- _ASSERTE(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
TessellateTriangle(level - 1, p0, p01, p20, count, ouput, start);
TessellateTriangle(level - 1, p1, p12, p01, count, ouput, start);
@@ -389,7 +389,7 @@ dgInt32 dgConvexHull4d::SupportVertex(dgAABBPointTree4d **const treePointer,
index = i;
}
}
- _ASSERTE (index != -1);
+ NEWTON_ASSERT (index != -1);
return index;
*/
@@ -427,34 +427,34 @@ dgInt32 dgConvexHull4d::SupportVertex(dgAABBPointTree4d **const treePointer,
aabbProjection[stack] = leftSupportDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_4D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_4D);
aabbProjection[stack] = rightSupportDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_4D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_4D);
} else {
aabbProjection[stack] = rightSupportDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_4D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_4D);
aabbProjection[stack] = leftSupportDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < DG_STACK_DEPTH_4D);
+ NEWTON_ASSERT(stack < DG_STACK_DEPTH_4D);
}
} else {
dgAABBPointTree4dClump *const clump = (dgAABBPointTree4dClump *) me;
for (dgInt32 i = 0; i < clump->m_count; i++) {
const dgHullVector &p = points[clump->m_indices[i]];
- _ASSERTE(p.m_x >= clump->m_box[0].m_x);
- _ASSERTE(p.m_x <= clump->m_box[1].m_x);
- _ASSERTE(p.m_y >= clump->m_box[0].m_y);
- _ASSERTE(p.m_y <= clump->m_box[1].m_y);
- _ASSERTE(p.m_z >= clump->m_box[0].m_z);
- _ASSERTE(p.m_z <= clump->m_box[1].m_z);
- _ASSERTE(p.m_w >= clump->m_box[0].m_w);
- _ASSERTE(p.m_w <= clump->m_box[1].m_w);
+ NEWTON_ASSERT(p.m_x >= clump->m_box[0].m_x);
+ NEWTON_ASSERT(p.m_x <= clump->m_box[1].m_x);
+ NEWTON_ASSERT(p.m_y >= clump->m_box[0].m_y);
+ NEWTON_ASSERT(p.m_y <= clump->m_box[1].m_y);
+ NEWTON_ASSERT(p.m_z >= clump->m_box[0].m_z);
+ NEWTON_ASSERT(p.m_z <= clump->m_box[1].m_z);
+ NEWTON_ASSERT(p.m_w >= clump->m_box[0].m_w);
+ NEWTON_ASSERT(p.m_w <= clump->m_box[1].m_w);
if (!p.m_mark) {
dgFloat64 dist = p.DotProduct4(dir);
if (dist > maxProj) {
@@ -473,7 +473,7 @@ dgInt32 dgConvexHull4d::SupportVertex(dgAABBPointTree4d **const treePointer,
if (parent) {
dgAABBPointTree4d *const sibling =
(parent->m_left != clump) ? parent->m_left : parent->m_right;
- _ASSERTE(sibling != clump);
+ NEWTON_ASSERT(sibling != clump);
dgAABBPointTree4d *const grandParent = parent->m_parent;
if (grandParent) {
sibling->m_parent = grandParent;
@@ -492,7 +492,7 @@ dgInt32 dgConvexHull4d::SupportVertex(dgAABBPointTree4d **const treePointer,
}
}
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
return index;
}
@@ -513,7 +513,7 @@ dgAABBPointTree4d *dgConvexHull4d::BuildTree(dgAABBPointTree4d *const parent,
dgInt8 **memoryPool, dgInt32 &maxMemSize) const {
dgAABBPointTree4d *tree = NULL;
- _ASSERTE(count);
+ NEWTON_ASSERT(count);
dgBigVector minP(dgFloat32(1.0e15f), dgFloat32(1.0e15f), dgFloat32(1.0e15f),
dgFloat32(1.0e15f));
dgBigVector maxP(-dgFloat32(1.0e15f), -dgFloat32(1.0e15f),
@@ -524,7 +524,7 @@ dgAABBPointTree4d *dgConvexHull4d::BuildTree(dgAABBPointTree4d *const parent,
new (*memoryPool) dgAABBPointTree4dClump;
*memoryPool += sizeof(dgAABBPointTree4dClump);
maxMemSize -= sizeof(dgAABBPointTree4dClump);
- _ASSERTE(maxMemSize >= 0);
+ NEWTON_ASSERT(maxMemSize >= 0);
clump->m_count = count;
for (dgInt32 i = 0; i < count; i++) {
@@ -615,10 +615,10 @@ dgAABBPointTree4d *dgConvexHull4d::BuildTree(dgAABBPointTree4d *const parent,
tree = new (*memoryPool) dgAABBPointTree4d;
*memoryPool += sizeof(dgAABBPointTree4d);
maxMemSize -= sizeof(dgAABBPointTree4d);
- _ASSERTE(maxMemSize >= 0);
+ NEWTON_ASSERT(maxMemSize >= 0);
- _ASSERTE(i0);
- _ASSERTE(count - i0);
+ NEWTON_ASSERT(i0);
+ NEWTON_ASSERT(count - i0);
tree->m_left = BuildTree(tree, points, i0, baseIndex, memoryPool,
maxMemSize);
@@ -626,7 +626,7 @@ dgAABBPointTree4d *dgConvexHull4d::BuildTree(dgAABBPointTree4d *const parent,
memoryPool, maxMemSize);
}
- _ASSERTE(tree);
+ NEWTON_ASSERT(tree);
tree->m_parent = parent;
tree->m_box[0] = minP
- dgBigVector(dgFloat64(1.0e-3f), dgFloat64(1.0e-3f), dgFloat64(1.0e-3f),
@@ -684,7 +684,7 @@ dgInt32 dgConvexHull4d::InitVertexArray(dgHullVector *const points,
dgFloat64(0.0f));
for (dgInt32 i = 1; i < normalCount; i++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
+ NEWTON_ASSERT(indexSV >= 0);
e1 = points[indexSV].Sub4(convexPoints[0]);
e1.m_w = dgFloat64(0.0f);
dgFloat64 error2 = e1.DotProduct4(e1);
@@ -709,8 +709,8 @@ dgInt32 dgConvexHull4d::InitVertexArray(dgHullVector *const points,
;
for (dgInt32 i = 2; i < normalCount; i++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
- _ASSERTE(indexSV < count);
+ NEWTON_ASSERT(indexSV >= 0);
+ NEWTON_ASSERT(indexSV < count);
e2 = points[indexSV].Sub4(convexPoints[0]);
e2.m_w = dgFloat64(0.0f);
dgFloat64 den = e2.DotProduct4(e2);
@@ -749,8 +749,8 @@ dgInt32 dgConvexHull4d::InitVertexArray(dgHullVector *const points,
;
for (dgInt32 i = 3; i < normalCount; i++) {
dgInt32 indexSV = SupportVertex(&tree, points, normalArray[i]);
- _ASSERTE(indexSV >= 0);
- _ASSERTE(indexSV < count);
+ NEWTON_ASSERT(indexSV >= 0);
+ NEWTON_ASSERT(indexSV < count);
e3 = points[indexSV].Sub4(convexPoints[0]);
e3.m_w = dgFloat64(0.0f);
@@ -897,7 +897,7 @@ void dgConvexHull4d::LinkSibling(dgListNode *node0, dgListNode *node1) const {
void dgConvexHull4d::InsertNewVertex(dgInt32 vertexIndex,
dgListNode *const frontFace, dgList<dgListNode *> &deletedFaces,
dgList<dgListNode *> &newFaces) {
- _ASSERTE(Sanity());
+ NEWTON_ASSERT(Sanity());
dgList<dgListNode *> stack(GetAllocator());
dgInt32 mark = IncMark();
@@ -915,7 +915,7 @@ void dgConvexHull4d::InsertNewVertex(dgInt32 vertexIndex,
for (dgList<dgListNode *>::dgListNode *deleteNode =
deletedFaces.GetFirst(); deleteNode; deleteNode =
deleteNode->GetNext()) {
- _ASSERTE(deleteNode->GetInfo() != node);
+ NEWTON_ASSERT(deleteNode->GetInfo() != node);
}
#endif
deletedFaces.Append(node);
@@ -923,7 +923,7 @@ void dgConvexHull4d::InsertNewVertex(dgInt32 vertexIndex,
face->SetMark(mark);
for (dgInt32 i = 0; i < 4; i++) {
dgListNode *const twinNode = (dgListNode *) face->m_faces[i].m_twin;
- _ASSERTE(twinNode);
+ NEWTON_ASSERT(twinNode);
dgConvexHull4dTetraherum *const twinFace = &twinNode->GetInfo();
if (twinFace->GetMark() != mark) {
@@ -938,7 +938,7 @@ void dgConvexHull4d::InsertNewVertex(dgInt32 vertexIndex,
deleteNode; deleteNode = deleteNode->GetNext()) {
dgListNode *const deleteTetraNode = deleteNode->GetInfo();
dgConvexHull4dTetraherum *const deletedTetra = &deleteTetraNode->GetInfo();
- _ASSERTE(deletedTetra->GetMark() == mark);
+ NEWTON_ASSERT(deletedTetra->GetMark() == mark);
for (dgInt32 i = 0; i < 4; i++) {
dgListNode *const twinNode = deletedTetra->m_faces[i].m_twin;
dgConvexHull4dTetraherum *const twinTetra = &twinNode->GetInfo();
diff --git a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.h b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.h
index b13872dc88c..77668857675 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgConvexHull4d.h
@@ -147,15 +147,15 @@ inline dgInt32 dgConvexHull4d::GetVertexCount() const {
}
inline dgInt32 dgConvexHull4d::GetVertexIndex(dgInt32 index) const {
- _ASSERTE(index >= 0);
- _ASSERTE(index < m_count);
+ NEWTON_ASSERT(index >= 0);
+ NEWTON_ASSERT(index < m_count);
return m_points[index].m_index;
}
inline const dgBigVector &dgConvexHull4d::GetVertex(dgInt32 index) const {
- _ASSERTE(index >= 0);
- _ASSERTE(index < m_count);
+ NEWTON_ASSERT(index >= 0);
+ NEWTON_ASSERT(index < m_count);
// return dgVector (dgFloat32 (m_points[index].m_x), dgFloat32 (m_points[index].m_y), dgFloat32 (m_points[index].m_z), dgFloat32 (m_points[index].m_w));
return m_points[index];
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp b/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
index 37a112786e9..290eadc3b98 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgDelaunayTetrahedralization.cpp
@@ -71,9 +71,9 @@ dgDelaunayTetrahedralization::dgDelaunayTetrahedralization(
q.m_y += dgFloat64(1.0e-3f);
q.m_z += dgFloat64(1.0e-3f);
index = AddVertex(q);
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
}
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
// m_points[index] = points[i];
m_points[index].m_index = i;
}
@@ -89,7 +89,7 @@ dgDelaunayTetrahedralization::dgDelaunayTetrahedralization(
points[0].m_z += dgFloat64(1.0e-0f);
points[0].m_w = points[0].m_x * points[0].m_x + points[0].m_y * points[0].m_y + points[0].m_z * points[0].m_z;
BuildHull(allocator, &pool[0], oldCount, distTol);
- _ASSERTE(oldCount == m_count);
+ NEWTON_ASSERT(oldCount == m_count);
// restore the old point
//points[0].m_w = points[0].m_x * points[0].m_x + points[0].m_y * points[0].m_y + points[0].m_z * points[0].m_z;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgGeneralMatrix.h b/engines/hpl1/engine/libraries/newton/core/dgGeneralMatrix.h
index 76eeaa54cc7..150caf355f3 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgGeneralMatrix.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgGeneralMatrix.h
@@ -105,8 +105,8 @@ template<class T>
dgGeneralMatrix<T>::dgGeneralMatrix(dgInt32 row, dgInt32 column) {
dgInt32 i;
dgInt32 columnPad;
- _ASSERTE(row > 0);
- _ASSERTE(column > 0);
+ NEWTON_ASSERT(row > 0);
+ NEWTON_ASSERT(column > 0);
m_rowCount = row;
m_colCount = column;
@@ -154,7 +154,7 @@ dgGeneralMatrix<T>::dgGeneralMatrix(
m_colCount = column;
- _ASSERTE((((dgUnsigned32) elemBuffer) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) elemBuffer) & 0x0f) == 0);
m_buffer = elemBuffer;
columnPad = ((m_colCount * sizeof(T) + 0x0f) & -0x0f) / sizeof(T);
@@ -176,7 +176,7 @@ dgGeneralMatrix<T>::dgGeneralMatrix(
m_rowCount = src.m_rowCount;
m_colCount = src.m_colCount;
- _ASSERTE((((dgUnsigned32) elemBuffer) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) elemBuffer) & 0x0f) == 0);
m_buffer = elemBuffer;
columnPad = ((m_colCount * sizeof(T) + 0x0f) & -0x0f) / sizeof(T);
@@ -221,15 +221,15 @@ void dgGeneralMatrix<T>::Trace() const {
template<class T>
dgGeneralVector<T> &dgGeneralMatrix<T>::operator[](dgInt32 i) {
- _ASSERTE(i < m_rowCount);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < m_rowCount);
+ NEWTON_ASSERT(i >= 0);
return m_rows[i];
}
template<class T>
const dgGeneralVector<T> &dgGeneralMatrix<T>::operator[](dgInt32 i) const {
- _ASSERTE(i < m_rowCount);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < m_rowCount);
+ NEWTON_ASSERT(i >= 0);
return m_rows[i];
}
@@ -258,7 +258,7 @@ void dgGeneralMatrix<T>::Identity() {
// dgInt32 i;
// dgInt32 j;
//
-// _ASSERTE (m_rowCount ==
+// NEWTON_ASSERT (m_rowCount ==
// dgGeneralMatrix<T>& me = *this;
// for (i = 0; i < m_rowCount; i ++) {
// for (j = i + 1; j < m_rowCount; j ++) {
@@ -285,7 +285,7 @@ void dgGeneralMatrix<T>::GaussianPivotStep(
T num(me[pivotRow][pivotCol]);
if (T(dgAbsf(num)) > tol) {
T den(me[srcRow][pivotCol]);
- _ASSERTE(T(dgAbsf(den)) > T(0.0f));
+ NEWTON_ASSERT(T(dgAbsf(den)) > T(0.0f));
#ifdef DG_COUNT_FLOAT_OPS
dgGeneralVector<T>::m_floatsOp += 2;
@@ -300,7 +300,7 @@ void dgGeneralMatrix<T>::GaussianPivotStep(
//template<class T>
//void dgGeneralMatrix<T>::Inverse (dgGeneralMatrix& inverseOut)
//{
-// _ASSERTE (m_colCount == m_rowCount);
+// NEWTON_ASSERT (m_colCount == m_rowCount);
//}
@@ -312,9 +312,9 @@ void dgGeneralMatrix<T>::VectorTimeMatrix(const dgGeneralVector<T> &v, dgGeneral
T *outMem;
const T *inMem;
- _ASSERTE(&v != &out);
- _ASSERTE(m_rowCount == v.m_colCount);
- _ASSERTE(m_colCount == out.m_colCount);
+ NEWTON_ASSERT(&v != &out);
+ NEWTON_ASSERT(m_rowCount == v.m_colCount);
+ NEWTON_ASSERT(m_colCount == out.m_colCount);
inMem = &v[0];
outMem = &out[0];
@@ -340,9 +340,9 @@ template<class T>
void dgGeneralMatrix<T>::MatrixTimeVectorTranspose(const dgGeneralVector<T> &v, dgGeneralVector<T> &out) {
dgInt32 i;
- _ASSERTE(&v != &out);
- _ASSERTE(m_rowCount == out.m_colCount);
- _ASSERTE(m_colCount == v.m_colCount);
+ NEWTON_ASSERT(&v != &out);
+ NEWTON_ASSERT(m_rowCount == out.m_colCount);
+ NEWTON_ASSERT(m_colCount == v.m_colCount);
for (i = 0; i < m_rowCount; i ++) {
out[i] = v.DotProduct(m_rows[i]);
@@ -358,11 +358,11 @@ void dgGeneralMatrix<T>::MatrixTimeMatrix(const dgGeneralMatrix<T> &A, const dgG
T *out;
T *rowA;
- _ASSERTE(m_rowCount == A.m_rowCount);
- _ASSERTE(m_colCount == B.m_colCount);
- _ASSERTE(A.m_colCount == B.m_rowCount);
+ NEWTON_ASSERT(m_rowCount == A.m_rowCount);
+ NEWTON_ASSERT(m_colCount == B.m_colCount);
+ NEWTON_ASSERT(A.m_colCount == B.m_rowCount);
- _ASSERTE(this != &A);
+ NEWTON_ASSERT(this != &A);
count = A.m_colCount;
for (i = 0; i < m_rowCount; i ++) {
@@ -397,12 +397,12 @@ void dgGeneralMatrix<T>::MatrixTimeMatrixTranspose(const dgGeneralMatrix<T> &A,
T *rowA;
T *rowB;
- _ASSERTE(m_rowCount == A.m_rowCount);
- _ASSERTE(m_colCount == Bt.m_rowCount);
- _ASSERTE(A.m_colCount == Bt.m_colCount);
+ NEWTON_ASSERT(m_rowCount == A.m_rowCount);
+ NEWTON_ASSERT(m_colCount == Bt.m_rowCount);
+ NEWTON_ASSERT(A.m_colCount == Bt.m_colCount);
- _ASSERTE(this != &A);
- _ASSERTE(this != &Bt);
+ NEWTON_ASSERT(this != &A);
+ NEWTON_ASSERT(this != &Bt);
count = A.m_colCount;
for (i = 0; i < m_rowCount; i ++) {
@@ -439,8 +439,8 @@ bool dgGeneralMatrix<T>::Solve(dgGeneralVector<T> &b, T tol) {
T *rowI;
T *rowK;
- _ASSERTE(m_rowCount == m_colCount);
- _ASSERTE(b.m_colCount == m_colCount);
+ NEWTON_ASSERT(m_rowCount == m_colCount);
+ NEWTON_ASSERT(b.m_colCount == m_colCount);
B = &b[0];
// convert to upper triangular matrix by applying gauss pivoting
@@ -506,21 +506,21 @@ bool dgGeneralMatrix<T>::Solve(dgGeneralVector<T> &b, T tol) {
template<class T>
void dgGeneralMatrix<T>::SwapRows(dgInt32 i, dgInt32 j) {
- _ASSERTE(i >= 0);
- _ASSERTE(j >= 0);
- _ASSERTE(i < m_rowCount);
- _ASSERTE(j < m_rowCount);
- _ASSERTE(j != i);
+ NEWTON_ASSERT(i >= 0);
+ NEWTON_ASSERT(j >= 0);
+ NEWTON_ASSERT(i < m_rowCount);
+ NEWTON_ASSERT(j < m_rowCount);
+ NEWTON_ASSERT(j != i);
Swap(m_rows[i].m_columns, m_rows[j].m_columns);
}
template<class T>
void dgGeneralMatrix<T>::SwapColumns(dgInt32 i, dgInt32 j) {
dgInt32 k;
- _ASSERTE(i >= 0);
- _ASSERTE(j >= 0);
- _ASSERTE(i < m_colCount);
- _ASSERTE(j < m_colCount);
+ NEWTON_ASSERT(i >= 0);
+ NEWTON_ASSERT(j >= 0);
+ NEWTON_ASSERT(i < m_colCount);
+ NEWTON_ASSERT(j < m_colCount);
for (k = 0; k < m_colCount; k ++) {
Swap(m_rows[k][i], m_rows[k][j]);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgGeneralVector.h b/engines/hpl1/engine/libraries/newton/core/dgGeneralVector.h
index 28d1fc199c7..0462a24e1ee 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgGeneralVector.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgGeneralVector.h
@@ -97,11 +97,11 @@ dgGeneralVector<T>::dgGeneralVector() {
template<class T>
dgGeneralVector<T>::dgGeneralVector(dgInt32 size) {
- _ASSERTE(size > 0);
+ NEWTON_ASSERT(size > 0);
m_ownMemory = true;
m_colCount = size;
m_columns = new T[size];
- _ASSERTE((((dgUnsigned32) m_columns) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
}
template<class T>
@@ -109,7 +109,7 @@ dgGeneralVector<T>::dgGeneralVector(dgInt32 size, T *mem) {
m_ownMemory = false;
m_colCount = size;
m_columns = mem;
- _ASSERTE((((dgUnsigned32) m_columns) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
}
template<class T>
@@ -117,7 +117,7 @@ dgGeneralVector<T>::dgGeneralVector(const dgGeneralVector<T> &src) {
m_ownMemory = true;
m_colCount = src.m_colCount;
m_columns = new T[m_colCount];
- _ASSERTE((((dgUnsigned32) m_columns) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
Copy(src);
}
@@ -127,7 +127,7 @@ dgGeneralVector<T>::dgGeneralVector(const dgGeneralVector<T> &src, T *mem) {
m_ownMemory = false;
m_colCount = src.m_colCount;
m_columns = mem;
- _ASSERTE((((dgUnsigned32) m_columns) & 0x0f) == 0);
+ NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
Copy(src);
}
@@ -178,15 +178,15 @@ void dgGeneralVector<T>::Trace() const {
template<class T>
T &dgGeneralVector<T>::operator[](dgInt32 i) {
- _ASSERTE(i < m_colCount);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < m_colCount);
+ NEWTON_ASSERT(i >= 0);
return m_columns[i];
}
template<class T>
const T &dgGeneralVector<T>::operator[](dgInt32 i) const {
- _ASSERTE(i < m_colCount);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < m_colCount);
+ NEWTON_ASSERT(i >= 0);
return m_columns[i];
}
@@ -201,7 +201,7 @@ template<class T>
T dgGeneralVector<T>::DotProduct(const dgGeneralVector<T> &A) const {
dgInt32 i;
- _ASSERTE(m_colCount == A.m_colCount);
+ NEWTON_ASSERT(m_colCount == A.m_colCount);
T val(0.0);
for (i = 0; i < m_colCount; i ++) {
val = val + m_columns[i] * A.m_columns[i];
@@ -234,7 +234,7 @@ template<class T>
void dgGeneralVector<T>::Copy(const dgGeneralVector<T> &src) {
dgInt32 i;
- _ASSERTE(m_colCount == src.m_colCount);
+ NEWTON_ASSERT(m_colCount == src.m_colCount);
for (i = 0; i < m_colCount; i ++) {
m_columns[i] = src.m_columns[i];
}
@@ -288,8 +288,8 @@ template<class T>
void dgGeneralVector<T>::LinearCombine(T scale, const dgGeneralVector<T> &A, const dgGeneralVector<T> &B) {
dgInt32 i;
- _ASSERTE(A.m_colCount == m_colCount);
- _ASSERTE(B.m_colCount == m_colCount);
+ NEWTON_ASSERT(A.m_colCount == m_colCount);
+ NEWTON_ASSERT(B.m_colCount == m_colCount);
for (i = 0; i < m_colCount; i ++) {
m_columns[i] = A.m_columns[i] * scale + B.m_columns[i];
}
@@ -305,7 +305,7 @@ template<class T>
void dgGeneralVector<T>::operator+= (const dgGeneralVector<T> &A) {
dgInt32 i;
- _ASSERTE(A.m_colCount == m_colCount);
+ NEWTON_ASSERT(A.m_colCount == m_colCount);
for (i = 0; i < m_colCount; i ++) {
m_columns[i] += A.m_columns[i];
}
@@ -320,7 +320,7 @@ template<class T>
void dgGeneralVector<T>::operator-= (const dgGeneralVector<T> &A) {
dgInt32 i;
- _ASSERTE(A.m_colCount == m_colCount);
+ NEWTON_ASSERT(A.m_colCount == m_colCount);
for (i = 0; i < m_colCount; i ++) {
m_columns[i] -= A.m_columns[i];
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgGoogol.cpp b/engines/hpl1/engine/libraries/newton/core/dgGoogol.cpp
index 5b4e0dbf101..239e769e228 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgGoogol.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgGoogol.cpp
@@ -39,7 +39,7 @@ dgGoogol::dgGoogol(dgFloat64 value) :
m_mantissa[0] = (dgInt64(dgFloat64(dgUnsigned64(1) << 62) * mantissa));
// it looks like GCC have problems with this
- _ASSERTE(m_mantissa[0] >= 0);
+ NEWTON_ASSERT(m_mantissa[0] >= 0);
}
dgGoogol::~dgGoogol(void) {
@@ -116,7 +116,7 @@ dgInt32 dgGoogol::LeadinZeros(dgUnsigned64 a) const {
}
dgInt32 dgGoogol::NormalizeMantissa(dgUnsigned64 *const mantissa) const {
- _ASSERTE(dgInt64(mantissa[0]) >= 0);
+ NEWTON_ASSERT(dgInt64(mantissa[0]) >= 0);
dgInt32 bits = 0;
if (dgInt64(mantissa[0] * 2) < 0) {
@@ -229,7 +229,7 @@ void dgGoogol::ExtendeMultiply(dgUnsigned64 a, dgUnsigned64 b,
dgUnsigned64 ml = m << 32;
dgUnsigned64 ll = l + ml;
dgUnsigned64 mh = (m >> 32) + CheckCarrier(l, ml);
- _ASSERTE((mh & ~0xffffffff) == 0);
+ NEWTON_ASSERT((mh & ~0xffffffff) == 0);
dgUnsigned64 hh = h + mh;
@@ -246,7 +246,7 @@ void dgGoogol::ScaleMantissa(dgUnsigned64 *const dst, dgUnsigned64 scale) const
ExtendeMultiply(scale, m_mantissa[i], high, low);
dgUnsigned64 acc = low + carrier;
carrier = CheckCarrier(low, carrier);
- _ASSERTE(CheckCarrier(carrier, high) == 0);
+ NEWTON_ASSERT(CheckCarrier(carrier, high) == 0);
carrier += high;
dst[i + 1] = acc;
} else {
@@ -259,8 +259,8 @@ void dgGoogol::ScaleMantissa(dgUnsigned64 *const dst, dgUnsigned64 scale) const
}
dgGoogol dgGoogol::operator*(const dgGoogol &A) const {
- _ASSERTE(dgInt64(m_mantissa[0]) >= 0);
- _ASSERTE(dgInt64(A.m_mantissa[0]) >= 0);
+ NEWTON_ASSERT(dgInt64(m_mantissa[0]) >= 0);
+ NEWTON_ASSERT(dgInt64(A.m_mantissa[0]) >= 0);
if (m_mantissa[0] && A.m_mantissa[0]) {
dgUnsigned64 mantissaAcc[DG_GOOGOL_SIZE * 2];
@@ -322,7 +322,7 @@ dgGoogol dgGoogol::operator/(const dgGoogol &A) const {
test = (copy[i] == tmp.m_mantissa[i]);
}
} while (!test || (passes > (2 * DG_GOOGOL_SIZE)));
- _ASSERTE(
+ NEWTON_ASSERT(
passes <= (2 * DG_GOOGOL_SIZE));
return (*this) * tmp;
}
@@ -355,7 +355,7 @@ dgGoogol dgGoogol::Floor() const {
dgUnsigned64 mask = (-1LL) << (64 - bits);
tmp.m_mantissa[start] &= mask;
if (m_sign) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
return tmp;
diff --git a/engines/hpl1/engine/libraries/newton/core/dgHeap.h b/engines/hpl1/engine/libraries/newton/core/dgHeap.h
index 4f5a5e1c31e..75f2ffadf8a 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgHeap.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgHeap.h
@@ -115,7 +115,7 @@ dgHeapBase<OBJECT, KEY>::dgHeapBase(dgInt32 maxElements, dgMemoryAllocator *cons
template <class OBJECT, class KEY>
dgHeapBase<OBJECT, KEY>::dgHeapBase(const void *const buffer, dgInt32 sizeInBytes) {
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// m_allocated = false;
m_allocator = NULL;
m_pool = (RECORD *)Common::remove_const<void * const>::type(buffer);
@@ -172,7 +172,7 @@ dgInt32 dgHeapBase<OBJECT, KEY>::Find(OBJECT &obj) {
// ex: m_curCount < 32
// this will be change to a binary search in the heap should the
// the size of the heap get larger than 32
- // _ASSERTE (m_curCount <= 32);
+ // NEWTON_ASSERT (m_curCount <= 32);
for (dgInt32 i = 0; i < m_curCount; i ++) {
if (m_pool[i].obj == obj) {
return i;
@@ -187,7 +187,7 @@ dgInt32 dgHeapBase<OBJECT, KEY>::Find(KEY key) {
// ex: m_curCount < 32
// this will be change to a binary search in the heap shoud the
// the size of the heap get larger than 32
- _ASSERTE(m_curCount <= 32);
+ NEWTON_ASSERT(m_curCount <= 32);
for (dgInt32 i = 0; i < m_curCount; i ++) {
if (m_pool[i].m_key == key) {
return i;
@@ -199,7 +199,7 @@ dgInt32 dgHeapBase<OBJECT, KEY>::Find(KEY key) {
template <class OBJECT, class KEY>
const OBJECT &dgHeapBase<OBJECT, KEY>::operator[](dgInt32 i) const {
- _ASSERTE(i <= m_curCount);
+ NEWTON_ASSERT(i <= m_curCount);
return m_pool[i].m_obj;
}
@@ -225,10 +225,10 @@ void dgDownHeap<OBJECT, KEY>::Push(OBJECT &obj, KEY key) {
dgInt32 i;
dgInt32 j;
#ifdef _DEBUG
-// _ASSERTE (m_curCount < m_maxCount);
+// NEWTON_ASSERT (m_curCount < m_maxCount);
dgInt32 cc = dgHeapBase<OBJECT, KEY>::m_curCount;
dgInt32 cm = dgHeapBase<OBJECT, KEY>::m_maxCount;
- _ASSERTE(cc < cm);
+ NEWTON_ASSERT(cc < cm);
#endif
dgHeapBase<OBJECT, KEY>::m_curCount ++;
@@ -240,12 +240,12 @@ void dgDownHeap<OBJECT, KEY>::Push(OBJECT &obj, KEY key) {
}
dgHeapBase<OBJECT, KEY>::m_pool[i - 1] = dgHeapBase<OBJECT, KEY>::m_pool[j - 1];
}
- _ASSERTE(i);
+ NEWTON_ASSERT(i);
dgHeapBase<OBJECT, KEY>::m_pool[i - 1].m_key = key;
dgHeapBase<OBJECT, KEY>::m_pool[i - 1].m_obj = obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -272,7 +272,7 @@ void dgDownHeap<OBJECT, KEY>::Remove(dgInt32 index) {
dgHeapBase<OBJECT, KEY>::m_pool[k - 1].m_obj = dgHeapBase<OBJECT, KEY>::m_pool[dgHeapBase<OBJECT, KEY>::m_curCount].m_obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -299,7 +299,7 @@ void dgDownHeap<OBJECT, KEY>::Pop() {
dgHeapBase<OBJECT, KEY>::m_pool[k - 1].m_obj = dgHeapBase<OBJECT, KEY>::m_pool[dgHeapBase<OBJECT, KEY>::m_curCount].m_obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -331,7 +331,7 @@ void dgDownHeap<OBJECT, KEY>::Sort() {
dgHeapBase<OBJECT, KEY>::m_pool[count - i - 1].m_obj = obj;
}
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -395,10 +395,10 @@ void dgUpHeap<OBJECT, KEY>::Push(OBJECT &obj, KEY key) {
dgInt32 j;
#ifdef _DEBUG
- // _ASSERTE (m_curCount < m_maxCount);
+ // NEWTON_ASSERT (m_curCount < m_maxCount);
dgInt32 cc = dgHeapBase<OBJECT, KEY>::m_curCount;
dgInt32 cm = dgHeapBase<OBJECT, KEY>::m_maxCount;
- _ASSERTE(cc < cm);
+ NEWTON_ASSERT(cc < cm);
#endif
dgHeapBase<OBJECT, KEY>::m_curCount ++;
@@ -409,12 +409,12 @@ void dgUpHeap<OBJECT, KEY>::Push(OBJECT &obj, KEY key) {
}
dgHeapBase<OBJECT, KEY>::m_pool[i - 1] = dgHeapBase<OBJECT, KEY>::m_pool[j - 1];
}
- _ASSERTE(i);
+ NEWTON_ASSERT(i);
dgHeapBase<OBJECT, KEY>::m_pool[i - 1].m_key = key;
dgHeapBase<OBJECT, KEY>::m_pool[i - 1].m_obj = obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -444,7 +444,7 @@ void dgUpHeap<OBJECT, KEY>::Sort() {
dgHeapBase<OBJECT, KEY>::m_pool[count - i - 1].m_obj = obj;
}
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -471,7 +471,7 @@ void dgUpHeap<OBJECT, KEY>::Remove(dgInt32 index) {
dgHeapBase<OBJECT, KEY>::m_pool[k - 1].m_obj = dgHeapBase<OBJECT, KEY>::m_pool[dgHeapBase<OBJECT, KEY>::m_curCount].m_obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -498,7 +498,7 @@ void dgUpHeap<OBJECT, KEY>::Pop() {
dgHeapBase<OBJECT, KEY>::m_pool[k - 1].m_obj = dgHeapBase<OBJECT, KEY>::m_pool[dgHeapBase<OBJECT, KEY>::m_curCount].m_obj;
#ifdef DG_HEAP_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgIntersections.cpp b/engines/hpl1/engine/libraries/newton/core/dgIntersections.cpp
index 6622f763b9a..03a2d7cd2c0 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgIntersections.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgIntersections.cpp
@@ -151,7 +151,7 @@ dgFloat32 dgFastRayTest::PolygonIntersectSimd(const dgVector &normal,
/*
dgFloatSign test;
- _ASSERTE (m_p0.m_w == m_p1.m_w);
+ NEWTON_ASSERT (m_p0.m_w == m_p1.m_w);
simd_type dist = simd_mul_v ((simd_type&)normal, (simd_type&)m_diff);
dist = simd_add_s (dist, simd_permut_v(dist, dist, PURMUT_MASK(3, 2, 1, 2)));
@@ -209,8 +209,8 @@ dgFloat32 dgFastRayTest::PolygonIntersectSimd(const dgVector &normal,
if (test.m_integer.m_iVal) {
dgFloat32 tOut;
simd_store_s (simd_div_s(num, dist), &tOut);
- _ASSERTE (tOut >= dgFloat32 (0.0f));
- _ASSERTE (tOut <= dgFloat32 (1.0f));
+ NEWTON_ASSERT (tOut >= dgFloat32 (0.0f));
+ NEWTON_ASSERT (tOut <= dgFloat32 (1.0f));
return tOut;
}
p0v1 = p0v2;
@@ -220,7 +220,7 @@ dgFloat32 dgFastRayTest::PolygonIntersectSimd(const dgVector &normal,
return 1.2f;
*/
- _ASSERTE(m_p0.m_w == m_p1.m_w);
+ NEWTON_ASSERT(m_p0.m_w == m_p1.m_w);
dgFloat32 dist = normal % m_diff;
if (dist < m_dirError) {
@@ -306,8 +306,8 @@ dgFloat32 dgFastRayTest::PolygonIntersectSimd(const dgVector &normal,
//the line is to the left of all the polygon edges,
//then the intersection is the point we the line intersect the plane of the polygon
tOut = tOut / dist;
- _ASSERTE(tOut >= dgFloat32(0.0f));
- _ASSERTE(tOut <= dgFloat32(1.0f));
+ NEWTON_ASSERT(tOut >= dgFloat32(0.0f));
+ NEWTON_ASSERT(tOut <= dgFloat32(1.0f));
return tOut;
}
}
@@ -319,7 +319,7 @@ dgFloat32 dgFastRayTest::PolygonIntersectSimd(const dgVector &normal,
dgFloat32 dgFastRayTest::PolygonIntersect(const dgVector &normal, const dgFloat32 *const polygon, dgInt32 strideInBytes, const dgInt32 *const indexArray, dgInt32 indexCount) const {
- _ASSERTE(m_p0.m_w == m_p1.m_w);
+ NEWTON_ASSERT(m_p0.m_w == m_p1.m_w);
dgFloat32 dist = normal % m_diff;
if (dist < m_dirError) {
@@ -348,8 +348,8 @@ dgFloat32 dgFastRayTest::PolygonIntersect(const dgVector &normal, const dgFloat3
//the line is to the left of all the polygon edges,
//then the intersection is the point we the line intersect the plane of the polygon
tOut = tOut / dist;
- _ASSERTE(tOut >= dgFloat32(0.0f));
- _ASSERTE(tOut <= dgFloat32(1.0f));
+ NEWTON_ASSERT(tOut >= dgFloat32(0.0f));
+ NEWTON_ASSERT(tOut <= dgFloat32(1.0f));
return tOut;
}
}
@@ -509,8 +509,8 @@ dgVector dgPointToTriangleDistance(const dgVector &point, const dgVector &p0,
if ((vc <= dgFloat32(0.0f)) && (alpha1 >= dgFloat32(0.0f))
&& (alpha3 <= dgFloat32(0.0f))) {
dgFloat32 t = alpha1 / (alpha1 - alpha3);
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p0 + p10.Scale(t);
}
@@ -525,8 +525,8 @@ dgVector dgPointToTriangleDistance(const dgVector &point, const dgVector &p0,
if ((vb <= dgFloat32(0.0f)) && (alpha2 >= dgFloat32(0.0f))
&& (alpha6 <= dgFloat32(0.0f))) {
dgFloat32 t = alpha2 / (alpha2 - alpha6);
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p0 + p20.Scale(t);
}
@@ -534,18 +534,18 @@ dgVector dgPointToTriangleDistance(const dgVector &point, const dgVector &p0,
if ((va <= dgFloat32(0.0f)) && ((alpha4 - alpha3) >= dgFloat32(0.0f))
&& ((alpha5 - alpha6) >= dgFloat32(0.0f))) {
dgFloat32 t = (alpha4 - alpha3) / ((alpha4 - alpha3) + (alpha5 - alpha6));
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p1 + (p2 - p1).Scale(t);
}
dgFloat32 den = float(dgFloat32(1.0f)) / (va + vb + vc);
dgFloat32 t = vb * den;
dgFloat32 s = vc * den;
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(s >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
- _ASSERTE(s <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(s >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(s <= dgFloat32(1.0f));
return p0 + p10.Scale(t) + p20.Scale(s);
}
@@ -573,8 +573,8 @@ dgBigVector dgPointToTriangleDistance(const dgBigVector &point,
if ((vc <= dgFloat64(0.0f)) && (alpha1 >= dgFloat64(0.0f))
&& (alpha3 <= dgFloat64(0.0f))) {
dgFloat64 t = alpha1 / (alpha1 - alpha3);
- _ASSERTE(t >= dgFloat64(0.0f));
- _ASSERTE(t <= dgFloat64(1.0f));
+ NEWTON_ASSERT(t >= dgFloat64(0.0f));
+ NEWTON_ASSERT(t <= dgFloat64(1.0f));
return p0 + p10.Scale(t);
}
@@ -589,8 +589,8 @@ dgBigVector dgPointToTriangleDistance(const dgBigVector &point,
if ((vb <= dgFloat64(0.0f)) && (alpha2 >= dgFloat64(0.0f))
&& (alpha6 <= dgFloat64(0.0f))) {
dgFloat64 t = alpha2 / (alpha2 - alpha6);
- _ASSERTE(t >= dgFloat64(0.0f));
- _ASSERTE(t <= dgFloat64(1.0f));
+ NEWTON_ASSERT(t >= dgFloat64(0.0f));
+ NEWTON_ASSERT(t <= dgFloat64(1.0f));
return p0 + p20.Scale(t);
}
@@ -598,18 +598,18 @@ dgBigVector dgPointToTriangleDistance(const dgBigVector &point,
if ((va <= dgFloat64(0.0f)) && ((alpha4 - alpha3) >= dgFloat64(0.0f))
&& ((alpha5 - alpha6) >= dgFloat64(0.0f))) {
dgFloat64 t = (alpha4 - alpha3) / ((alpha4 - alpha3) + (alpha5 - alpha6));
- _ASSERTE(t >= dgFloat64(0.0f));
- _ASSERTE(t <= dgFloat64(1.0f));
+ NEWTON_ASSERT(t >= dgFloat64(0.0f));
+ NEWTON_ASSERT(t <= dgFloat64(1.0f));
return p1 + (p2 - p1).Scale(t);
}
dgFloat64 den = float(dgFloat64(1.0f)) / (va + vb + vc);
dgFloat64 t = vb * den;
dgFloat64 s = vc * den;
- _ASSERTE(t >= dgFloat64(0.0f));
- _ASSERTE(s >= dgFloat64(0.0f));
- _ASSERTE(t <= dgFloat64(1.0f));
- _ASSERTE(s <= dgFloat64(1.0f));
+ NEWTON_ASSERT(t >= dgFloat64(0.0f));
+ NEWTON_ASSERT(s >= dgFloat64(0.0f));
+ NEWTON_ASSERT(t <= dgFloat64(1.0f));
+ NEWTON_ASSERT(s <= dgFloat64(1.0f));
return p0 + p10.Scale(t) + p20.Scale(s);
}
@@ -625,7 +625,7 @@ bool dgApi dgPointToPolygonDistance(const dgVector &p,
// dgFloat32 dist;
// dgFloat32 minDist;
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
dgInt32 stride = dgInt32(strideInBytes / sizeof(dgFloat32));
dgInt32 i0 = indexArray[0] * stride;
@@ -699,7 +699,7 @@ dgBigVector LineTriangleIntersection(const dgBigVector &p0,
dgBigVector testpoint(
A.Scale(val0 / den) + B.Scale(val1 / den) + C.Scale(val2 / den));
dgFloat64 volume = ((B - A) * (C - A)) % (testpoint - A);
- _ASSERTE(fabs(volume) < dgFloat64(1.0e-12f));
+ NEWTON_ASSERT(fabs(volume) < dgFloat64(1.0e-12f));
#endif
return dgBigVector(val0 / den, val1 / den, val2 / den, dgFloat32(0.0f));
diff --git a/engines/hpl1/engine/libraries/newton/core/dgList.h b/engines/hpl1/engine/libraries/newton/core/dgList.h
index 2d52f0a02e6..596601d08fa 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgList.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgList.h
@@ -37,7 +37,7 @@ public:
dgListNode(dgListNode *const prev, dgListNode *const next)
: m_info() {
-// _ASSERTE ((dgUnsigned64 (&m_info) & 0x0f) == 0);
+// NEWTON_ASSERT ((dgUnsigned64 (&m_info) & 0x0f) == 0);
m_prev = prev;
m_next = next;
if (m_prev) {
@@ -50,7 +50,7 @@ public:
dgListNode(const T &info, dgListNode *const prev, dgListNode *const next)
: m_info(info) {
-// _ASSERTE ((dgUnsigned64 (&m_info) & 0x0f) == 0);
+// NEWTON_ASSERT ((dgUnsigned64 (&m_info) & 0x0f) == 0);
m_prev = prev;
m_next = next;
if (m_prev) {
@@ -79,7 +79,7 @@ public:
// void Remove()
// {
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// Kill();
// Unlink();
// Release();
@@ -149,22 +149,22 @@ public:
}
void operator++ () {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->m_next();
}
void operator++ (dgInt32) {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->GetNext();
}
void operator-- () {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->GetPrev();
}
void operator-- (dgInt32) {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->GetPrev();
}
@@ -297,8 +297,8 @@ typename dgList<T>::dgListNode *dgList<T>::GetLast() const {
template<class T>
typename dgList<T>::dgListNode *dgList<T>::Append(dgListNode *const node) {
- _ASSERTE(node->m_next == NULL);
- _ASSERTE(node->m_prev == NULL);
+ NEWTON_ASSERT(node->m_next == NULL);
+ NEWTON_ASSERT(node->m_prev == NULL);
m_count ++;
if (m_first == NULL) {
m_last = node;
@@ -308,7 +308,7 @@ typename dgList<T>::dgListNode *dgList<T>::Append(dgListNode *const node) {
m_last = node;
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_last;
}
@@ -323,7 +323,7 @@ typename dgList<T>::dgListNode *dgList<T>::Append() {
m_last = new (m_allocator) dgListNode(m_last, NULL);
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_last;
}
@@ -338,7 +338,7 @@ typename dgList<T>::dgListNode *dgList<T>::Append(const T &element) {
m_last = new (m_allocator) dgListNode(element, m_last, NULL);
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_last;
@@ -346,8 +346,8 @@ typename dgList<T>::dgListNode *dgList<T>::Append(const T &element) {
template<class T>
typename dgList<T>::dgListNode *dgList<T>::Addtop(dgListNode *const node) {
- _ASSERTE(node->m_next == NULL);
- _ASSERTE(node->m_prev == NULL);
+ NEWTON_ASSERT(node->m_next == NULL);
+ NEWTON_ASSERT(node->m_prev == NULL);
m_count ++;
if (m_last == NULL) {
m_last = node;
@@ -357,7 +357,7 @@ typename dgList<T>::dgListNode *dgList<T>::Addtop(dgListNode *const node) {
m_first = node;
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_first;
}
@@ -373,7 +373,7 @@ typename dgList<T>::dgListNode *dgList<T>::Addtop() {
m_first = new (m_allocator) dgListNode(NULL, m_first);
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_first;
}
@@ -389,15 +389,15 @@ typename dgList<T>::dgListNode *dgList<T>::Addtop(const T &element) {
m_first = new (m_allocator) dgListNode(element, NULL, m_first);
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return m_first;
}
template<class T>
void dgList<T>::InsertAfter(dgListNode *const root, dgListNode *const node) {
- _ASSERTE(root);
- _ASSERTE(node != root);
+ NEWTON_ASSERT(root);
+ NEWTON_ASSERT(node != root);
if (root->m_next != node) {
if (node == m_first) {
@@ -419,19 +419,19 @@ void dgList<T>::InsertAfter(dgListNode *const root, dgListNode *const node) {
m_last = node;
}
- _ASSERTE(m_last);
- _ASSERTE(!m_last->m_next);
- _ASSERTE(m_first);
- _ASSERTE(!m_first->m_prev);
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(m_last);
+ NEWTON_ASSERT(!m_last->m_next);
+ NEWTON_ASSERT(m_first);
+ NEWTON_ASSERT(!m_first->m_prev);
+ NEWTON_ASSERT(SanityCheck());
}
}
template<class T>
void dgList<T>::InsertBefore(dgListNode *const root, dgListNode *const node) {
- _ASSERTE(root);
- _ASSERTE(node != root);
+ NEWTON_ASSERT(root);
+ NEWTON_ASSERT(node != root);
if (root->m_prev != node) {
if (node == m_last) {
@@ -453,11 +453,11 @@ void dgList<T>::InsertBefore(dgListNode *const root, dgListNode *const node) {
m_first = node;
}
- _ASSERTE(m_first);
- _ASSERTE(!m_first->m_prev);
- _ASSERTE(m_last);
- _ASSERTE(!m_last->m_next);
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(m_first);
+ NEWTON_ASSERT(!m_first->m_prev);
+ NEWTON_ASSERT(m_last);
+ NEWTON_ASSERT(!m_last->m_next);
+ NEWTON_ASSERT(SanityCheck());
}
}
@@ -476,7 +476,7 @@ void dgList<T>::RotateToEnd(dgListNode *const node) {
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -494,7 +494,7 @@ void dgList<T>::RotateToBegin(dgListNode *const node) {
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -519,7 +519,7 @@ typename dgList<T>::dgListNode *dgList<T>::GetNodeFromInfo(T &info) const {
dgInt64 offset = ((char *) &node->m_info) - ((char *) node);
dgListNode *const retnode = (dgListNode *)(((char *) node) - offset);
- _ASSERTE(&retnode->GetInfo() == &info);
+ NEWTON_ASSERT(&retnode->GetInfo() == &info);
return retnode;
}
@@ -534,10 +534,10 @@ void dgList<T>::Remove(const T &element) {
template<class T>
void dgList<T>::Unlink(dgListNode *const node) {
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
m_count --;
- _ASSERTE(m_count >= 0);
+ NEWTON_ASSERT(m_count >= 0);
if (node == m_first) {
m_first = m_first->GetNext();
@@ -549,7 +549,7 @@ void dgList<T>::Unlink(dgListNode *const node) {
node->Unlink();
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -571,7 +571,7 @@ void dgList<T>::Merge(dgList<T> &list) {
list.m_last = NULL;
list.m_first = NULL;
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -592,7 +592,7 @@ void dgList<T>::RemoveAll() {
node->Unlink();
delete node;
}
- _ASSERTE(m_count == 0);
+ NEWTON_ASSERT(m_count == 0);
m_last = NULL;
m_first = NULL;
}
@@ -604,22 +604,22 @@ bool dgList<T>::SanityCheck() const {
for (dgListNode *node = m_first; node; node = node->GetNext()) {
tCount ++;
if (node->GetPrev()) {
- _ASSERTE(node->GetPrev() != node->GetNext());
+ NEWTON_ASSERT(node->GetPrev() != node->GetNext());
if (node->GetPrev()->GetNext() != node) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
}
}
if (node->GetNext()) {
- _ASSERTE(node->GetPrev() != node->GetNext());
+ NEWTON_ASSERT(node->GetPrev() != node->GetNext());
if (node->GetNext()->GetPrev() != node) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
}
}
}
if (tCount != m_count) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
}
#endif
diff --git a/engines/hpl1/engine/libraries/newton/core/dgMatrix.cpp b/engines/hpl1/engine/libraries/newton/core/dgMatrix.cpp
index 9b2f56ca532..bfc1b9f0e50 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgMatrix.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgMatrix.cpp
@@ -58,7 +58,7 @@ dgMatrix::dgMatrix(const dgQuaternion &rotation, const dgVector &position) {
#ifdef _DEBUG
dgFloat32 w2 = dgFloat32(2.0f) * rotation.m_q0 * rotation.m_q0;
- _ASSERTE(dgAbsf(w2 + x2 + y2 + z2 - dgFloat32(2.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(w2 + x2 + y2 + z2 - dgFloat32(2.0f)) < dgFloat32(1.0e-3f));
#endif
dgFloat32 xy = dgFloat32(2.0f) * rotation.m_q1 * rotation.m_q2;
@@ -263,7 +263,7 @@ dgMatrix dgMatrix::Inverse4x4() const {
break;
}
}
- _ASSERTE(j < 4);
+ NEWTON_ASSERT(j < 4);
for (dgInt32 k = 0; k < 4; k ++) {
tmp[i][k] += tmp[j][k];
inv[i][k] += inv[j][k];
@@ -323,9 +323,9 @@ dgMatrix dgMatrix::Symetric3by3Inverse() const {
dgFloat32(1.0f)));
dgMatrix test(matInv * mat);
- _ASSERTE(dgAbsf(test[0][0] - dgFloat32(1.0f)) < dgFloat32(0.01f));
- _ASSERTE(dgAbsf(test[1][1] - dgFloat32(1.0f)) < dgFloat32(0.01f));
- _ASSERTE(dgAbsf(test[2][2] - dgFloat32(1.0f)) < dgFloat32(0.01f));
+ NEWTON_ASSERT(dgAbsf(test[0][0] - dgFloat32(1.0f)) < dgFloat32(0.01f));
+ NEWTON_ASSERT(dgAbsf(test[1][1] - dgFloat32(1.0f)) < dgFloat32(0.01f));
+ NEWTON_ASSERT(dgAbsf(test[2][2] - dgFloat32(1.0f)) < dgFloat32(0.01f));
#endif
return dgMatrix(
@@ -347,7 +347,7 @@ dgVector dgMatrix::CalcPitchYawRoll() const {
dgFloat32 yaw =
dgAsin(-ClampValue(matrix[0][2], dgFloat32(-0.999999f), dgFloat32(0.999999f)));
- _ASSERTE(dgCheckFloat(yaw));
+ NEWTON_ASSERT(dgCheckFloat(yaw));
if (matrix[0][2] < minSin) {
if (matrix[0][2] > (-minSin)) {
roll = dgAtan2(matrix[0][1], matrix[0][0]);
@@ -364,7 +364,7 @@ dgVector dgMatrix::CalcPitchYawRoll() const {
for (dgInt32 i = 0; i < 3; i++) {
for (dgInt32 j = 0; j < 3; j++) {
dgFloat32 error = dgAbsf(m[i][j] - matrix[i][j]);
- _ASSERTE(error < 5.0e-2f);
+ NEWTON_ASSERT(error < 5.0e-2f);
}
}
#endif
@@ -415,9 +415,9 @@ void dgMatrix::EigenVectors (dgVector &eigenValues, const dgMatrix& initialGuess
dgFloat32 sm = dgAbsf(mat[0][1]) + dgAbsf(mat[0][2]) + dgAbsf(mat[1][2]);
if (sm < dgFloat32 (1.0e-6f)) {
- _ASSERTE (dgAbsf((eigenVectors.m_front % eigenVectors.m_front) - dgFloat32(1.0f)) < dgEPSILON);
- _ASSERTE (dgAbsf((eigenVectors.m_up % eigenVectors.m_up) - dgFloat32(1.0f)) < dgEPSILON);
- _ASSERTE (dgAbsf((eigenVectors.m_right % eigenVectors.m_right) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT (dgAbsf((eigenVectors.m_front % eigenVectors.m_front) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT (dgAbsf((eigenVectors.m_up % eigenVectors.m_up) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT (dgAbsf((eigenVectors.m_right % eigenVectors.m_right) - dgFloat32(1.0f)) < dgEPSILON);
// order the eigenvalue vectors
dgVector tmp (eigenVectors.m_front * eigenVectors.m_up);
@@ -569,9 +569,9 @@ void dgMatrix::EigenVectors(dgVector &eigenValues, const dgMatrix &initialGuess)
dgFloat32 sm = dgAbsf(mat[0][1]) + dgAbsf(mat[0][2]) + dgAbsf(mat[1][2]);
if (sm < dgFloat32(1.0e-6f)) {
- _ASSERTE(dgAbsf((eigenVectors.m_front % eigenVectors.m_front) - dgFloat32(1.0f)) < dgEPSILON);
- _ASSERTE(dgAbsf((eigenVectors.m_up % eigenVectors.m_up) - dgFloat32(1.0f)) < dgEPSILON);
- _ASSERTE(dgAbsf((eigenVectors.m_right % eigenVectors.m_right) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT(dgAbsf((eigenVectors.m_front % eigenVectors.m_front) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT(dgAbsf((eigenVectors.m_up % eigenVectors.m_up) - dgFloat32(1.0f)) < dgEPSILON);
+ NEWTON_ASSERT(dgAbsf((eigenVectors.m_right % eigenVectors.m_right) - dgFloat32(1.0f)) < dgEPSILON);
// order the eigenvalue vectors
dgVector tmp(eigenVectors.m_front * eigenVectors.m_up);
diff --git a/engines/hpl1/engine/libraries/newton/core/dgMatrix.h b/engines/hpl1/engine/libraries/newton/core/dgMatrix.h
index a53118ffdf2..aa29868470d 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgMatrix.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgMatrix.h
@@ -131,22 +131,22 @@ DG_INLINE dgMatrix::dgMatrix(const dgVector &front) {
m_right.m_w = dgFloat32(0.0f);
m_posit = dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(1.0f));
- _ASSERTE((dgAbsf(m_front % m_front) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
- _ASSERTE((dgAbsf(m_up % m_up) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
- _ASSERTE((dgAbsf(m_right % m_right) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
- _ASSERTE((dgAbsf(m_right % (m_front * m_up)) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT((dgAbsf(m_front % m_front) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT((dgAbsf(m_up % m_up) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT((dgAbsf(m_right % m_right) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT((dgAbsf(m_right % (m_front * m_up)) - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
}
DG_INLINE dgVector &dgMatrix::operator[](dgInt32 i) {
- _ASSERTE(i < 4);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < 4);
+ NEWTON_ASSERT(i >= 0);
return (&m_front)[i];
}
DG_INLINE const dgVector &dgMatrix::operator[](dgInt32 i) const {
- _ASSERTE(i < 4);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < 4);
+ NEWTON_ASSERT(i >= 0);
return (&m_front)[i];
}
@@ -304,7 +304,7 @@ DG_INLINE dgMatrix dgMatrix::InverseSimd() const {
dgMatrix matrix;
const dgMatrix &source = *this;
- _ASSERTE((dgUnsigned64(this) & 0x0f) == 0);
+ NEWTON_ASSERT((dgUnsigned64(this) & 0x0f) == 0);
r2 = simd_set1(dgFloat32(0.0f));
r0 = simd_pack_lo_v((simd_type &) source[0], (simd_type &) source[1]);
diff --git a/engines/hpl1/engine/libraries/newton/core/dgMemory.cpp b/engines/hpl1/engine/libraries/newton/core/dgMemory.cpp
index e2091648c39..225d650d2fa 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgMemory.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgMemory.cpp
@@ -32,7 +32,7 @@ public:
}
~dgGlobalAllocator() {
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
}
static void *dgApi __malloc__(dgUnsigned32 size) {
@@ -44,7 +44,7 @@ public:
}
void operator delete (void *const ptr) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
//::delete (ptr);
free(ptr);
}
@@ -80,7 +80,7 @@ dgMemoryAllocator::dgMemoryAllocator(dgMemAlloc memAlloc, dgMemFree memFree) {
dgMemoryAllocator::~dgMemoryAllocator() {
dgGlobalAllocator::m_globalAllocator.Remove(this);
- _ASSERTE(m_memoryUsed == 0);
+ NEWTON_ASSERT(m_memoryUsed == 0);
}
void *dgMemoryAllocator::operator new (size_t size) {
@@ -101,8 +101,8 @@ void dgMemoryAllocator::SetAllocatorsCallback(dgMemAlloc memAlloc, dgMemFree mem
}
void *dgMemoryAllocator::MallocLow(dgInt32 workingSize, dgInt32 alignment) {
- _ASSERTE(alignment >= DG_MEMORY_GRANULARITY);
- _ASSERTE(((-alignment) & (alignment - 1)) == 0);
+ NEWTON_ASSERT(alignment >= DG_MEMORY_GRANULARITY);
+ NEWTON_ASSERT(((-alignment) & (alignment - 1)) == 0);
dgInt32 size = workingSize + alignment * 2;
void *const ptr = m_malloc(dgUnsigned32(size));
dgUnsigned64 val = dgUnsigned64(PointerToInt(ptr));
@@ -119,7 +119,7 @@ void *dgMemoryAllocator::MallocLow(dgInt32 workingSize, dgInt32 alignment) {
void dgMemoryAllocator::FreeLow(void *const retPtr) {
dgMemoryInfo *info;
info = ((dgMemoryInfo *)(retPtr)) - 1;
- _ASSERTE(info->m_allocator == this);
+ NEWTON_ASSERT(info->m_allocator == this);
dgAtomicAdd(&m_memoryUsed, -info->m_size);
@@ -133,7 +133,7 @@ void dgMemoryAllocator::FreeLow(void *const retPtr) {
// alloca memory on pool that are quantized to DG_MEMORY_GRANULARITY
// if memory size is larger than DG_MEMORY_BIN_ENTRIES then the memory is not placed into a pool
void *dgMemoryAllocator::Malloc(dgInt32 memsize) {
- _ASSERTE(dgInt32(sizeof(dgMemoryCacheEntry) + sizeof(dgInt32) + sizeof(dgInt32)) <= DG_MEMORY_GRANULARITY);
+ NEWTON_ASSERT(dgInt32(sizeof(dgMemoryCacheEntry) + sizeof(dgInt32) + sizeof(dgInt32)) <= DG_MEMORY_GRANULARITY);
dgInt32 size = memsize + DG_MEMORY_GRANULARITY - 1;
size &= (-DG_MEMORY_GRANULARITY);
@@ -177,7 +177,7 @@ void *dgMemoryAllocator::Malloc(dgInt32 memsize) {
m_memoryDirectory[entry].m_cache->m_prev = NULL;
}
- _ASSERTE(m_memoryDirectory[entry].m_cache);
+ NEWTON_ASSERT(m_memoryDirectory[entry].m_cache);
dgMemoryCacheEntry *const cashe = m_memoryDirectory[entry].m_cache;
m_memoryDirectory[entry].m_cache = cashe->m_next;
@@ -189,7 +189,7 @@ void *dgMemoryAllocator::Malloc(dgInt32 memsize) {
dgMemoryInfo *info;
info = ((dgMemoryInfo *)(ptr)) - 1;
- _ASSERTE(info->m_allocator == this);
+ NEWTON_ASSERT(info->m_allocator == this);
dgMemoryBin *const bin = (dgMemoryBin *) info->m_ptr;
bin->m_info.m_count++;
@@ -206,7 +206,7 @@ void *dgMemoryAllocator::Malloc(dgInt32 memsize) {
// if memory size is larger than DG_MEMORY_BIN_ENTRIES then the memory is not placed into a pool
void dgMemoryAllocator::Free(void *const retPtr) {
dgMemoryInfo *const info = ((dgMemoryInfo *)(retPtr)) - 1;
- _ASSERTE(info->m_allocator == this);
+ NEWTON_ASSERT(info->m_allocator == this);
dgInt32 entry = info->m_size;
@@ -221,7 +221,7 @@ void dgMemoryAllocator::Free(void *const retPtr) {
dgMemoryCacheEntry *const tmpCashe = m_memoryDirectory[entry].m_cache;
if (tmpCashe) {
- _ASSERTE(!tmpCashe->m_prev);
+ NEWTON_ASSERT(!tmpCashe->m_prev);
tmpCashe->m_prev = cashe;
}
cashe->m_next = tmpCashe;
@@ -232,7 +232,7 @@ void dgMemoryAllocator::Free(void *const retPtr) {
dgMemoryBin *const bin = (dgMemoryBin *) info->m_ptr;
#ifdef _DEBUG
- _ASSERTE((bin->m_info.m_stepInBites - DG_MEMORY_GRANULARITY) > 0);
+ NEWTON_ASSERT((bin->m_info.m_stepInBites - DG_MEMORY_GRANULARITY) > 0);
memset(retPtr, 0, bin->m_info.m_stepInBites - DG_MEMORY_GRANULARITY);
#endif
@@ -305,10 +305,10 @@ void dgMemoryAllocator::dgMemoryLeaksTracker::InsertBlock(dgInt32 size, void *co
dgUnsigned32 key;
dgUnsigned32 index;
- //_ASSERTE (ptr != (void*)0x04cf8080);
- //_ASSERTE (ptr != (void*)0x04d38080);
- //_ASSERTE (ptr != (void*)0x04f48080);
- //_ASSERTE (ptr != (void*)0x04f78080);
+ //NEWTON_ASSERT (ptr != (void*)0x04cf8080);
+ //NEWTON_ASSERT (ptr != (void*)0x04d38080);
+ //NEWTON_ASSERT (ptr != (void*)0x04f48080);
+ //NEWTON_ASSERT (ptr != (void*)0x04f78080);
//if (m_leakAllocationCounter >= 2080840)
//m_leakAllocationCounter *=1;
@@ -319,8 +319,8 @@ void dgMemoryAllocator::dgMemoryLeaksTracker::InsertBlock(dgInt32 size, void *co
index = ((index + 1) < DG_TRACK_MEMORY_LEAKS_ENTRIES) ? index + 1 : 0;
}
- _ASSERTE(i < 8);
- _ASSERTE(i < DG_TRACK_MEMORY_LEAKS_ENTRIES);
+ NEWTON_ASSERT(i < 8);
+ NEWTON_ASSERT(i < DG_TRACK_MEMORY_LEAKS_ENTRIES);
m_density ++;
m_pool[index].m_size = size;
@@ -345,7 +345,7 @@ void dgMemoryAllocator::dgMemoryLeaksTracker::RemoveBlock(void *const ptr) {
m_density --;
m_totalAllocatedCalls--;
m_totalAllocatedBytes -= m_pool[index].m_size;
- _ASSERTE(m_totalAllocatedBytes >= 0);
+ NEWTON_ASSERT(m_totalAllocatedBytes >= 0);
m_pool[index].m_size = 0;
m_pool[index].m_ptr = NULL;
break;
@@ -353,7 +353,7 @@ void dgMemoryAllocator::dgMemoryLeaksTracker::RemoveBlock(void *const ptr) {
index = ((index + 1) < DG_TRACK_MEMORY_LEAKS_ENTRIES) ? index + 1 : 0;
}
- _ASSERTE(i < DG_TRACK_MEMORY_LEAKS_ENTRIES);
+ NEWTON_ASSERT(i < DG_TRACK_MEMORY_LEAKS_ENTRIES);
}
#endif
@@ -389,7 +389,7 @@ void dgApi dgFreeStack(void *const ptr) {
// general memory allocation for all data in the library
void *dgApi dgMalloc(size_t size, dgMemoryAllocator *const allocator) {
void *ptr = NULL;
- _ASSERTE(allocator);
+ NEWTON_ASSERT(allocator);
if (size) {
ptr = allocator->Malloc(dgInt32(size));
}
@@ -401,7 +401,7 @@ void dgApi dgFree(void *const ptr) {
if (ptr) {
dgMemoryAllocator::dgMemoryInfo *info;
info = ((dgMemoryAllocator::dgMemoryInfo *) ptr) - 1;
- _ASSERTE(info->m_allocator);
+ NEWTON_ASSERT(info->m_allocator);
info->m_allocator->Free(ptr);
}
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgMemory.h b/engines/hpl1/engine/libraries/newton/core/dgMemory.h
index ebfde8f2f14..cd3c2126085 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgMemory.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgMemory.h
@@ -54,8 +54,8 @@ dgInt32 dgGetMemoryUsed();
#define DG_CLASS_ALLOCATOR_NEW_ARRAY(allocator) inline void *operator new[] (size_t size, dgMemoryAllocator* const allocator) { return dgMalloc(size, allocator);}
#define DG_CLASS_ALLOCATOR_DELETE(allocator) inline void operator delete (void* const ptr, dgMemoryAllocator* const allocator) { dgFree(ptr); }
#define DG_CLASS_ALLOCATOR_DELETE_ARRAY(allocator) inline void operator delete[] (void* const ptr, dgMemoryAllocator* const allocator) { dgFree(ptr); }
-#define DG_CLASS_ALLOCATOR_NEW_DUMMY inline void *operator new (size_t size) { _ASSERTE (0); return dgMalloc(size, NULL);}
-#define DG_CLASS_ALLOCATOR_NEW_ARRAY_DUMMY inline void *operator new[] (size_t size) { _ASSERTE (0); return dgMalloc(size, NULL);}
+#define DG_CLASS_ALLOCATOR_NEW_DUMMY inline void *operator new (size_t size) { NEWTON_ASSERT (0); return dgMalloc(size, NULL);}
+#define DG_CLASS_ALLOCATOR_NEW_ARRAY_DUMMY inline void *operator new[] (size_t size) { NEWTON_ASSERT (0); return dgMalloc(size, NULL);}
#define DG_CLASS_ALLOCATOR_DELETE_DUMMY inline void operator delete (void* const ptr) { dgFree(ptr); }
#define DG_CLASS_ALLOCATOR_DELETE_ARRAY_DUMMY inline void operator delete[] (void* const ptr) { dgFree(ptr); }
diff --git a/engines/hpl1/engine/libraries/newton/core/dgNode.cpp b/engines/hpl1/engine/libraries/newton/core/dgNode.cpp
index 60de1221b2d..ef7144dd748 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgNode.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgNode.cpp
@@ -63,7 +63,7 @@ void dgBaseNode::CloneFixUp(const dgBaseNode &clone) {
dgBaseNode *obj;
dgBaseNode *cloneChild;
- _ASSERTE(GetNameID() == clone.GetNameID());
+ NEWTON_ASSERT(GetNameID() == clone.GetNameID());
cloneChild = clone.GetChild();
for (obj = child; obj; obj = obj->sibling) {
@@ -88,9 +88,9 @@ void dgBaseNode::CloneFixUp(const dgBaseNode &clone) {
void dgBaseNode::Attach(dgBaseNode *parentArg, bool addFirst) {
dgBaseNode *obj;
- _ASSERTE(!parent);
- _ASSERTE(!sibling);
- _ASSERTE(parentArg);
+ NEWTON_ASSERT(!parent);
+ NEWTON_ASSERT(!sibling);
+ NEWTON_ASSERT(parentArg);
parent = parentArg;
if (parent->child) {
diff --git a/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupBuilder.cpp b/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupBuilder.cpp
index aa7cc7ae27c..d2aafa70f93 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupBuilder.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupBuilder.cpp
@@ -45,7 +45,7 @@ public:
dgInt32 AddFilterFace(dgUnsigned32 count, dgInt32 *const pool) {
BeginFace();
- _ASSERTE(count);
+ NEWTON_ASSERT(count);
bool reduction = true;
while (reduction && !AddFace(dgInt32(count), pool)) {
reduction = false;
@@ -67,7 +67,7 @@ public:
}
EndFace();
- _ASSERTE(reduction);
+ NEWTON_ASSERT(reduction);
return reduction ? dgInt32(count) : 0;
}
};
@@ -288,7 +288,7 @@ void dgPolygonSoupDatabaseBuilder::OptimizeByGroupID() {
break;
}
}
- _ASSERTE(builderLeftOver.m_faceCount == 0);
+ NEWTON_ASSERT(builderLeftOver.m_faceCount == 0);
}
polygonIndex += m_faceVertexCount[i];
}
@@ -331,7 +331,7 @@ void dgPolygonSoupDatabaseBuilder::OptimizeByGroupID(
for (dgInt32 i = faceNumber; i < source.m_faceCount; i++) {
dgInt32 indexCount;
indexCount = source.m_faceVertexCount[i];
- _ASSERTE(indexCount < 1024);
+ NEWTON_ASSERT(indexCount < 1024);
if (source.m_vertexIndex[faceIndexNumber] == attribute) {
dgEdge *const face = polyhedra.AddFace(indexCount - 1,
@@ -441,7 +441,7 @@ void dgPolygonSoupDatabaseBuilder::OptimizeByIndividualFaces() {
}
polygonIndex += oldCount;
}
- _ASSERTE(polygonIndex == m_indexCount);
+ NEWTON_ASSERT(polygonIndex == m_indexCount);
m_faceCount = newFaceCount;
m_indexCount = newIndexCount;
}
@@ -685,7 +685,7 @@ dgInt32 dgPolygonSoupDatabaseBuilder::FilterFace(dgInt32 count,
polyhedra.FaceNormal(edge, &m_vertexPoints[0].m_x,
sizeof(dgBigVector)));
- _ASSERTE((normal % normal) > dgFloat32(1.0e-10f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(1.0e-10f));
normal = normal.Scale(dgRsqrt(normal % normal + dgFloat32(1.0e-20f)));
while (flag) {
@@ -785,7 +785,7 @@ dgInt32 dgPolygonSoupDatabaseBuilder::FilterFace(dgInt32 count,
dgBigVector e1((p2 - p1));
dgBigVector n(e1 * e0);
- _ASSERTE((n % normal) > dgFloat32(0.0f));
+ NEWTON_ASSERT((n % normal) > dgFloat32(0.0f));
j0 = j1;
j1 = j2;
}
@@ -938,7 +938,7 @@ dgInt32 dgPolygonSoupDatabaseBuilder::AddConvexFace(dgInt32 count,
polyhedra2.ConvexPartition(&m_vertexPoints[0].m_x, sizeof(dgTriplex),
&leftOver);
leftOver.EndFace();
- _ASSERTE(leftOver.GetCount() == 0);
+ NEWTON_ASSERT(leftOver.GetCount() == 0);
dgInt32 mark = polyhedra2.IncLRU();
dgInt32 index = 0;
diff --git a/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupDatabase.h b/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupDatabase.h
index 6fb687f8a67..0df8f11ddb6 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupDatabase.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgPolygonSoupDatabase.h
@@ -115,13 +115,13 @@ inline dgFloat32 dgPolygonSoupDatabase::GetRadius() const {
}
inline void dgPolygonSoupDatabase::ForAllSectorsSimd(const dgVector &min, const dgVector &max, dgAABBIntersectCallback callback, void *const context) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
inline void dgPolygonSoupDatabase::ForAllSectors(const dgVector &min, const dgVector &max, dgAABBIntersectCallback callback, void *const context) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
@@ -130,11 +130,11 @@ inline void dgPolygonSoupDatabase::GetAABB(dgVector &p0, dgVector &p1) const {
inline void dgPolygonSoupDatabase::ForAllSectorsRayHit(const dgFastRayTest &ray, dgRayIntersectCallback callback, void *const context) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
inline void dgPolygonSoupDatabase::ForAllSectorsRayHitSimd(const dgFastRayTest &ray, dgRayIntersectCallback callback, void *const context) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
#endif
diff --git a/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.cpp b/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.cpp
index 154619138aa..62d8e1c0885 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.cpp
@@ -50,7 +50,7 @@ struct dgEdgeCollapseEdgeHandle {
dgEdgeCollapseEdgeHandle *const handle =
(dgEdgeCollapseEdgeHandle *) IntToPointer(m_edge->m_userData);
if (handle) {
- _ASSERTE(handle != this);
+ NEWTON_ASSERT(handle != this);
handle->m_edge = NULL;
}
m_edge->m_userData = dgUnsigned64(PointerToInt(this));
@@ -227,7 +227,7 @@ static void GetAdjacentCoplanarFacesPerimeter(
const dgFloat32 normalDeviation = dgFloat32(0.9999f);
dgStack<dgInt32>facesIndex(4096);
- _ASSERTE(face->m_incidentFace > 0);
+ NEWTON_ASSERT(face->m_incidentFace > 0);
polyhedra.IncLRU();
dgInt32 faceMark = polyhedra.IncLRU();
@@ -277,7 +277,7 @@ static void GetAdjacentCoplanarFacesPerimeter(
if ((ptr->m_twin->m_incidentFace > 0) && (ptr->m_twin->m_mark != faceMark)) {
stack[index] = ptr->m_twin;
index ++;
- _ASSERTE(index < polyhedra.GetCount() / 2);
+ NEWTON_ASSERT(index < polyhedra.GetCount() / 2);
}
ptr = ptr->m_next;
} while (ptr != edge);
@@ -390,7 +390,7 @@ void dgPolyhedra::DeleteAllFace() {
}
bool dgPolyhedra::SanityCheck() const {
- //_ASSERTE (0);
+ //NEWTON_ASSERT (0);
return true;
/*
dgInt32 i;
@@ -503,7 +503,7 @@ dgEdge *dgPolyhedra::FindVertexNode(dgInt32 v) const {
dgEdge *dgPolyhedra::SpliteEdgeAndTriangulate(dgInt32 newIndex, dgEdge *srcEdge) {
dgEdge *ankle = srcEdge->m_next;
dgEdge *edge = SpliteEdge(newIndex, srcEdge);
- _ASSERTE(edge == ankle->m_prev);
+ NEWTON_ASSERT(edge == ankle->m_prev);
edge = ankle->m_prev;
ankle = edge;
@@ -541,7 +541,7 @@ dgEdge *dgPolyhedra::SpliteEdgeAndTriangulate(dgInt32 newIndex, dgEdge *srcEdge)
} while (edge != ankle);
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return ankle;
@@ -593,7 +593,7 @@ dgInt32 dgPolyhedra::GetUnboundedFaceCount() const {
}
dgInt32 dgPolyhedra::PackVertex(dgFloat32 *const destArray, const dgFloat32 *const unpackArray, dgInt32 strideInBytes) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
/*
dgInt32 i;
@@ -625,7 +625,7 @@ dgInt32 dgPolyhedra::PackVertex(dgFloat32 *const destArray, const dgFloat32 *con
tree[edgeCount] = node;
node->AddRef();
- _ASSERTE (edgeCount < maxCount);
+ NEWTON_ASSERT (edgeCount < maxCount);
edgeCount ++;
edge = &node->GetInfo();
@@ -695,8 +695,8 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
ptr = ptr->m_next;
} while (ptr != edge);
- _ASSERTE(edge);
- _ASSERTE(0);
+ NEWTON_ASSERT(edge);
+ NEWTON_ASSERT(0);
faceList.Append(edge);
}
}
@@ -728,13 +728,13 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE (SanityCheck ());
+ NEWTON_ASSERT (SanityCheck ());
#endif
stride = strideInBytes / sizeof (dgFloat32);
area2 = area * area;
dgStack<char> heapPool (desc.m_faceCount * (sizeof (dgFloat32) + sizeof (dgPairKey) + sizeof (dgInt32)));
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
dgDownHeap<dgPairKey, dgFloat32> bigHeapArray(&heapPool[0], heapPool.GetSizeInBytes());
Iterator iter (*this);
@@ -745,7 +745,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
edge = &(*iter);
if ((edge->m_mark != mark) && (edge->m_incidentFace > 0)) {
- _ASSERTE (edge->m_next->m_next->m_next == edge);
+ NEWTON_ASSERT (edge->m_next->m_next->m_next == edge);
edge->m_mark = mark;
edge->m_next->m_mark = mark;
@@ -823,7 +823,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE (SanityCheck ());
+ NEWTON_ASSERT (SanityCheck ());
#endif
}
@@ -852,7 +852,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
startFace = startFace->m_twin;
}
- _ASSERTE (startFace->m_incidentFace > 0);
+ NEWTON_ASSERT (startFace->m_incidentFace > 0);
mark = IncLRU();
dgBigVector normal (FaceNormal (startFace, pool, strideInBytes));
@@ -864,7 +864,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
ptr = ptr->m_next;
} while (ptr != startFace);
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
faceList.Append (startFace);
return;
}
@@ -878,7 +878,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
dgEdge* const edge = stack[index];
if (edge->m_mark == mark) {
- _ASSERTE (0u);
+ NEWTON_ASSERT (0u);
continue;
}
@@ -897,12 +897,12 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
if ((ptr->m_twin->m_incidentFace > 0) && (ptr->m_twin->m_mark != mark)) {
stack[index] = ptr->m_twin;
index ++;
- _ASSERTE (index < GetCount() / 2);
+ NEWTON_ASSERT (index < GetCount() / 2);
}
ptr = ptr->m_next;
} while (ptr != edge);
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
faceList.Append (edge);
}
}
@@ -987,7 +987,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
userData[count] = dgInt32 (ptr->m_userData);
vertexData[count] = ptr->m_incidentVertex;
count ++;
- _ASSERTE (count < 1024 * 4);
+ NEWTON_ASSERT (count < 1024 * 4);
ptr->m_mark = mark;
ptr = ptr->m_prev;
@@ -997,7 +997,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
}
EndFace();
- _ASSERTE (SanityCheck());
+ NEWTON_ASSERT (SanityCheck());
}
*/
@@ -1094,11 +1094,11 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
edgeAngle1 = dgRAD2DEG * dgAtan2 (twinNormal % (e30 * e10), e10 % e30);
if ((edgeAngle0 + edgeAngle1) < 160.0f) {
- _ASSERTE ((edgeAngle0 + edgeAngle1) > 0.0f);
+ NEWTON_ASSERT ((edgeAngle0 + edgeAngle1) > 0.0f);
medianAngle = 4.0f * edgeAngle0 * edgeAngle1 / (edgeAngle0 + edgeAngle1);
- _ASSERTE (medianAngle > 0.0f);
- _ASSERTE (medianAngle < 360.0f);
+ NEWTON_ASSERT (medianAngle > 0.0f);
+ NEWTON_ASSERT (medianAngle < 360.0f);
edgeCost = abs (ClampValue (90 - (dgInt32)medianAngle, -90, 90));
} else {
edgeCost = 4000000;
@@ -1116,11 +1116,11 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
twinAngle1 = dgRAD2DEG * dgAtan2 (edgeNormal % (t30 * t10), t10 % t30);
if ((twinAngle0 + twinAngle1) < 160.0f) {
- _ASSERTE ((twinAngle0 + twinAngle1) > 0.0f);
+ NEWTON_ASSERT ((twinAngle0 + twinAngle1) > 0.0f);
medianAngle = 4.0f * twinAngle0 * twinAngle1 / (twinAngle0 + twinAngle1);
- _ASSERTE (medianAngle > 0.0f);
- _ASSERTE (medianAngle < 360.0f);
+ NEWTON_ASSERT (medianAngle > 0.0f);
+ NEWTON_ASSERT (medianAngle < 360.0f);
twinCost = abs (ClampValue (90 - (dgInt32)medianAngle, -90, 90));
} else {
twinCost = 4000000;
@@ -1221,7 +1221,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
// }
// }
//}
- //_ASSERTE (0);
+ //NEWTON_ASSERT (0);
//#endif
}
@@ -1280,7 +1280,7 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
for (iter.Begin(); iter; iter ++) {
edge = &(*iter);
if (edge->m_incidentFace > 0)
- _ASSERTE (edge->m_next->m_next->m_next == edge);
+ NEWTON_ASSERT (edge->m_next->m_next->m_next == edge);
}
#endif
}
@@ -1418,8 +1418,8 @@ void dgPolyhedra::GetBadEdges(dgList<dgEdge *> &faceList, const dgFloat32 *const
ptr = node->GetInfo();
- _ASSERTE (ptr->m_mark != mark);
- _ASSERTE (ptr->m_twin->m_incidentVertex == vertex);
+ NEWTON_ASSERT (ptr->m_mark != mark);
+ NEWTON_ASSERT (ptr->m_twin->m_incidentVertex == vertex);
twinVertex = ptr->m_twin->m_incidentVertex;
@@ -1548,7 +1548,7 @@ newEdge:
ptr = ptr->m_twin->m_next;
} while (ptr != edge);
- _ASSERTE(face);
+ NEWTON_ASSERT(face);
ptr = face;
do {
outputBuffer[count] = dgUnsigned32(ptr->m_incidentVertex);
@@ -1668,7 +1668,7 @@ dgPolyhedra::dgPolyhedra(const dgPolyhedra &polyhedra) :
m_faceSecuence = polyhedra.m_faceSecuence;
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -1764,7 +1764,7 @@ dgEdge *dgPolyhedra::AddFace(dgInt32 count, const dgInt32 *const index,
dgPairKey code(i0, i1);
dgEdge tmpEdge(i0, m_faceSecuence, udata0);
dgTreeNode *node = Insert(tmpEdge, code.GetVal(), state);
- _ASSERTE(!state);
+ NEWTON_ASSERT(!state);
dgEdge *edge0 = &node->GetInfo();
dgEdge *const first = edge0;
@@ -1777,7 +1777,7 @@ dgEdge *dgPolyhedra::AddFace(dgInt32 count, const dgInt32 *const index,
dgPairKey codeI(i0, i1);
dgEdge tmpEdgeI(i0, m_faceSecuence, udata0);
node = Insert(tmpEdgeI, codeI.GetVal(), state);
- _ASSERTE(!state);
+ NEWTON_ASSERT(!state);
dgEdge *const edge1 = &node->GetInfo();
edge0->m_next = edge1;
@@ -1807,8 +1807,8 @@ void dgPolyhedra::EndFace() {
}
#ifdef __ENABLE_SANITY_CHECK
- //_ASSERTE (polyhedra->SanityCheck());
- _ASSERTE(SanityCheck());
+ //NEWTON_ASSERT (polyhedra->SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
dgStack<dgEdge *> edgeArrayPool(GetCount() * 2 + 256);
@@ -1824,7 +1824,7 @@ void dgPolyhedra::EndFace() {
tmpEdge.m_incidentFace = -1;
dgPolyhedra::dgTreeNode *const node = Insert(tmpEdge, code.GetVal(),
state);
- _ASSERTE(!state);
+ NEWTON_ASSERT(!state);
edge->m_twin = &node->GetInfo();
edge->m_twin->m_twin = edge;
edgeArray[edgeCount] = edge->m_twin;
@@ -1834,7 +1834,7 @@ void dgPolyhedra::EndFace() {
for (dgInt32 i = 0; i < edgeCount; i++) {
dgEdge *const edge = edgeArray[i];
- _ASSERTE(!edge->m_prev);
+ NEWTON_ASSERT(!edge->m_prev);
dgEdge *ptr = edge->m_twin;
for (; ptr->m_next; ptr = ptr->m_next->m_twin) {
}
@@ -1843,8 +1843,8 @@ void dgPolyhedra::EndFace() {
}
#ifdef __ENABLE_SANITY_CHECK
-// _ASSERTE (polyhedra->SanityCheck ());
- _ASSERTE(SanityCheck());
+// NEWTON_ASSERT (polyhedra->SanityCheck ());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -1921,8 +1921,8 @@ void dgPolyhedra::DeleteEdge(dgEdge *const edge) {
dgTreeNode *const nodeA = GetNodeFromInfo(*edge);
dgTreeNode *const nodeB = GetNodeFromInfo(*twin);
- _ASSERTE(&nodeA->GetInfo() == edge);
- _ASSERTE(&nodeB->GetInfo() == twin);
+ NEWTON_ASSERT(&nodeA->GetInfo() == edge);
+ NEWTON_ASSERT(&nodeB->GetInfo() == twin);
Remove(nodeA);
Remove(nodeB);
@@ -1947,10 +1947,10 @@ dgEdge *dgPolyhedra::SpliteEdge(dgInt32 newIndex, dgEdge *const edge) {
dgEdge *const twin0 = AddHalfEdge(newIndex, i0);
dgEdge *const twin1 = AddHalfEdge(i1, newIndex);
- _ASSERTE(edge0);
- _ASSERTE(edge1);
- _ASSERTE(twin0);
- _ASSERTE(twin1);
+ NEWTON_ASSERT(edge0);
+ NEWTON_ASSERT(edge1);
+ NEWTON_ASSERT(twin0);
+ NEWTON_ASSERT(twin1);
edge0->m_twin = twin0;
twin0->m_twin = edge0;
@@ -1983,7 +1983,7 @@ dgEdge *dgPolyhedra::SpliteEdge(dgInt32 newIndex, dgEdge *const edge) {
twin1->m_incidentFace = f1;
#ifdef __ENABLE_SANITY_CHECK
- // _ASSERTE (SanityCheck ());
+ // NEWTON_ASSERT (SanityCheck ());
#endif
return edge0;
@@ -2011,10 +2011,10 @@ bool dgPolyhedra::FlipEdge(dgEdge *const edge) {
dgPairKey twinKey(prevEdge->m_incidentVertex, prevTwin->m_incidentVertex);
ReplaceKey(GetNodeFromInfo(*edge), edgeKey.GetVal());
- // _ASSERTE (node);
+ // NEWTON_ASSERT (node);
ReplaceKey(GetNodeFromInfo(*edge->m_twin), twinKey.GetVal());
- // _ASSERTE (node);
+ // NEWTON_ASSERT (node);
edge->m_incidentVertex = prevTwin->m_incidentVertex;
edge->m_twin->m_incidentVertex = prevEdge->m_incidentVertex;
@@ -2047,7 +2047,7 @@ bool dgPolyhedra::FlipEdge(dgEdge *const edge) {
edge->m_twin->m_prev->m_incidentFace = edge->m_twin->m_incidentFace;
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
return true;
@@ -2096,12 +2096,12 @@ bool dgPolyhedra::GetConectedSurface(dgPolyhedra &polyhedra) const {
faceIndex[count] = ptr->m_incidentVertex;
faceDataIndex[count] = dgInt64(ptr->m_userData);
count++;
- _ASSERTE(count < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
if ((ptr->m_twin->m_incidentFace > 0) && (ptr->m_twin->m_mark != mark)) {
stack[index] = ptr->m_twin;
index++;
- _ASSERTE(index < GetCount());
+ NEWTON_ASSERT(index < GetCount());
}
ptr = ptr->m_next;
@@ -2139,7 +2139,7 @@ void dgPolyhedra::DeleteDegenerateFaces(const dgFloat64 *const pool,
}
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
dgStack<dgPolyhedra::dgTreeNode *> faceArrayPool(GetCount() / 2 + 100);
@@ -2181,7 +2181,7 @@ void dgPolyhedra::DeleteDegenerateFaces(const dgFloat64 *const pool,
for (iter.Begin(); iter; iter ++) {
dgEdge *const edge = &(*iter);
if ((edge->m_mark != mark) && (edge->m_incidentFace > 0)) {
- //_ASSERTE (edge->m_next->m_next->m_next == edge);
+ //NEWTON_ASSERT (edge->m_next->m_next->m_next == edge);
dgEdge *ptr = edge;
do {
ptr->m_mark = mark;
@@ -2191,10 +2191,10 @@ void dgPolyhedra::DeleteDegenerateFaces(const dgFloat64 *const pool,
dgBigVector normal(FaceNormal(edge, pool, strideInBytes));
dgFloat64 faceArea = normal % normal;
- _ASSERTE(faceArea >= area2);
+ NEWTON_ASSERT(faceArea >= area2);
}
}
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
}
@@ -2269,7 +2269,7 @@ static void CalculateAllMetrics(const dgPolyhedra *const polyhedra,
for (iter.Begin(); iter; iter++) {
dgEdge *const edge = &(*iter);
- _ASSERTE(edge);
+ NEWTON_ASSERT(edge);
if (edge->m_mark != edgeMark) {
if (edge->m_incidentFace > 0) {
@@ -2290,7 +2290,7 @@ static void CalculateAllMetrics(const dgPolyhedra *const polyhedra,
} while (ptr != edge);
} else {
- _ASSERTE(edge->m_twin->m_incidentFace > 0);
+ NEWTON_ASSERT(edge->m_twin->m_incidentFace > 0);
dgInt32 i0 = edge->m_twin->m_incidentVertex;
dgInt32 i1 = edge->m_twin->m_next->m_incidentVertex;
dgInt32 i2 = edge->m_twin->m_prev->m_incidentVertex;
@@ -2387,7 +2387,7 @@ dgFloat64 dgPolyhedra::EdgePenalty(const dgBigVector *const pool,
dgBigVector n1((pv1 - p) * (pv2 - p));
// dgFloat64 mag0 = n0 % n0;
-// _ASSERTE (mag0 > dgFloat64(1.0e-16f));
+// NEWTON_ASSERT (mag0 > dgFloat64(1.0e-16f));
// mag0 = sqrt (mag0);
// dgFloat64 mag1 = n1 % n1;
@@ -2480,7 +2480,7 @@ static void RemoveHalfEdge(dgPolyhedra *const polyhedra, dgEdge *const edge) {
}
dgPolyhedra::dgTreeNode *const node = polyhedra->GetNodeFromInfo(*edge);
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
polyhedra->Remove(node);
}
@@ -2493,11 +2493,11 @@ static dgEdge *CollapseEdge(dgPolyhedra *const polyhedra, dgEdge *const edge) {
dgPolyhedra::dgPairKey TwinKey(v1, v0);
dgPolyhedra::dgTreeNode *const node = polyhedra->Find(TwinKey.GetVal());
dgEdge *const twin1 = node ? &node->GetInfo() : NULL;
- _ASSERTE(twin1);
- _ASSERTE(edge->m_twin == twin1);
- _ASSERTE(twin1->m_twin == edge);
- _ASSERTE(edge->m_incidentFace != 0);
- _ASSERTE(twin1->m_incidentFace != 0);
+ NEWTON_ASSERT(twin1);
+ NEWTON_ASSERT(edge->m_twin == twin1);
+ NEWTON_ASSERT(twin1->m_twin == edge);
+ NEWTON_ASSERT(edge->m_incidentFace != 0);
+ NEWTON_ASSERT(twin1->m_incidentFace != 0);
#endif
dgEdge *retEdge = edge->m_twin->m_prev->m_twin;
@@ -2560,8 +2560,8 @@ static dgEdge *CollapseEdge(dgPolyhedra *const polyhedra, dgEdge *const edge) {
edge->m_prev->m_next = edge->m_next;
}
- _ASSERTE(twin->m_twin->m_incidentVertex == v0);
- _ASSERTE(edge->m_twin->m_incidentVertex == v1);
+ NEWTON_ASSERT(twin->m_twin->m_incidentVertex == v0);
+ NEWTON_ASSERT(edge->m_twin->m_incidentVertex == v1);
RemoveHalfEdge(polyhedra, twin);
RemoveHalfEdge(polyhedra, edge);
@@ -2575,7 +2575,7 @@ static dgEdge *CollapseEdge(dgPolyhedra *const polyhedra, dgEdge *const edge) {
dgPolyhedra::dgPairKey key(v1, ptr->m_twin->m_incidentVertex);
ptr->m_incidentVertex = v1;
node = polyhedra->ReplaceKey(node, key.GetVal());
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
}
}
@@ -2585,7 +2585,7 @@ static dgEdge *CollapseEdge(dgPolyhedra *const polyhedra, dgEdge *const edge) {
if (&node->GetInfo() == ptr->m_twin) {
dgPolyhedra::dgPairKey key(ptr->m_twin->m_incidentVertex, v1);
node = polyhedra->ReplaceKey(node, key.GetVal());
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
}
}
@@ -2602,7 +2602,7 @@ void dgPolyhedra::Optimize(const dgFloat64 *const array, dgInt32 strideInBytes,
dgInt32 stride = dgInt32(strideInBytes / sizeof(dgFloat64));
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
dgInt32 edgeCount = GetEdgeCount() * 4 + 1024 * 16;
@@ -2666,13 +2666,13 @@ void dgPolyhedra::Optimize(const dgFloat64 *const array, dgInt32 strideInBytes,
&& (EdgePenalty(&vertexPool[0], edge) > dgFloat64(0.0f))) {
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
edge = CollapseEdge(this, edge);
#ifdef __ENABLE_SANITY_CHECK
- _ASSERTE(SanityCheck());
+ NEWTON_ASSERT(SanityCheck());
#endif
if (edge) {
// Update vertex metrics
@@ -2690,7 +2690,7 @@ void dgPolyhedra::Optimize(const dgFloat64 *const array, dgInt32 strideInBytes,
dgInt32 mark = IncLRU();
ptr = edge;
do {
- _ASSERTE(ptr->m_mark != mark);
+ NEWTON_ASSERT(ptr->m_mark != mark);
ptr->m_mark = mark;
index0 = ptr->m_incidentVertex;
@@ -2742,7 +2742,7 @@ void dgPolyhedra::Optimize(const dgFloat64 *const array, dgInt32 strideInBytes,
}
if (cost > dgFloat64(0.0f)) {
- _ASSERTE(cost > dgFloat64(0.0f));
+ NEWTON_ASSERT(cost > dgFloat64(0.0f));
dgEdgeCollapseEdgeHandle handle(ptr1);
handleNodePtr = edgeHandleList.Addtop(handle);
bigHeapArray.Push(handleNodePtr, cost);
@@ -2769,7 +2769,7 @@ void dgPolyhedra::Optimize(const dgFloat64 *const array, dgInt32 strideInBytes,
}
if (cost > dgFloat64(0.0f)) {
- _ASSERTE(cost > dgFloat64(0.0f));
+ NEWTON_ASSERT(cost > dgFloat64(0.0f));
dgEdgeCollapseEdgeHandle handle(ptr1->m_twin);
handleNodePtr = edgeHandleList.Addtop(handle);
bigHeapArray.Push(handleNodePtr, cost);
@@ -2889,11 +2889,11 @@ dgEdge *dgPolyhedra::TriangulateFace(dgEdge *face, const dgFloat64 *const pool,
do {
perimeter[perimeterCount] = ptr;
perimeterCount++;
- _ASSERTE(perimeterCount < dgInt32(sizeof(perimeter) / sizeof(perimeter[0])));
+ NEWTON_ASSERT(perimeterCount < dgInt32(sizeof(perimeter) / sizeof(perimeter[0])));
ptr = ptr->m_next;
} while (ptr != face);
perimeter[perimeterCount] = face;
- _ASSERTE((perimeterCount + 1) < dgInt32(sizeof(perimeter) / sizeof(perimeter[0])));
+ NEWTON_ASSERT((perimeterCount + 1) < dgInt32(sizeof(perimeter) / sizeof(perimeter[0])));
#endif
dgBigVector normal(
@@ -2930,7 +2930,7 @@ dgEdge *dgPolyhedra::TriangulateFace(dgEdge *face, const dgFloat64 *const pool,
if (!twin) {
return face;
}
- _ASSERTE(twin);
+ NEWTON_ASSERT(twin);
edge->m_mark = ear->m_mark;
edge->m_userData = ear->m_next->m_userData;
@@ -2971,7 +2971,7 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
deleteEdge[0] = face;
dgInt32 stride = dgInt32(strideInBytes / sizeof(dgFloat64));
- _ASSERTE(face->m_incidentFace > 0);
+ NEWTON_ASSERT(face->m_incidentFace > 0);
dgBigVector normalAverage(FaceNormal(face, pool, strideInBytes));
dgFloat64 dot = normalAverage % normalAverage;
@@ -2995,7 +2995,7 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
ptr->m_mark = faceMark;
faceIndex[faceIndexCount] = ptr->m_incidentVertex;
faceIndexCount++;
- _ASSERTE(faceIndexCount < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
+ NEWTON_ASSERT(faceIndexCount < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
ptr = ptr->m_next;
} while (ptr != face);
}
@@ -3009,8 +3009,8 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
dgEdge *const stackFace = stack[index];
deleteEdge[deleteCount] = stackFace;
deleteCount++;
- _ASSERTE(deleteCount < dgInt32(sizeof(deleteEdge) / sizeof(deleteEdge[0])));
- _ASSERTE(stackFace->m_next->m_next->m_next == stackFace);
+ NEWTON_ASSERT(deleteCount < dgInt32(sizeof(deleteEdge) / sizeof(deleteEdge[0])));
+ NEWTON_ASSERT(stackFace->m_next->m_next->m_next == stackFace);
dgEdge *edge = stackFace;
do {
@@ -3022,7 +3022,7 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
do {
ptr1->m_mark = faceMark;
faceIndex[faceIndexCount] = ptr1->m_incidentVertex;
- _ASSERTE(
+ NEWTON_ASSERT(
faceIndexCount < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
faceIndexCount++;
ptr1 = ptr1->m_next;
@@ -3033,7 +3033,7 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
if (dot < dgFloat64(1.0e-12f)) {
deleteEdge[deleteCount] = ptr;
deleteCount++;
- _ASSERTE(
+ NEWTON_ASSERT(
deleteCount < dgInt32(sizeof(deleteEdge) / sizeof(deleteEdge[0])));
} else {
//normal1 = normal1.Scale (dgFloat64 (1.0f) / sqrt (dot));
@@ -3060,7 +3060,7 @@ void dgPolyhedra::MarkAdjacentCoplanarFaces(dgPolyhedra &polyhedraOut,
;
stack[index] = ptr;
index++;
- _ASSERTE(index < dgInt32(sizeof(stack) / sizeof(stack[0])));
+ NEWTON_ASSERT(index < dgInt32(sizeof(stack) / sizeof(stack[0])));
}
}
}
@@ -3240,14 +3240,14 @@ void dgPolyhedra::RefineTriangulation(const dgFloat64 *const vertex,
do {
edgePerimeters[perimeterCount] = ptr->m_twin;
perimeterCount++;
- _ASSERTE(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
+ NEWTON_ASSERT(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
ptr = ptr->m_prev;
} while (ptr != edge);
break;
}
}
- _ASSERTE(perimeterCount);
- _ASSERTE(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
+ NEWTON_ASSERT(perimeterCount);
+ NEWTON_ASSERT(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
edgePerimeters[perimeterCount] = edgePerimeters[0];
dgBigVector normal(FaceNormal(edgePerimeters[0], vertex, dgInt32(stride * sizeof(dgFloat64))));
@@ -3275,11 +3275,11 @@ void dgPolyhedra::OptimizeTriangulation(const dgFloat64 *const vertex,
if (edge->m_incidentFace > 0) {
dgPolyhedra flatFace(GetAllocator());
MarkAdjacentCoplanarFaces(flatFace, edge, vertex, strideInBytes);
- //_ASSERTE (flatFace.GetCount());
+ //NEWTON_ASSERT (flatFace.GetCount());
if (flatFace.GetCount()) {
//flatFace.Triangulate (vertex, strideInBytes, &leftOver);
- //_ASSERTE (!leftOver.GetCount());
+ //NEWTON_ASSERT (!leftOver.GetCount());
flatFace.RefineTriangulation(vertex, stride);
dgInt32 mark = flatFace.IncLRU();
@@ -3293,7 +3293,7 @@ void dgPolyhedra::OptimizeTriangulation(const dgFloat64 *const vertex,
do {
polygon[vertexCount] = ptr->m_incidentVertex;
vertexCount++;
- _ASSERTE(vertexCount < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
+ NEWTON_ASSERT(vertexCount < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
ptr->m_mark = mark;
ptr = ptr->m_next;
} while (ptr != edgeFF);
@@ -3308,7 +3308,7 @@ void dgPolyhedra::OptimizeTriangulation(const dgFloat64 *const vertex,
}
}
buildConvex.EndFace();
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
SwapInfo(buildConvex);
}
@@ -3347,7 +3347,7 @@ void dgPolyhedra::Triangulate(const dgFloat64 *const vertex,
heap.Flush();
if (edge) {
- _ASSERTE(edge->m_incidentFace > 0);
+ NEWTON_ASSERT(edge->m_incidentFace > 0);
if (leftOver) {
dgInt32 *const index = (dgInt32 *) &heap[0];
@@ -3389,7 +3389,7 @@ void dgPolyhedra::Triangulate(const dgFloat64 *const vertex,
if (edge->m_incidentFace < 0) {
continue;
}
- _ASSERTE(edge == edge->m_next->m_next->m_next);
+ NEWTON_ASSERT(edge == edge->m_next->m_next->m_next);
for (dgInt32 i = 0; i < 3; i++) {
edge->m_incidentFace = m_faceSecuence;
@@ -3417,7 +3417,7 @@ static void RemoveColinearVertices(dgPolyhedra &flatFace,
} while (ptr != edge);
edgePerimeters[perimeterCount] = edge;
perimeterCount++;
- _ASSERTE(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
+ NEWTON_ASSERT(perimeterCount < dgInt32(sizeof(edgePerimeters) / sizeof(edgePerimeters[0])));
}
}
@@ -3444,11 +3444,11 @@ static void RemoveColinearVertices(dgPolyhedra &flatFace,
}
if (ptr->m_twin->m_next->m_next->m_next == ptr->m_twin) {
- _ASSERTE(ptr->m_twin->m_next->m_incidentFace > 0);
+ NEWTON_ASSERT(ptr->m_twin->m_next->m_incidentFace > 0);
flatFace.DeleteEdge(ptr->m_twin->m_next);
}
- _ASSERTE(ptr->m_next->m_twin->m_next->m_twin == ptr);
+ NEWTON_ASSERT(ptr->m_next->m_twin->m_next->m_twin == ptr);
edge = ptr->m_next;
if (!flatFace.FindEdge(ptr->m_incidentVertex,
@@ -3499,7 +3499,7 @@ static dgInt32 GetInteriorDiagonals(dgPolyhedra &polyhedra,
diagonals[count] = edge;
count++;
}
- _ASSERTE(count <= maxCount);
+ NEWTON_ASSERT(count <= maxCount);
}
}
}
@@ -3584,7 +3584,7 @@ void dgPolyhedra::ConvexPartition(const dgFloat64 *const vertex,
if (edge->m_incidentFace < 0) {
edge = edge->m_twin;
}
- _ASSERTE(edge->m_incidentFace > 0);
+ NEWTON_ASSERT(edge->m_incidentFace > 0);
dgBigVector normal(FaceNormal(edge, vertex, strideInBytes));
normal = normal.Scale(dgFloat64(1.0f) / sqrt(normal % normal));
@@ -3597,7 +3597,7 @@ void dgPolyhedra::ConvexPartition(const dgFloat64 *const vertex,
break;
}
}
- _ASSERTE(edge);
+ NEWTON_ASSERT(edge);
dgInt32 isConvex = 1;
dgEdge *ptr = edge;
@@ -3645,7 +3645,7 @@ void dgPolyhedra::ConvexPartition(const dgFloat64 *const vertex,
do {
polygon[count] = ptr->m_incidentVertex;
count++;
- _ASSERTE(count < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
ptr = ptr->m_next;
} while (ptr != edge);
@@ -3689,7 +3689,7 @@ void dgPolyhedra::ConvexPartition(const dgFloat64 *const vertex,
do {
polygon[diagonalCountTemp] = ptr->m_incidentVertex;
diagonalCountTemp++;
- _ASSERTE(diagonalCountTemp < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
+ NEWTON_ASSERT(diagonalCountTemp < dgInt32(sizeof(polygon) / sizeof(polygon[0])));
ptr->m_mark = mark;
ptr = ptr->m_next;
} while (ptr != edgeFLF);
@@ -3705,7 +3705,7 @@ void dgPolyhedra::ConvexPartition(const dgFloat64 *const vertex,
}
buildConvex.EndFace();
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
SwapInfo(buildConvex);
}
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.h b/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.h
index edf4bf604e0..00a2c00b83c 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgPolyhedra.h
@@ -280,7 +280,7 @@ inline dgInt32 dgPolyhedra::GetEdgeCount() const {
for (iter.Begin(); iter; iter ++) {
edgeCount ++;
}
- _ASSERTE(edgeCount == GetCount());;
+ NEWTON_ASSERT(edgeCount == GetCount());;
#endif
return GetCount();
}
@@ -300,7 +300,7 @@ inline dgInt32 dgPolyhedra::GetLastVertexIndex() const {
inline dgInt32 dgPolyhedra::IncLRU() const {
m_edgeMark ++;
- _ASSERTE(m_edgeMark < 0x7fffffff);
+ NEWTON_ASSERT(m_edgeMark < 0x7fffffff);
return m_edgeMark;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgQuaternion.cpp b/engines/hpl1/engine/libraries/newton/core/dgQuaternion.cpp
index f5efc8961cc..c9ac97b776a 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgQuaternion.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgQuaternion.cpp
@@ -73,11 +73,11 @@ dgQuaternion::dgQuaternion(const dgMatrix &matrix) {
dgMatrix unitMatrix(tmp * matrix.Inverse());
for (dgInt32 i = 0; i < 4; i++) {
dgFloat32 err = dgAbsf(unitMatrix[i][i] - dgFloat32(1.0f));
- _ASSERTE(err < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(err < dgFloat32(1.0e-2f));
}
dgFloat32 err = dgAbsf(DotProduct(*this) - dgFloat32(1.0f));
- _ASSERTE(err < dgFloat32(dgEPSILON * 100.0f));
+ NEWTON_ASSERT(err < dgFloat32(dgEPSILON * 100.0f));
#endif
}
@@ -90,7 +90,7 @@ dgQuaternion::dgQuaternion(const dgVector &unitAxis, dgFloat32 Angle) {
#ifdef _DEBUG
if (dgAbsf(Angle) > dgFloat32(dgEPSILON / 10.0f)) {
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - unitAxis % unitAxis) < dgFloat32(dgEPSILON * 10.0f));
}
#endif
@@ -102,7 +102,7 @@ dgQuaternion::dgQuaternion(const dgVector &unitAxis, dgFloat32 Angle) {
dgVector dgQuaternion::CalcAverageOmega(const dgQuaternion &QB,
dgFloat32 dt) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(0, 0, 0, 0);
/*
dgFloat32 dirMag;
@@ -110,7 +110,7 @@ dgVector dgQuaternion::CalcAverageOmega(const dgQuaternion &QB,
dgFloat32 omegaMag;
dgFloat32 dirMagInv;
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
dgQuaternion dq (Inverse() * QB);
// dgQuaternion dq (QB * Inverse());
dgVector omegaDir (dq.m_q1, dq.m_q2, dq.m_q3, dgFloat32 (0.0f));
@@ -130,7 +130,7 @@ dgVector dgQuaternion::CalcAverageOmega(const dgQuaternion &QB,
}
dgQuaternion dgQuaternion::Slerp(const dgQuaternion &QB, dgFloat32 t) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgQuaternion();
/*
dgFloat32 dot;
diff --git a/engines/hpl1/engine/libraries/newton/core/dgQuaternion.h b/engines/hpl1/engine/libraries/newton/core/dgQuaternion.h
index 34ed60b2994..72fe658aaf5 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgQuaternion.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgQuaternion.h
@@ -68,7 +68,7 @@ inline dgQuaternion::dgQuaternion(dgFloat32 Q0, dgFloat32 Q1, dgFloat32 Q2, dgFl
m_q1 = Q1;
m_q2 = Q2;
m_q3 = Q3;
-// _ASSERTE (dgAbsf (DotProduct (*this) -dgFloat32 (1.0f)) < dgFloat32(1.0e-4f));
+// NEWTON_ASSERT (dgAbsf (DotProduct (*this) -dgFloat32 (1.0f)) < dgFloat32(1.0e-4f));
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgRef.h b/engines/hpl1/engine/libraries/newton/core/dgRef.h
index 4b4af21d2b3..fd1d324fee2 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgRef.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgRef.h
@@ -128,7 +128,7 @@ inline dgRef::~dgRef() {
inline dgRef *dgRef::AddRef() {
m_ref ++;
- _ASSERTE(m_ref < ((1 << 24) - 1));
+ NEWTON_ASSERT(m_ref < ((1 << 24) - 1));
return this;
}
@@ -142,7 +142,7 @@ inline dgInt32 dgRef::Release() {
}
inline dgRef *dgRef::CreateClone() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return NULL;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgRefCounter.h b/engines/hpl1/engine/libraries/newton/core/dgRefCounter.h
index db1e3094c61..e5951fc51bb 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgRefCounter.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgRefCounter.h
@@ -42,7 +42,7 @@ inline dgRefCounter::dgRefCounter(void) {
}
inline dgRefCounter::~dgRefCounter(void) {
- _ASSERTE(m_refCount <= 1);
+ NEWTON_ASSERT(m_refCount <= 1);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgSPDMatrix.cpp b/engines/hpl1/engine/libraries/newton/core/dgSPDMatrix.cpp
index 889ee5dde30..96e3fb1d411 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgSPDMatrix.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgSPDMatrix.cpp
@@ -47,8 +47,8 @@
return CholeskyDecomposition (rows, size);
} else {
- _ASSERTE (0);
- _ASSERTE (typeSizeInBytes == sizeof (dgFloat64));
+ NEWTON_ASSERT (0);
+ NEWTON_ASSERT (typeSizeInBytes == sizeof (dgFloat64));
}
return true;
@@ -77,8 +77,8 @@
BackAndForwardSustitition (rows, size, (dgFloat32*)rightsideVector);
} else {
- _ASSERTE (0);
- _ASSERTE (typeSizeInBytes == sizeof (dgFloat64));
+ NEWTON_ASSERT (0);
+ NEWTON_ASSERT (typeSizeInBytes == sizeof (dgFloat64));
}
}
*/
@@ -109,8 +109,8 @@
return true;
}
} else {
- _ASSERTE (0);
- _ASSERTE (typeSizeInBytes == sizeof (dgFloat64));
+ NEWTON_ASSERT (0);
+ NEWTON_ASSERT (typeSizeInBytes == sizeof (dgFloat64));
}
return false;
diff --git a/engines/hpl1/engine/libraries/newton/core/dgSphere.cpp b/engines/hpl1/engine/libraries/newton/core/dgSphere.cpp
index 0a02e3a095e..c975cf98f0f 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgSphere.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgSphere.cpp
@@ -260,7 +260,7 @@ static void Statistics(dgSphere &sphere, dgVector &eigenValues,
const dgFace face[],
dgInt32 faceCount)
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
dgInt32 i;
dgInt32 index;
@@ -358,7 +358,7 @@ static void Statistics(dgSphere &sphere, dgVector &eigenValues,
dgSphere::dgSphere() :
dgMatrix(dgGetIdentityMatrix()), m_size(0, 0, 0, 0) {
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// planeTest = FrontTest;
}
@@ -366,14 +366,14 @@ dgSphere::dgSphere(const dgQuaternion &quat, const dgVector &position,
const dgVector &dim) :
dgMatrix(quat, position) {
SetDimensions(dim.m_x, dim.m_y, dim.m_z);
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// planeTest = FrontTest;
}
dgSphere::dgSphere(const dgMatrix &matrix, const dgVector &dim) :
dgMatrix(matrix) {
SetDimensions(dim.m_x, dim.m_y, dim.m_z);
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
// planeTest = FrontTest;
}
@@ -798,7 +798,7 @@ void dgSphere::SetDimensions(const dgFloat32 vertex[], dgInt32 strideInBytes,
code = 0;
for (i = 0; i < 6; i ++) {
code |= (this->*planeTestArray[i]) (matrix, guardPlanes);
- _ASSERTE (code >= 0);
+ NEWTON_ASSERT (code >= 0);
if (code) {
return code;
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgStack.h b/engines/hpl1/engine/libraries/newton/core/dgStack.h
index d91ae714254..32f72dbdb84 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgStack.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgStack.h
@@ -85,8 +85,8 @@ template<class T>
T &dgStack<T>::operator[](dgInt32 entry) {
T *mem;
- _ASSERTE(entry >= 0);
- _ASSERTE((entry < m_size) || ((m_size == 0) && (entry == 0)));
+ NEWTON_ASSERT(entry >= 0);
+ NEWTON_ASSERT((entry < m_size) || ((m_size == 0) && (entry == 0)));
mem = (T *) m_ptr;
return mem[entry];
@@ -96,9 +96,9 @@ template<class T>
const T &dgStack<T>::operator[](dgInt32 entry) const {
T *mem;
- _ASSERTE(0);
- _ASSERTE(entry >= 0);
- _ASSERTE((entry < m_size) || ((m_size == 0) && (entry == 0)));
+ NEWTON_ASSERT(0);
+ NEWTON_ASSERT(entry >= 0);
+ NEWTON_ASSERT((entry < m_size) || ((m_size == 0) && (entry == 0)));
mem = (T *) m_ptr;
return mem[entry];
diff --git a/engines/hpl1/engine/libraries/newton/core/dgThreads.cpp b/engines/hpl1/engine/libraries/newton/core/dgThreads.cpp
index 511a2e780e3..a460843fa0c 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgThreads.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgThreads.cpp
@@ -82,7 +82,7 @@ void dgThreads::DestroydgThreads() {
//Queues up another to work
dgInt32 dgThreads::SubmitJob(dgWorkerThread *const job) {
- _ASSERTE(job->m_threadIndex != -1);
+ NEWTON_ASSERT(job->m_threadIndex != -1);
job->ThreadExecute();
return 1;
}
@@ -127,7 +127,7 @@ void dgThreads::CalculateChunkSizes(dgInt32 elements,
}
void dgThreads::dgGetLock() const {
- _ASSERTE(sizeof(dgInt32) == sizeof(long));
+ NEWTON_ASSERT(sizeof(dgInt32) == sizeof(long));
//spinLock( &m_globalSpinLock );
// linux and mac may need to yeald time
@@ -141,10 +141,10 @@ void dgThreads::dgReleaseLock() const {
}
void dgThreads::dgGetIndirectLock(dgInt32 *lockVar) {
- _ASSERTE(sizeof(dgInt32) == sizeof(long));
+ NEWTON_ASSERT(sizeof(dgInt32) == sizeof(long));
}
void dgThreads::dgReleaseIndirectLock(dgInt32 *lockVar) {
- _ASSERTE(sizeof(dgInt32) == sizeof(long));
+ NEWTON_ASSERT(sizeof(dgInt32) == sizeof(long));
dgSpinUnlock(lockVar);
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTree.cpp b/engines/hpl1/engine/libraries/newton/core/dgTree.cpp
index 094114a4db6..fe540efd342 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTree.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgTree.cpp
@@ -199,7 +199,7 @@ void dgRedBackNode::InsertFixup(dgRedBackNode **const head) {
}
}
} else {
- _ASSERTE(ptr->m_parent == ptr->m_parent->m_parent->m_right);
+ NEWTON_ASSERT(ptr->m_parent == ptr->m_parent->m_parent->m_right);
// mirror image of above code
dgRedBackNode *const tmp = ptr->m_parent->m_parent->m_left;
if (tmp && (tmp->GetColor() == RED)) {
@@ -374,14 +374,14 @@ void dgRedBackNode::Unlink(dgRedBackNode **const head) {
endNode = endNode->m_left;
}
- _ASSERTE(endNode);
- _ASSERTE(endNode->m_parent);
- _ASSERTE(!endNode->m_left);
+ NEWTON_ASSERT(endNode);
+ NEWTON_ASSERT(endNode->m_parent);
+ NEWTON_ASSERT(!endNode->m_left);
// x is y's only child
dgRedBackNode *const child = endNode->m_right;
- _ASSERTE(
+ NEWTON_ASSERT(
(endNode != node->m_right) || !child || (child->m_parent == endNode));
endNode->m_left = node->m_left;
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTree.h b/engines/hpl1/engine/libraries/newton/core/dgTree.h
index 3190ce27952..cf0a0c79f5c 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTree.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgTree.h
@@ -93,7 +93,7 @@ public:
const KEY &key,
dgTreeNode *parentNode)
: dgRedBackNode(parentNode), m_info(info), m_key(key) {
-// _ASSERTE ((dgUnsigned64 (&m_info) & 0x0f) == 0);
+// NEWTON_ASSERT ((dgUnsigned64 (&m_info) & 0x0f) == 0);
}
~dgTreeNode() {
@@ -171,22 +171,22 @@ public:
}
void operator++ () {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->Next();
}
void operator++ (dgInt32) {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->Next();
}
void operator-- () {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->Prev();
}
void operator-- (dgInt32) {
- _ASSERTE(m_ptr);
+ NEWTON_ASSERT(m_ptr);
m_ptr = m_ptr->Prev();
}
@@ -371,13 +371,13 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::Find(KEY key) con
dgTreeNode *ptr = m_head;
while (ptr != NULL) {
if (key < ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == -1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == -1) ;
ptr = ptr->GetLeft();
} else if (key > ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 1) ;
ptr = ptr->GetRight();
} else {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 0) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 0) ;
break;
}
}
@@ -390,8 +390,8 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::GetNodeFromInfo(O
dgInt64 offset = ((char *) &node->m_info) - ((char *) node);
dgTreeNode *const retnode = (dgTreeNode *)(((char *) node) - offset);
- _ASSERTE(retnode->IsInTree());
- _ASSERTE(&retnode->GetInfo() == &info);
+ NEWTON_ASSERT(retnode->IsInTree());
+ NEWTON_ASSERT(&retnode->GetInfo() == &info);
return (retnode->IsInTree()) ? retnode : NULL;
}
@@ -419,11 +419,11 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::FindGreater(KEY k
Iterator iter(*this);
for (iter.Begin(); iter.GetNode() != prev; iter ++) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 <= key);
+ NEWTON_ASSERT(key1 <= key);
}
for (; iter.GetNode(); iter ++) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 > key);
+ NEWTON_ASSERT(key1 > key);
}
}
#endif
@@ -457,11 +457,11 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::FindGreaterEqual(
Iterator iter(*this);
for (iter.Begin(); iter.GetNode() != prev; iter ++) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 <= key);
+ NEWTON_ASSERT(key1 <= key);
}
for (; iter.GetNode(); iter ++) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 >= key);
+ NEWTON_ASSERT(key1 >= key);
}
}
#endif
@@ -497,11 +497,11 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::FindLessEqual(KEY
Iterator iter(*this);
for (iter.End(); iter.GetNode() != prev; iter --) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 >= key);
+ NEWTON_ASSERT(key1 >= key);
}
for (; iter.GetNode(); iter --) {
KEY key1 = iter.GetKey();
- _ASSERTE(key1 < key);
+ NEWTON_ASSERT(key1 < key);
}
}
#endif
@@ -519,22 +519,22 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::Insert(const OBJE
parent = ptr;
if (key < ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == -1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == -1) ;
val = -1;
ptr = ptr->GetLeft();
} else if (key > ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 1) ;
val = 1;
ptr = ptr->GetRight();
} else {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 0) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 0) ;
elementWasInTree = true;
return ptr;
}
}
m_count ++;
- _ASSERTE(m_allocator);
+ NEWTON_ASSERT(m_allocator);
ptr = new (m_allocator) dgTreeNode(element, key, parent);
if (!parent) {
m_head = ptr;
@@ -580,15 +580,15 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::Insert(typename d
// }
if (key < ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == -1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == -1) ;
val = -1;
ptr = ptr->GetLeft();
} else if (key > ptr->m_key) {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 1) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 1) ;
val = 1;
ptr = ptr->GetRight();
} else {
- _ASSERTE(CompareKeys(ptr->m_key, key) == 0) ;
+ NEWTON_ASSERT(CompareKeys(ptr->m_key, key) == 0) ;
return NULL;
}
}
@@ -624,7 +624,7 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::Replace(OBJECT &e
while (ptr != NULL) {
parent = ptr;
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
val = CompareKeys(ptr->m_key, key);
if (val == 0) {
ptr->m_info = element;
@@ -637,7 +637,7 @@ typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::Replace(OBJECT &e
}
}
- _ASSERTE(m_allocator);
+ NEWTON_ASSERT(m_allocator);
ptr = new (m_allocator) dgTreeNode(element, key, parent);
if (!parent) {
m_head = ptr;
@@ -660,7 +660,7 @@ template<class OBJECT, class KEY>
typename dgTree<OBJECT, KEY>::dgTreeNode *dgTree<OBJECT, KEY>::ReplaceKey(typename dgTree<OBJECT, KEY>::dgTreeNode *const node, KEY key) {
Unlink(node);
dgTreeNode *const ptr = Insert(node, key);
- _ASSERTE(ptr);
+ NEWTON_ASSERT(ptr);
return ptr;
}
@@ -676,7 +676,7 @@ void dgTree<OBJECT, KEY>::Unlink(typename dgTree<OBJECT, KEY>::dgTreeNode *const
dgTreeNode **const headPtr = (dgTreeNode **) &m_head;
node->Unlink((dgRedBackNode **)headPtr);
- _ASSERTE(!Find(node->GetKey()));
+ NEWTON_ASSERT(!Find(node->GetKey()));
}
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp b/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
index 2074198a28d..3048817f3ba 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
+++ b/engines/hpl1/engine/libraries/newton/core/dgTypes.cpp
@@ -31,7 +31,7 @@ void GetMinMax(dgVector &minOut, dgVector &maxOut,
dgInt32 stride = dgInt32(strideInBytes / sizeof(dgFloat32));
const dgFloat32 *vArray = vertexArray + stride;
- _ASSERTE(stride >= 3);
+ NEWTON_ASSERT(stride >= 3);
minOut = dgVector(vertexArray[0], vertexArray[1], vertexArray[2],
dgFloat32(0.0f));
maxOut = dgVector(vertexArray[0], vertexArray[1], vertexArray[2],
@@ -55,7 +55,7 @@ void GetMinMax(dgBigVector &minOut, dgBigVector &maxOut,
dgInt32 stride = dgInt32(strideInBytes / sizeof(dgFloat64));
const dgFloat64 *vArray = vertexArray + stride;
- _ASSERTE(stride >= 3);
+ NEWTON_ASSERT(stride >= 3);
minOut = dgBigVector(vertexArray[0], vertexArray[1], vertexArray[2],
dgFloat64(0.0f));
maxOut = dgBigVector(vertexArray[0], vertexArray[1], vertexArray[2],
@@ -356,7 +356,7 @@ static dgInt32 SortVertices(dgFloat64 *const vertexList, dgInt32 stride,
stack[stackIndex][1] = j;
stackIndex++;
}
- _ASSERTE(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
+ NEWTON_ASSERT(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
} else {
for (dgInt32 i = lo + 1; i <= hi; i++) {
dgFloat64 tmp[64];
@@ -377,7 +377,7 @@ static dgInt32 SortVertices(dgFloat64 *const vertexList, dgInt32 stride,
#ifdef _DEBUG
for (dgInt32 i = 0; i < (vertexCount - 1); i++) {
- _ASSERTE(
+ NEWTON_ASSERT(
cmp_vertex(&vertexList[i * stride], &vertexList[(i + 1) * stride], firstSortAxis) <= 0);
}
#endif
@@ -473,7 +473,7 @@ static dgInt32 QuickSortVertices(dgFloat64 *const vertList, dgInt32 stride,
i1--;
}
} while (i0 <= i1);
- _ASSERTE(i0 < vertexCount);
+ NEWTON_ASSERT(i0 < vertexCount);
dgInt32 count0 = QuickSortVertices(&vertList[0 * stride], stride,
compareCount, i0, tolerance);
@@ -515,8 +515,8 @@ dgInt32 dgVertexListToIndexList(dgFloat64 *const vertList,
if (compareCount < 3) {
return 0;
}
- _ASSERTE(compareCount <= dgInt32(strideInBytes / sizeof(dgFloat64)));
- _ASSERTE(strideInBytes == dgInt32(sizeof(dgFloat64) * (strideInBytes / sizeof(dgFloat64))));
+ NEWTON_ASSERT(compareCount <= dgInt32(strideInBytes / sizeof(dgFloat64)));
+ NEWTON_ASSERT(strideInBytes == dgInt32(sizeof(dgFloat64) * (strideInBytes / sizeof(dgFloat64))));
dgInt32 stride = strideInBytes / dgInt32(sizeof(dgFloat64));
dgInt32 stride2 = stride + 2;
@@ -570,7 +570,7 @@ dgInt32 dgVertexListToIndexList(dgFloat32 *const vertList,
dgFloat32 tolerance) {
dgInt32 stride = strideInBytes / sizeof(dgFloat32);
- _ASSERTE(!unsignedSizeInBytes);
+ NEWTON_ASSERT(!unsignedSizeInBytes);
dgStack<dgFloat64> pool(vertexCount * stride);
dgInt32 floatCount = floatSizeInBytes / sizeof(dgFloat32);
diff --git a/engines/hpl1/engine/libraries/newton/core/dgTypes.h b/engines/hpl1/engine/libraries/newton/core/dgTypes.h
index 83eef5b7351..b5dc57df72a 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgTypes.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgTypes.h
@@ -219,6 +219,8 @@ class dgBigVector;
#endif
#endif
+#define NEWTON_ASSERT(x) ((void)(x))
+
DG_INLINE dgInt32 exp_2(dgInt32 x) {
dgInt32 exp;
@@ -303,8 +305,8 @@ dgInt32 dgBinarySearch(T const *array, dgInt32 elements, dgInt32 entry) {
entry1 = array[index1].m_Key;
if (entry1 == entry) {
- _ASSERTE(array[index1].m_Key <= entry);
- _ASSERTE(array[index1 + 1].m_Key >= entry);
+ NEWTON_ASSERT(array[index1].m_Key <= entry);
+ NEWTON_ASSERT(array[index1 + 1].m_Key >= entry);
return index1;
} else if (entry < entry1) {
@@ -318,8 +320,8 @@ dgInt32 dgBinarySearch(T const *array, dgInt32 elements, dgInt32 entry) {
index0--;
}
- _ASSERTE(array[index0].m_Key <= entry);
- _ASSERTE(array[index0 + 1].m_Key >= entry);
+ NEWTON_ASSERT(array[index0].m_Key <= entry);
+ NEWTON_ASSERT(array[index0 + 1].m_Key >= entry);
return index0;
}
@@ -334,8 +336,8 @@ void dgRadixSort(T *const array,
dgInt32 scanCount[256];
dgInt32 histogram[256][4];
- _ASSERTE(radixPass >= 1);
- _ASSERTE(radixPass <= 4);
+ NEWTON_ASSERT(radixPass >= 1);
+ NEWTON_ASSERT(radixPass <= 4);
memset(histogram, 0, sizeof(histogram));
@@ -386,7 +388,7 @@ void dgRadixSort(T *const array,
#ifdef _DEBUG
for (dgInt32 i = 0; i < (elements - 1); i++) {
- _ASSERTE(getRadixKey(&array[i], context) <= getRadixKey(&array[i + 1], context));
+ NEWTON_ASSERT(getRadixKey(&array[i], context) <= getRadixKey(&array[i + 1], context));
}
#endif
}
@@ -439,7 +441,7 @@ void dgSort(T *const array,
stack[stackIndex][1] = j;
stackIndex++;
}
- _ASSERTE(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
+ NEWTON_ASSERT(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
}
}
@@ -463,7 +465,7 @@ void dgSort(T *const array,
// for (; j && (compare (&array[j - 1], &tmp, context) > 0); j --) {
for (; compare(&array[j - 1], &tmp, context) > 0; j--) {
- _ASSERTE(j > 0);
+ NEWTON_ASSERT(j > 0);
array[j] = array[j - 1];
}
@@ -472,7 +474,7 @@ void dgSort(T *const array,
#ifdef _DEBUG
for (dgInt32 i = 0; i < (elements - 1); i++) {
- _ASSERTE(compare(&array[i], &array[i + 1], context) <= 0);
+ NEWTON_ASSERT(compare(&array[i], &array[i + 1], context) <= 0);
}
#endif
}
@@ -525,7 +527,7 @@ void dgSortIndirect(T **const array,
stack[stackIndex][1] = j;
stackIndex++;
}
- _ASSERTE(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
+ NEWTON_ASSERT(stackIndex < dgInt32(sizeof(stack) / (2 * sizeof(stack[0][0]))));
}
}
@@ -549,7 +551,7 @@ void dgSortIndirect(T **const array,
// for (; j && (compare (array[j - 1], tmp, context) > 0); j --) {
for (; compare(array[j - 1], tmp, context) > 0; j--) {
- _ASSERTE(j > 0);
+ NEWTON_ASSERT(j > 0);
array[j] = array[j - 1];
}
@@ -558,7 +560,7 @@ void dgSortIndirect(T **const array,
#ifdef _DEBUG
for (dgInt32 i = 0; i < (elements - 1); i++) {
- _ASSERTE(compare(array[i], array[i + 1], context) <= 0);
+ NEWTON_ASSERT(compare(array[i], array[i + 1], context) <= 0);
}
#endif
}
@@ -637,7 +639,7 @@ DG_INLINE dgFloat32 dgAbsf(dgFloat32 x) {
dgDoubleInt val;
val.m_float = x;
val.m_intH &= ~(dgUnsigned64(1) << 31);
- _ASSERTE(val.m_float == fabs(x));
+ NEWTON_ASSERT(val.m_float == fabs(x));
return dgFloat32(val.m_float);
#else
@@ -666,7 +668,7 @@ DG_INLINE dgInt32 dgFastInt(dgFloat32 x) {
val.m_float = dgFloat64(x) + conversionMagicConst;
round.m_float = x - dgFloat64(val.m_intL);
dgInt32 ret = val.m_intL + (round.m_intH >> 31);
- _ASSERTE(ret == dgInt32(floor(x)));
+ NEWTON_ASSERT(ret == dgInt32(floor(x)));
return ret;
#else
@@ -683,7 +685,7 @@ DG_INLINE dgInt32 dgFastInt(dgFloat32 x) {
DG_INLINE dgFloat32 dgFloor(dgFloat32 x) {
#ifdef _MSC_VER
dgFloat32 ret = dgFloat32(dgFastInt(x));
- _ASSERTE(ret == floor(x));
+ NEWTON_ASSERT(ret == floor(x));
return ret;
#else
@@ -699,7 +701,7 @@ DG_INLINE dgFloat32 dgCeil(dgFloat32 x) {
ret += dgFloat32(1.0f);
}
- _ASSERTE(ret == ceil(x));
+ NEWTON_ASSERT(ret == ceil(x));
return ret;
#else
diff --git a/engines/hpl1/engine/libraries/newton/core/dgVector.h b/engines/hpl1/engine/libraries/newton/core/dgVector.h
index 0c958ea518e..6720330bb5b 100644
--- a/engines/hpl1/engine/libraries/newton/core/dgVector.h
+++ b/engines/hpl1/engine/libraries/newton/core/dgVector.h
@@ -123,7 +123,7 @@ dgTemplateVector<T>::dgTemplateVector() {}
template<class T>
dgTemplateVector<T>::dgTemplateVector(const T *ptr)
: m_x(ptr[0]), m_y(ptr[1]), m_z(ptr[2]), m_w(0.0f) {
-// _ASSERTE (dgCheckVector ((*this)));
+// NEWTON_ASSERT (dgCheckVector ((*this)));
}
template<class T>
@@ -134,15 +134,15 @@ constexpr dgTemplateVector<T>::dgTemplateVector(T x, T y, T z, T w)
template<class T>
T &dgTemplateVector<T>::operator[](dgInt32 i) {
- _ASSERTE(i < 4);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < 4);
+ NEWTON_ASSERT(i >= 0);
return (&m_x)[i];
}
template<class T>
const T &dgTemplateVector<T>::operator[](dgInt32 i) const {
- _ASSERTE(i < 4);
- _ASSERTE(i >= 0);
+ NEWTON_ASSERT(i < 4);
+ NEWTON_ASSERT(i >= 0);
return (&m_x)[i];
}
@@ -167,7 +167,7 @@ dgTemplateVector<T> &dgTemplateVector<T>::operator+= (const dgTemplateVector<T>
m_x += A.m_x;
m_y += A.m_y;
m_z += A.m_z;
-// _ASSERTE (dgCheckVector ((*this)));
+// NEWTON_ASSERT (dgCheckVector ((*this)));
return *this;
}
@@ -181,7 +181,7 @@ dgTemplateVector<T> &dgTemplateVector<T>::operator-= (const dgTemplateVector<T>
m_x -= A.m_x;
m_y -= A.m_y;
m_z -= A.m_z;
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
return *this;
}
@@ -274,24 +274,24 @@ DG_INLINE dgVector::dgVector()
DG_INLINE dgVector::dgVector(const dgTemplateVector<dgFloat32> &v)
: dgTemplateVector<dgFloat32>(v) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
DG_INLINE dgVector::dgVector(const dgFloat32 *ptr)
: dgTemplateVector<dgFloat32>(ptr) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
DG_INLINE dgVector::dgVector(const dgBigVector ©)
: dgTemplateVector<dgFloat32>(dgFloat32(copy.m_x), dgFloat32(copy.m_y), dgFloat32(copy.m_z), dgFloat32(copy.m_w)) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
#ifdef DG_BUILD_SIMD_CODE
DG_INLINE dgVector::dgVector(const simd_type &val) {
- _ASSERTE((dgUnsigned64(this) & 0x0f) == 0);
+ NEWTON_ASSERT((dgUnsigned64(this) & 0x0f) == 0);
(simd_type &) *this = val;
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
#endif
@@ -340,29 +340,29 @@ DG_INLINE dgBigVector::dgBigVector()
DG_INLINE dgBigVector::dgBigVector(const dgVector &v)
: dgTemplateVector<dgFloat64>(v.m_x, v.m_y, v.m_z, v.m_w) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
DG_INLINE dgBigVector::dgBigVector(const dgTemplateVector<dgFloat64> &v)
: dgTemplateVector<dgFloat64>(v) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
DG_INLINE dgBigVector::dgBigVector(const dgFloat32 *ptr)
: dgTemplateVector<dgFloat64>(ptr[0], ptr[1], ptr[2], dgFloat64(0.0f)) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
#ifndef __USE_DOUBLE_PRECISION__
DG_INLINE dgBigVector::dgBigVector(const dgFloat64 *ptr)
: dgTemplateVector<dgFloat64>(ptr) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
#endif
DG_INLINE dgBigVector::dgBigVector(dgFloat64 x, dgFloat64 y, dgFloat64 z, dgFloat64 w)
: dgTemplateVector<dgFloat64>(x, y, z, w) {
- _ASSERTE(dgCheckVector((*this)));
+ NEWTON_ASSERT(dgCheckVector((*this)));
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.cpp
index ec6f396ba5a..f073d1cb3ad 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBallConstraint.cpp
@@ -33,7 +33,7 @@ dgBallConstraint::dgBallConstraint() : dgBilateralConstraint() {
// dgBallConstraintArray& array = * world;
// constraint = array.GetElement();
- _ASSERTE((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
// constraint->SetStiffness (dgFloat32 (0.5f));
m_maxDOF = 6;
@@ -55,7 +55,7 @@ dgBallConstraint::~dgBallConstraint() {
dgBallConstraintArray& array = * world;
constraint = array.GetElement();
- _ASSERTE ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
constraint->Init();
@@ -86,8 +86,8 @@ dgVector dgBallConstraint::GetJointAngle() const {
}
dgVector dgBallConstraint::GetJointOmega() const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &matrix = m_body0->GetMatrix();
dgVector dir0(matrix.RotateVector(m_localMatrix0[0]));
@@ -141,8 +141,8 @@ void dgBallConstraint::SetLatealLimitState(bool state) {
}
void dgBallConstraint::SetPivotPoint(const dgVector &pivot) {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &matrix = m_body0->GetMatrix();
dgVector pin(pivot - matrix.m_posit);
@@ -168,8 +168,8 @@ void dgBallConstraint::SetLimits(const dgVector &coneDir,
dgMatrix matrix1;
CalculateGlobalMatrixAndAngle(matrix0, matrix1);
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &body0_Matrix = m_body0->GetMatrix();
dgVector lateralDir(bilateralDir * coneDir);
@@ -258,7 +258,7 @@ dgUnsigned32 dgBallConstraint::JacobianDerivative(dgContraintDescritor ¶ms)
}
penetrationErr = MIN_JOINT_PIN_LENGTH * (angle.m_x - m_twistAngle);
- _ASSERTE(penetrationErr >= dgFloat32(0.0f));
+ NEWTON_ASSERT(penetrationErr >= dgFloat32(0.0f));
params.m_forceBounds[ret].m_low = dgFloat32(0.0f);
params.m_forceBounds[ret].m_normalIndex = DG_NORMAL_CONSTRAINT;
@@ -280,7 +280,7 @@ dgUnsigned32 dgBallConstraint::JacobianDerivative(dgContraintDescritor ¶ms)
}
penetrationErr = MIN_JOINT_PIN_LENGTH * (-m_twistAngle - angle.m_x);
- _ASSERTE(penetrationErr >= dgFloat32(0.0f));
+ NEWTON_ASSERT(penetrationErr >= dgFloat32(0.0f));
params.m_forceBounds[ret].m_low = dgFloat32(0.0f);
params.m_forceBounds[ret].m_normalIndex = DG_NORMAL_CONSTRAINT;
@@ -318,7 +318,7 @@ dgUnsigned32 dgBallConstraint::JacobianDerivative(dgContraintDescritor ¶ms)
}
penetrationErr = MIN_JOINT_PIN_LENGTH * (dgAcos(GetMax(coneCos, dgFloat32(-0.9999f))) - m_coneAngle);
- _ASSERTE(penetrationErr >= dgFloat32(0.0f));
+ NEWTON_ASSERT(penetrationErr >= dgFloat32(0.0f));
CalculatePointDerivative(ret, params, normalDir, pointData,
&m_jointForce[ret]);
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.cpp
index 52676759f0d..d51246ac5ac 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.cpp
@@ -35,8 +35,8 @@
#define DG_POS_DAMP (dgFloat32(1500.0f))
dgBilateralConstraint::dgBilateralConstraint() : dgConstraint() {
- _ASSERTE((sizeof(dgBilateralConstraint) & 15) == 0);
- _ASSERTE((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT((sizeof(dgBilateralConstraint) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
// dgConstraint::Init ();
@@ -80,14 +80,14 @@ void dgBilateralConstraint::SetDestructorCallback(
void dgBilateralConstraint::CalculateMatrixOffset(const dgVector &pivot,
const dgVector &dir, dgMatrix &matrix0, dgMatrix &matrix1) {
dgFloat32 length;
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &body0_Matrix = m_body0->GetMatrix();
length = dir % dir;
length = dgSqrt(length);
- _ASSERTE(length > dgFloat32(0.0f));
+ NEWTON_ASSERT(length > dgFloat32(0.0f));
// matrix0.m_front = body0_Matrix.UnrotateVector (dir.Scale (dgFloat32 (1.0f) / length));
// Create__Basis (matrix0.m_front, matrix0.m_up, matrix0.m_right);
matrix0 = dgMatrix(
@@ -115,12 +115,12 @@ void dgBilateralConstraint::SetPivotAndPinDir(const dgVector &pivot,
void dgBilateralConstraint::SetPivotAndPinDir(const dgVector &pivot,
const dgVector &pinDirection0, const dgVector &pinDirection1) {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &body0_Matrix = m_body0->GetMatrix();
- _ASSERTE((pinDirection0 % pinDirection0) > dgFloat32(0.0f));
+ NEWTON_ASSERT((pinDirection0 % pinDirection0) > dgFloat32(0.0f));
m_localMatrix0.m_front = pinDirection0.Scale(
dgFloat32(1.0f) / dgSqrt(pinDirection0 % pinDirection0));
m_localMatrix0.m_right = m_localMatrix0.m_front * pinDirection1;
@@ -149,8 +149,8 @@ void dgBilateralConstraint::SetPivotAndPinDir(const dgVector &pivot,
dgVector dgBilateralConstraint::CalculateGlobalMatrixAndAngle(
dgMatrix &globalMatrix0, dgMatrix &globalMatrix1) const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
const dgMatrix &body0Matrix = m_body0->GetMatrix();
const dgMatrix &body1Matrix = m_body1->GetMatrix();
// dgMatrix body1Matrix (dgGetIdentityMatrix());
@@ -163,13 +163,13 @@ dgVector dgBilateralConstraint::CalculateGlobalMatrixAndAngle(
dgMatrix relMatrix(globalMatrix1 * globalMatrix0.Inverse());
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (relMatrix.m_front % relMatrix.m_front)) < 1.0e-5f);
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (relMatrix.m_up % relMatrix.m_up)) < 1.0e-5f);
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (relMatrix.m_right % relMatrix.m_right)) < 1.0e-5f);
- // _ASSERTE ((relMatrix.m_posit % relMatrix.m_posit) < 1.0e-3f);
+ // NEWTON_ASSERT ((relMatrix.m_posit % relMatrix.m_posit) < 1.0e-3f);
return relMatrix.CalcPitchYawRoll();
}
@@ -259,10 +259,10 @@ void dgBilateralConstraint::CalculateAngularDerivative(dgInt32 index,
dgFloat32 alphaError;
dgFloat32 omegaError;
- _ASSERTE(jointForce);
+ NEWTON_ASSERT(jointForce);
dgVector omega1;
- _ASSERTE(m_body0);
+ NEWTON_ASSERT(m_body0);
dgVector omega0(m_body0->GetOmega());
dgJacobian &jacobian0 = desc.m_jacobian[index].m_jacobian_IM0;
jacobian0.m_linear[0] = dgFloat32(0.0f);
@@ -275,7 +275,7 @@ void dgBilateralConstraint::CalculateAngularDerivative(dgInt32 index,
jacobian0.m_angular[3] = dgFloat32(0.0f);
dgJacobian &jacobian1 = desc.m_jacobian[index].m_jacobian_IM1;
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body1);
omega1 = m_body1->GetOmega();
jacobian1.m_linear[0] = dgFloat32(0.0f);
jacobian1.m_linear[1] = dgFloat32(0.0f);
@@ -301,7 +301,7 @@ void dgBilateralConstraint::CalculateAngularDerivative(dgInt32 index,
desc.m_isMotor[index] = 0;
m_motorAcceleration[index] = dgFloat32(0.0f);
- //_ASSERTE (dgAbsf (alphaError - CalculateSpringDamperAcceleration (index, desc, jointAngle, dgVector (0, 0, 0), dgVector (0, 0, 0), ANGULAR_POS_DAMP, ANGULAR_VEL_DAMP)) < 1.0e-2f);
+ //NEWTON_ASSERT (dgAbsf (alphaError - CalculateSpringDamperAcceleration (index, desc, jointAngle, dgVector (0, 0, 0), dgVector (0, 0, 0), ANGULAR_POS_DAMP, ANGULAR_VEL_DAMP)) < 1.0e-2f);
desc.m_penetration[index] = jointAngle;
desc.m_jointAccel[index] = alphaError;
@@ -319,9 +319,9 @@ void dgBilateralConstraint::CalculatePointDerivative(dgInt32 index,
dgFloat32 relCentr;
dgFloat32 accelError;
- _ASSERTE(jointForce);
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(jointForce);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
dgJacobian &jacobian0 = desc.m_jacobian[index].m_jacobian_IM0;
dgVector r0CrossDir(param.m_r0 * dir);
@@ -364,7 +364,7 @@ void dgBilateralConstraint::CalculatePointDerivative(dgInt32 index,
dgFloat32 den = dgFloat32(1.0f) + dt * kd + dt * ksd;
accelError = num / den;
- //_ASSERTE (dgAbsf (accelError - CalculateSpringDamperAcceleration (index, desc, 0.0f, param.m_posit0, param.m_posit1, LINEAR_POS_DAMP, LINEAR_VEL_DAMP)) < 1.0e-2f);
+ //NEWTON_ASSERT (dgAbsf (accelError - CalculateSpringDamperAcceleration (index, desc, 0.0f, param.m_posit0, param.m_posit1, LINEAR_POS_DAMP, LINEAR_VEL_DAMP)) < 1.0e-2f);
m_rowIsMotor[index] = 0;
desc.m_isMotor[index] = 0;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.h b/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.h
index 578c6a48f30..1c80c06b162 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBilateralConstraint.h
@@ -35,10 +35,10 @@ protected:
virtual ~dgBilateralConstraint();
virtual void Init() {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
virtual void Remove(dgWorld *world) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
virtual bool IsBilateral() const;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBody.cpp b/engines/hpl1/engine/libraries/newton/physics/dgBody.cpp
index aeac0b28cce..4eb8f587b27 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBody.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBody.cpp
@@ -38,11 +38,11 @@
dgBody::dgBody() {
// int xx = sizeof (dgBody);
- _ASSERTE((sizeof(dgBody) & 0x0f) == 0);
+ NEWTON_ASSERT((sizeof(dgBody) & 0x0f) == 0);
}
dgBody::~dgBody() {
- // _ASSERTE (m_collisionCell.GetCount() == 0);
+ // NEWTON_ASSERT (m_collisionCell.GetCount() == 0);
}
void dgBody::SetAparentMassMatrix(const dgVector &massMatrix) {
@@ -61,7 +61,7 @@ void dgBody::SetAparentMassMatrix(const dgVector &massMatrix) {
void dgBody::SetMassMatrix(dgFloat32 mass, dgFloat32 Ix, dgFloat32 Iy,
dgFloat32 Iz) {
- // _ASSERTE (mass > dgFloat32 (0.0f));
+ // NEWTON_ASSERT (mass > dgFloat32 (0.0f));
if (m_collision->IsType(dgCollision::dgCollisionMesh_RTTI)) {
mass = DG_INFINITE_MASS * 2.0f;
}
@@ -82,9 +82,9 @@ void dgBody::SetMassMatrix(dgFloat32 mass, dgFloat32 Ix, dgFloat32 Iy,
}
} else {
- _ASSERTE(Ix > dgFloat32(0.0f));
- _ASSERTE(Iy > dgFloat32(0.0f));
- _ASSERTE(Iz > dgFloat32(0.0f));
+ NEWTON_ASSERT(Ix > dgFloat32(0.0f));
+ NEWTON_ASSERT(Iy > dgFloat32(0.0f));
+ NEWTON_ASSERT(Iz > dgFloat32(0.0f));
// dgVector omega (m_mass.CompProduct(m_matrix.UnrotateVector(m_omega)));
@@ -112,7 +112,7 @@ void dgBody::SetMassMatrix(dgFloat32 mass, dgFloat32 Ix, dgFloat32 Iy,
if (refNode->GetInfo().GetBody()->m_invMass.m_w != 0.0f) {
for (; refNode; refNode = refNode->GetNext()) {
dgBody *body = refNode->GetInfo().GetBody();
- _ASSERTE(body->m_invMass.m_w != 0.0f);
+ NEWTON_ASSERT(body->m_invMass.m_w != 0.0f);
}
break;
}
@@ -124,7 +124,7 @@ void dgBody::SetMassMatrix(dgFloat32 mass, dgFloat32 Ix, dgFloat32 Iy,
}
void dgBody::AttachCollision(dgCollision *collision) {
- _ASSERTE(collision);
+ NEWTON_ASSERT(collision);
if (collision->IsType(dgCollision::dgCollisionCompound_RTTI)) {
if (collision->IsType(dgCollision::dgCollisionCompoundBreakable_RTTI)) {
@@ -244,7 +244,7 @@ void dgBody::UpdateCollisionMatrixSimd(dgFloat32 timestep, dgInt32 threadIndex)
}
if (m_collisionCell.m_cell) {
- _ASSERTE(m_world);
+ NEWTON_ASSERT(m_world);
if (!m_sleeping) {
if ((dgAbsf(oldP0.m_x - m_minAABB.m_x) > DG_AABB_ERROR) || (dgAbsf(oldP0.m_y - m_minAABB.m_y) > DG_AABB_ERROR) || (dgAbsf(oldP0.m_z - m_minAABB.m_z) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_x - m_maxAABB.m_x) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_y - m_maxAABB.m_y) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_z - m_maxAABB.m_z) > DG_AABB_ERROR)) {
m_world->UpdateBodyBroadphase(this, threadIndex);
@@ -285,7 +285,7 @@ void dgBody::UpdateCollisionMatrix(dgFloat32 timestep, dgInt32 threadIndex) {
}
if (m_collision->IsType(dgCollision::dgCollisionCompound_RTTI)) {
- //_ASSERTE (0);
+ //NEWTON_ASSERT (0);
dgCollisionCompound *const compoundCollision =
(dgCollisionCompound *)m_collision;
@@ -311,7 +311,7 @@ void dgBody::UpdateCollisionMatrix(dgFloat32 timestep, dgInt32 threadIndex) {
}
if (m_collisionCell.m_cell) {
- _ASSERTE(m_world);
+ NEWTON_ASSERT(m_world);
if (!m_sleeping) {
if ((dgAbsf(oldP0.m_x - m_minAABB.m_x) > DG_AABB_ERROR) || (dgAbsf(oldP0.m_y - m_minAABB.m_y) > DG_AABB_ERROR) || (dgAbsf(oldP0.m_z - m_minAABB.m_z) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_x - m_maxAABB.m_x) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_y - m_maxAABB.m_y) > DG_AABB_ERROR) || (dgAbsf(oldP1.m_z - m_maxAABB.m_z) > DG_AABB_ERROR)) {
@@ -327,7 +327,7 @@ dgFloat32 dgBody::RayCast(const dgLineBox &line, OnRayCastAction filter,
OnRayPrecastAction preFilter, void *const userData, dgFloat32 minT) const {
dgContactPoint contactOut;
- _ASSERTE(filter);
+ NEWTON_ASSERT(filter);
if (m_world->m_cpu == dgSimdPresent) {
if (dgOverlapTestSimd(line.m_boxL0, line.m_boxL1, m_minAABB, m_maxAABB)) {
dgVector localP0(m_collisionWorldMatrix.UntransformVector(line.m_l0));
@@ -335,8 +335,8 @@ dgFloat32 dgBody::RayCast(const dgLineBox &line, OnRayCastAction filter,
dgFloat32 t = m_collision->RayCastSimd(localP0, localP1, contactOut,
preFilter, this, userData);
if (t < minT) {
- _ASSERTE(t >= 0.0f);
- _ASSERTE(t <= 1.0f);
+ NEWTON_ASSERT(t >= 0.0f);
+ NEWTON_ASSERT(t <= 1.0f);
contactOut.m_normal = m_collisionWorldMatrix.RotateVectorSimd(
contactOut.m_normal);
@@ -351,8 +351,8 @@ dgFloat32 dgBody::RayCast(const dgLineBox &line, OnRayCastAction filter,
dgFloat32 t = m_collision->RayCast(localP0, localP1, contactOut,
preFilter, this, userData);
if (t < minT) {
- _ASSERTE(t >= 0.0f);
- _ASSERTE(t <= 1.0f);
+ NEWTON_ASSERT(t >= 0.0f);
+ NEWTON_ASSERT(t <= 1.0f);
contactOut.m_normal = m_collisionWorldMatrix.RotateVector(
contactOut.m_normal);
minT = filter(this, contactOut.m_normal, dgInt32(contactOut.m_userId),
@@ -394,8 +394,8 @@ void dgBody::AddBuoyancyForce(dgFloat32 fluidDensity,
dgFloat32(2.0f));
torque -= m_omega.Scale(damp);
- // _ASSERTE (dgSqrt (force % force) < (dgSqrt (gravityVector % gravityVector) * m_mass.m_w * dgFloat32 (100.0f)));
- // _ASSERTE (dgSqrt (torque % torque) < (dgSqrt (gravityVector % gravityVector) * m_mass.m_w * dgFloat32 (100.0f) * dgFloat32 (10.0f)));
+ // NEWTON_ASSERT (dgSqrt (force % force) < (dgSqrt (gravityVector % gravityVector) * m_mass.m_w * dgFloat32 (100.0f)));
+ // NEWTON_ASSERT (dgSqrt (torque % torque) < (dgSqrt (gravityVector % gravityVector) * m_mass.m_w * dgFloat32 (100.0f) * dgFloat32 (10.0f)));
m_world->dgGetUserLock();
m_accel += force;
@@ -407,10 +407,10 @@ void dgBody::AddBuoyancyForce(dgFloat32 fluidDensity,
// void dgBody::CalcInvInertiaMatrix (dgMatrix& matrix) const
void dgBody::CalcInvInertiaMatrix() {
- _ASSERTE(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
m_invWorldInertiaMatrix[0][0] = m_invMass[0] * m_matrix[0][0];
m_invWorldInertiaMatrix[0][1] = m_invMass[1] * m_matrix[1][0];
@@ -429,10 +429,10 @@ void dgBody::CalcInvInertiaMatrix() {
m_invWorldInertiaMatrix[3][1] = dgFloat32(0.0f);
m_invWorldInertiaMatrix[3][2] = dgFloat32(0.0f);
- _ASSERTE(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
}
void dgBody::CalcInvInertiaMatrixSimd() {
@@ -481,15 +481,15 @@ void dgBody::CalcInvInertiaMatrixSimd() {
// CalcInvInertiaMatrix ();
// for (int i = 0; i < 4; i ++) {
// for (int j = 0; j < 4; j ++) {
-// _ASSERTE (dgAbsf (aaa[i][j] - m_invWorldInertiaMatrix[i][j]) <= dgAbsf (aaa[i][j] * dgFloat32 (1.0e-3f)));
+// NEWTON_ASSERT (dgAbsf (aaa[i][j] - m_invWorldInertiaMatrix[i][j]) <= dgAbsf (aaa[i][j] * dgFloat32 (1.0e-3f)));
// }
// }
#endif
- _ASSERTE(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
- _ASSERTE(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[0][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[1][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[2][3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(m_invWorldInertiaMatrix[3][3] == dgFloat32(1.0f));
#else
@@ -575,7 +575,7 @@ void dgBody::IntegrateVelocity(dgFloat32 timestep) {
#ifdef _DEBUG
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
- _ASSERTE(dgCheckFloat(m_matrix[i][j]));
+ NEWTON_ASSERT(dgCheckFloat(m_matrix[i][j]));
}
}
@@ -583,12 +583,12 @@ void dgBody::IntegrateVelocity(dgFloat32 timestep) {
int j1 = 2;
for (int i = 0; i < 3; i++) {
dgFloat32 val;
- _ASSERTE(m_matrix[i][3] == 0.0f);
+ NEWTON_ASSERT(m_matrix[i][3] == 0.0f);
val = m_matrix[i] % m_matrix[i];
- _ASSERTE(dgAbsf(val - 1.0f) < 1.0e-5f);
+ NEWTON_ASSERT(dgAbsf(val - 1.0f) < 1.0e-5f);
dgVector tmp(m_matrix[j0] * m_matrix[j1]);
val = tmp % m_matrix[i];
- _ASSERTE(dgAbsf(val - 1.0f) < 1.0e-5f);
+ NEWTON_ASSERT(dgAbsf(val - 1.0f) < 1.0e-5f);
j0 = j1;
j1 = i;
}
@@ -620,7 +620,7 @@ void dgBody::CalculateContinueVelocitySimd(dgFloat32 timestep, dgVector &veloc,
dgVector dgBody::GetTrajectory(const dgVector &velocParam,
const dgVector &omegaParam) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(0, 0, 0, 0);
/*
dgFloat32 timestep;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBody.h b/engines/hpl1/engine/libraries/newton/physics/dgBody.h
index 68ffee2ffc7..d81e1ffdfda 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBody.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBody.h
@@ -552,7 +552,7 @@ inline void dgBody::AddDamingAcceleration() {
/*
inline void dgBody::AddGyroscopicTorque()
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
if (m_applyGyroscopic) {
const dgVector inertia = m_mass;
dgVector omega (m_matrix.UnrotateVector (m_omega));
@@ -641,7 +641,7 @@ inline void dgBody::SetMatrixOriginAndRotation(const dgMatrix &matrix) {
#ifdef _DEBUG
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
- _ASSERTE(dgCheckFloat(m_matrix[i][j]));
+ NEWTON_ASSERT(dgCheckFloat(m_matrix[i][j]));
}
}
@@ -649,12 +649,12 @@ inline void dgBody::SetMatrixOriginAndRotation(const dgMatrix &matrix) {
int j1 = 2;
for (dgInt32 i = 0; i < 3; i++) {
dgFloat32 val;
- _ASSERTE(m_matrix[i][3] == 0.0f);
+ NEWTON_ASSERT(m_matrix[i][3] == 0.0f);
val = m_matrix[i] % m_matrix[i];
- _ASSERTE(dgAbsf(val - 1.0f) < 1.0e-5f);
+ NEWTON_ASSERT(dgAbsf(val - 1.0f) < 1.0e-5f);
dgVector tmp(m_matrix[j0] * m_matrix[j1]);
val = tmp % m_matrix[i];
- _ASSERTE(dgAbsf(val - 1.0f) < 1.0e-5f);
+ NEWTON_ASSERT(dgAbsf(val - 1.0f) < 1.0e-5f);
j0 = j1;
j1 = i;
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBodyMasterList.cpp b/engines/hpl1/engine/libraries/newton/physics/dgBodyMasterList.cpp
index 783f045a14f..7e529eea8fb 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBodyMasterList.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBodyMasterList.cpp
@@ -31,7 +31,7 @@ dgBodyMasterListRow::dgBodyMasterListRow() : dgList<dgBodyMasterListCell>(NULL)
}
dgBodyMasterListRow::~dgBodyMasterListRow() {
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
}
dgBodyMasterListRow::dgListNode *dgBodyMasterListRow::AddJoint(
@@ -93,10 +93,10 @@ void dgBodyMasterList::AddBody(dgBody *const body) {
void dgBodyMasterList::RemoveBody(dgBody *const body) {
dgListNode *const node = body->m_masterNode;
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
node->GetInfo().RemoveAllJoints();
- _ASSERTE(node->GetInfo().GetCount() == 0);
+ NEWTON_ASSERT(node->GetInfo().GetCount() == 0);
Remove(node);
body->m_masterNode = NULL;
@@ -104,9 +104,9 @@ void dgBodyMasterList::RemoveBody(dgBody *const body) {
dgBodyMasterListRow::dgListNode *dgBodyMasterList::FindConstraintLink(
const dgBody *const body0, const dgBody *const body1) const {
- _ASSERTE(body0);
- _ASSERTE(body1);
- _ASSERTE(body0->m_masterNode);
+ NEWTON_ASSERT(body0);
+ NEWTON_ASSERT(body1);
+ NEWTON_ASSERT(body0->m_masterNode);
for (dgBodyMasterListRow::dgListNode *node =
body0->m_masterNode->GetInfo().GetFirst();
@@ -122,8 +122,8 @@ dgBodyMasterListRow::dgListNode *dgBodyMasterList::FindConstraintLink(
dgBodyMasterListRow::dgListNode *dgBodyMasterList::FindConstraintLinkNext(
const dgBodyMasterListRow::dgListNode *const me,
const dgBody *const body) const {
- _ASSERTE(me);
- _ASSERTE(body);
+ NEWTON_ASSERT(me);
+ NEWTON_ASSERT(body);
for (dgBodyMasterListRow::dgListNode *node = me->GetNext(); node;
node = node->GetNext()) {
if (node->GetInfo().m_bodyNode == body) {
@@ -136,13 +136,13 @@ dgBodyMasterListRow::dgListNode *dgBodyMasterList::FindConstraintLinkNext(
void dgBodyMasterList::AttachConstraint(dgConstraint *const constraint,
dgBody *const body0, dgBody *const srcbody1) {
- _ASSERTE(body0);
+ NEWTON_ASSERT(body0);
dgBody *body1 = srcbody1;
if (!body1) {
body1 = body0->GetWorld()->GetSentinelBody();
constraint->m_isUnilateral = true;
}
- _ASSERTE(body1);
+ NEWTON_ASSERT(body1);
constraint->m_body0 = body0;
constraint->m_body1 = body1;
@@ -163,14 +163,14 @@ void dgBodyMasterList::AttachConstraint(dgConstraint *const constraint,
void dgBodyMasterList::RemoveConstraint(dgConstraint *const constraint) {
m_constraintCount = m_constraintCount - 1;
- _ASSERTE(((dgInt32)m_constraintCount) >= 0);
+ NEWTON_ASSERT(((dgInt32)m_constraintCount) >= 0);
dgBody *const body0 = constraint->m_body0;
dgBody *const body1 = constraint->m_body1;
- _ASSERTE(body0);
- _ASSERTE(body1);
- _ASSERTE(body0 == constraint->m_link1->GetInfo().m_bodyNode);
- _ASSERTE(body1 == constraint->m_link0->GetInfo().m_bodyNode);
+ NEWTON_ASSERT(body0);
+ NEWTON_ASSERT(body1);
+ NEWTON_ASSERT(body0 == constraint->m_link1->GetInfo().m_bodyNode);
+ NEWTON_ASSERT(body1 == constraint->m_link0->GetInfo().m_bodyNode);
body0->m_equilibrium = dgUnsigned32(body0->m_invMass.m_w ? false : true);
body1->m_equilibrium = dgUnsigned32(body1->m_invMass.m_w ? false : true);
@@ -192,7 +192,7 @@ void dgBodyMasterList::SortMasterList() {
node->GetInfo().SortList();
dgBody *const body1 = node->GetInfo().GetBody();
- _ASSERTE(GetFirst() != node);
+ NEWTON_ASSERT(GetFirst() != node);
body1->InvalidateCache();
@@ -209,7 +209,7 @@ void dgBodyMasterList::SortMasterList() {
}
if (!prev) {
- _ASSERTE(entry == GetFirst());
+ NEWTON_ASSERT(entry == GetFirst());
RotateToBegin(entry);
} else {
InsertAfter(prev, entry);
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgBroadPhaseCollision.cpp b/engines/hpl1/engine/libraries/newton/physics/dgBroadPhaseCollision.cpp
index dcc75ff51e3..a17ae201849 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgBroadPhaseCollision.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgBroadPhaseCollision.cpp
@@ -34,7 +34,7 @@ dgSortArray::dgSortArray() : dgList<dgSortArrayEntry>(NULL) {
}
dgSortArray::~dgSortArray() {
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
}
void dgSortArray::Add(dgBody *const body) {
@@ -49,7 +49,7 @@ void dgSortArray::Add(dgBody *const body) {
void dgSortArray::Remove(dgBody *const body) {
dgListNode *const node =
(dgListNode *)body->m_collisionCell.m_axisArrayNode[dgInt32(m_index)];
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
dgList<dgSortArrayEntry>::Remove(node);
body->m_collisionCell.m_axisArrayNode[dgInt32(m_index)] = NULL;
@@ -88,7 +88,7 @@ dgFloat32 dgSortArray::Sort() {
InsertAfter(prev, entry);
}
}
- // _ASSERTE ((GetCount() * sum2 - sum * sum) > dgFloat32 (-10.0f));
+ // NEWTON_ASSERT ((GetCount() * sum2 - sum * sum) > dgFloat32 (-10.0f));
return GetCount() * sum2 - sum * sum;
}
@@ -98,7 +98,7 @@ dgFloat32 dgSortArray::RayCast(dgFloat32 minT, const dgLineBox &line,
if (m_isSorted) {
// dgFloat32 minVal = line.m_boxL0[m_index];
dgFloat32 maxVal = line.m_boxL1[m_index];
- _ASSERTE(line.m_boxL0[m_index] <= maxVal);
+ NEWTON_ASSERT(line.m_boxL0[m_index] <= maxVal);
for (dgListNode *node = GetFirst();
node && (node->GetInfo().m_key < maxVal); node = node->GetNext()) {
@@ -155,7 +155,7 @@ dgBroadPhaseCell::dgBroadPhaseCell() {
}
dgBroadPhaseCell::~dgBroadPhaseCell() {
- _ASSERTE(m_count == 0);
+ NEWTON_ASSERT(m_count == 0);
}
void dgBroadPhaseCell::Init(dgInt32 layer, dgMemoryAllocator *allocator) {
@@ -176,7 +176,7 @@ void dgBroadPhaseCell::Add(dgBody *const body) {
m_count++;
m_active = 1;
- _ASSERTE(!body->m_collisionCell.m_cell);
+ NEWTON_ASSERT(!body->m_collisionCell.m_cell);
m_sort[0].Add(body);
m_sort[1].Add(body);
@@ -188,8 +188,8 @@ void dgBroadPhaseCell::Remove(dgBody *const body) {
m_count--;
m_active = 1;
- _ASSERTE(m_count >= 0);
- _ASSERTE(body->m_collisionCell.m_cell);
+ NEWTON_ASSERT(m_count >= 0);
+ NEWTON_ASSERT(body->m_collisionCell.m_cell);
m_sort[0].Remove(body);
m_sort[1].Remove(body);
@@ -242,7 +242,7 @@ void dgBroadPhaseCell::UpdateAutoPair(dgWorld *const world,
innerNode->GetNext()) {
dgBody *const body1 = innerNode->GetInfo().m_body;
if (!body1->m_collision->IsType(dgCollision::dgCollisionNull_RTTI)) {
- _ASSERTE(body0 != body1);
+ NEWTON_ASSERT(body0 != body1);
if (OverlapTest(body0, body1)) {
contactPair.AddPair(body0, body1, threadIndex);
}
@@ -259,12 +259,12 @@ dgBroadPhaseLayer::dgBroadPhaseLayer() : dgTree<dgBroadPhaseCell, dgUnsigned32>(
}
dgBroadPhaseLayer::~dgBroadPhaseLayer() {
- _ASSERTE(!GetCount());
+ NEWTON_ASSERT(!GetCount());
}
void dgBroadPhaseLayer::Init(dgWorld *const world, dgFloat32 cellSize,
dgInt32 layerIndex) {
- _ASSERTE(GetCount() == 0);
+ NEWTON_ASSERT(GetCount() == 0);
m_me = world;
m_layerIndex = dgInt16(layerIndex);
m_cellSize = cellSize;
@@ -366,7 +366,7 @@ void dgBroadPhaseCollision::SetWorldSize(const dgVector &min,
m_inactiveList.Init(0, me->GetAllocator());
cellSize = m_worlSize;
for (dgInt32 i = 0; i < DG_OCTREE_MAX_DEPTH; i++) {
- _ASSERTE(m_layerMap[i].GetCount() == 0);
+ NEWTON_ASSERT(m_layerMap[i].GetCount() == 0);
m_layerMap[i].Init(me, cellSize, i);
cellSize *= dgFloat32(0.5f);
}
@@ -420,7 +420,7 @@ void dgBroadPhaseCollision::InvalidateCache() {
}
void dgBroadPhaseCollision::Add(dgBody *const body) {
- _ASSERTE(!body->m_collisionCell.m_cell);
+ NEWTON_ASSERT(!body->m_collisionCell.m_cell);
// new bodies are added to the root node, and the function set matrix relocate them
m_layerMap[0].FindCreate(0, 0)->Add(body);
}
@@ -429,7 +429,7 @@ void dgBroadPhaseCollision::Remove(dgBody *const body) {
// dgBroadPhaseCell* obtreeCell;
// dgBroadPhaseLayer::dgTreeNode* node;
- _ASSERTE(body->m_collisionCell.m_cell);
+ NEWTON_ASSERT(body->m_collisionCell.m_cell);
dgBroadPhaseCell *const obtreeCell = body->m_collisionCell.m_cell;
obtreeCell->Remove(body);
@@ -438,7 +438,7 @@ void dgBroadPhaseCollision::Remove(dgBody *const body) {
dgBroadPhaseLayer::dgTreeNode *const node = m_layerMap[dgInt32(
obtreeCell->m_layerIndex)]
.GetNodeFromInfo(*obtreeCell);
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
m_layerMap[dgInt32(obtreeCell->m_layerIndex)].Remove(node);
}
}
@@ -457,7 +457,7 @@ void dgBroadPhaseCollision::UpdatePairs(dgBody *const body0,
node && (node->GetInfo().m_key < val); node = node->GetNext()) {
dgBody *const body1 = node->GetInfo().m_body;
if (!body1->m_collision->IsType(dgCollision::dgCollisionNull_RTTI)) {
- _ASSERTE(body0 != body1);
+ NEWTON_ASSERT(body0 != body1);
if (OverlapTest(body0, body1)) {
contactPair.AddPair(body0, body1, threadIndex);
}
@@ -713,7 +713,7 @@ void dgBroadPhaseCalculateContactsWorkerThread::Realloc(dgInt32 jointsCount,
}
}
- _ASSERTE(index == contactCount);
+ NEWTON_ASSERT(index == contactCount);
m_world->GetAllocator()->FreeLow(m_world->m_contactBuffers[threadIndex]);
m_world->m_contactBuffersSizeInBytes[threadIndex] = size;
@@ -745,7 +745,7 @@ void dgBroadPhaseApplyExternalForce::ThreadExecute() {
if (m_world->m_cpu == dgSimdPresent) {
for (dgInt32 i = 0; i < count; i += step) {
dgBody *const body = bodyArray[i];
- _ASSERTE(
+ NEWTON_ASSERT(
body->m_collision->IsType(dgCollision::dgConvexCollision_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionCompound_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionConvexModifier_RTTI));
if (!body->IsInEquelibrium()) {
body->UpdateCollisionMatrixSimd(m_timeStep, m_threadIndex);
@@ -754,7 +754,7 @@ void dgBroadPhaseApplyExternalForce::ThreadExecute() {
} else {
for (dgInt32 i = 0; i < count; i += step) {
dgBody *const body = bodyArray[i];
- _ASSERTE(
+ NEWTON_ASSERT(
body->m_collision->IsType(dgCollision::dgConvexCollision_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionCompound_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionConvexModifier_RTTI));
if (!body->IsInEquelibrium()) {
body->UpdateCollisionMatrixSimd(m_timeStep, m_threadIndex);
@@ -767,9 +767,9 @@ void dgBroadPhaseApplyExternalForce::ThreadExecute() {
dgBody *const body = bodyArray[i];
body->m_solverInContinueCollision = false;
- _ASSERTE(body->m_invMass.m_w > dgFloat32(0.0f));
+ NEWTON_ASSERT(body->m_invMass.m_w > dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(
body->m_collision->IsType(dgCollision::dgConvexCollision_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionCompound_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionConvexModifier_RTTI));
body->ApplyExtenalForces(m_timeStep, m_threadIndex);
@@ -786,9 +786,9 @@ void dgBroadPhaseApplyExternalForce::ThreadExecute() {
dgBody *const body = bodyArray[i];
body->m_solverInContinueCollision = false;
- _ASSERTE(body->m_invMass.m_w > dgFloat32(0.0f));
+ NEWTON_ASSERT(body->m_invMass.m_w > dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(
body->m_collision->IsType(dgCollision::dgConvexCollision_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionCompound_RTTI) || body->m_collision->IsType(dgCollision::dgCollisionConvexModifier_RTTI));
body->ApplyExtenalForces(m_timeStep, m_threadIndex);
@@ -831,7 +831,7 @@ void dgBroadPhaseCalculateContactsWorkerThread::ThreadExecute() {
m_world->CalculateContactsSimd(&pair, m_timestep, m_threadIndex);
contactIndex += pair.m_contactCount;
- _ASSERTE(contactIndex < contactSize);
+ NEWTON_ASSERT(contactIndex < contactSize);
}
} else {
for (dgInt32 i = 0; i < count; i += step) {
@@ -849,7 +849,7 @@ void dgBroadPhaseCalculateContactsWorkerThread::ThreadExecute() {
m_world->CalculateContacts(&pair, m_timestep, m_threadIndex);
contactIndex += pair.m_contactCount;
- _ASSERTE(contactIndex < contactSize);
+ NEWTON_ASSERT(contactIndex < contactSize);
}
}
}
@@ -865,7 +865,7 @@ void dgBroadPhaseMaterialCallbackWorkerThread::ThreadExecute() {
dgCollidingPairCollector::dgPair &pair = pairs[i];
if (pair.m_contactCount || pair.m_isTrigger) {
- _ASSERTE(pair.m_contactCount <= (DG_CONSTRAINT_MAX_ROWS / 3));
+ NEWTON_ASSERT(pair.m_contactCount <= (DG_CONSTRAINT_MAX_ROWS / 3));
if (pair.m_isTrigger) {
m_world->ProcessTriggers(&pair, m_timestep, m_threadIndex);
} else {
@@ -1008,8 +1008,8 @@ void dgBroadPhaseCollision::RayCast(const dgVector &l0, const dgVector &l1,
do {
dgBroadPhaseCell *const cell = layer.Find(xIndex0, zIndex0);
if (cell) {
- //_ASSERTE (cell->m_count);
- _ASSERTE(cell->m_lastSortArray);
+ //NEWTON_ASSERT (cell->m_count);
+ NEWTON_ASSERT(cell->m_lastSortArray);
if (!me->m_inUpdate) {
if (!cell->m_lastSortArray->m_isSorted) {
cell->m_lastSortArray->Sort();
@@ -1041,7 +1041,7 @@ void dgBroadPhaseCollision::UpdateBodyBroadphase(dgBody *const body,
m_appMaxBox)) {
// dgBroadPhaseCell *cell;
// cell = body->m_collisionCell.m_cell;
- // _ASSERTE (cell);
+ // NEWTON_ASSERT (cell);
Remove(body);
Add(body);
body->m_isInWorld = true;
@@ -1084,7 +1084,7 @@ void dgBroadPhaseCollision::UpdateBodyBroadphase(dgBody *const body,
dgBroadPhaseLayer::dgTreeNode *const node = m_layerMap[dgInt32(
cell->m_layerIndex)]
.GetNodeFromInfo(*cell);
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
m_layerMap[int(cell->m_layerIndex)].Remove(node);
}
newCell->Add(body);
@@ -1114,7 +1114,7 @@ void dgBroadPhaseCollision::UpdateBodyBroadphase(dgBody *const body,
dgBroadPhaseLayer::dgTreeNode *const node = m_layerMap[dgInt32(
cell->m_layerIndex)]
.GetNodeFromInfo(*cell);
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
m_layerMap[dgInt32(cell->m_layerIndex)].Remove(node);
}
newCell->Add(body);
@@ -1143,7 +1143,7 @@ void dgBroadPhaseCollision::UpdateBodyBroadphase(dgBody *const body,
dgBroadPhaseLayer::dgTreeNode *const node = m_layerMap[dgInt32(
cell->m_layerIndex)]
.GetNodeFromInfo(*cell);
- _ASSERTE(node);
+ NEWTON_ASSERT(node);
m_layerMap[dgInt32(cell->m_layerIndex)].Remove(node);
}
m_inactiveList.Add(body);
@@ -1198,7 +1198,7 @@ dgUnsigned32 dgBroadPhaseCollision::UpdateContactsBroadPhaseBegin(
dgInt32 skipForceUpdate = collisioUpdateOnly ? 1 : 0;
dgInt32 cellsBodyCount = 0;
- _ASSERTE(masterList.GetFirst()->GetInfo().GetBody() == me->GetSentinelBody());
+ NEWTON_ASSERT(masterList.GetFirst()->GetInfo().GetBody() == me->GetSentinelBody());
for (dgBodyMasterList::dgListNode *node = masterList.GetFirst()->GetNext();
node; node = node->GetNext()) {
dgBody *const body = node->GetInfo().GetBody();
@@ -1223,7 +1223,7 @@ dgUnsigned32 dgBroadPhaseCollision::UpdateContactsBroadPhaseBegin(
if (cellsBodyCount >= dgInt32((sizeof(cellArray) / sizeof(dgCellPair)))) {
if (threadCounts > 1) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
me->m_threadsManager.CalculateChunkSizes(cellsBodyCount, chunkSizes);
for (dgInt32 threadIndex = 0; threadIndex < threadCounts;
threadIndex++) {
@@ -1238,7 +1238,7 @@ dgUnsigned32 dgBroadPhaseCollision::UpdateContactsBroadPhaseBegin(
}
me->m_threadsManager.SynchronizationBarrier();
} else {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
m_applyExtForces[0].m_step = 1;
m_applyExtForces[0].m_count = cellsBodyCount;
@@ -1299,7 +1299,7 @@ dgUnsigned32 dgBroadPhaseCollision::UpdateContactsBroadPhaseBegin(
dgBroadPhaseLayer::Iterator iter(m_layerMap[i]);
for (iter.Begin(); iter; iter++) {
dgBroadPhaseCell &cell = iter.GetNode()->GetInfo();
- _ASSERTE(cell.m_count);
+ NEWTON_ASSERT(cell.m_count);
if (cell.m_active) {
cell.Sort();
}
@@ -1361,7 +1361,7 @@ dgUnsigned32 dgBroadPhaseCollision::UpdateContactsBroadPhaseBegin(
dgBroadPhaseLayer::Iterator iter(m_layerMap[i]);
for (iter.Begin(); iter; iter++) {
dgBroadPhaseCell &cell = iter.GetNode()->GetInfo();
- _ASSERTE(cell.m_count);
+ NEWTON_ASSERT(cell.m_count);
if (cell.m_active) {
cellArray[cellsPairsCount].m_cell_A = &cell;
cellArray[cellsPairsCount].m_cell_B = NULL;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollision.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollision.cpp
index 0e931be0ee8..6c48937ffb7 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollision.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollision.cpp
@@ -83,8 +83,8 @@ void dgCollision::SetOffsetMatrix(const dgMatrix &matrix) {
#ifdef _DEBUG
dgFloat32 det;
det = (m_offset.m_front * m_offset.m_up) % m_offset.m_right;
- _ASSERTE(det > dgFloat32(0.999f));
- _ASSERTE(det < dgFloat32(1.001f));
+ NEWTON_ASSERT(det > dgFloat32(0.999f));
+ NEWTON_ASSERT(det < dgFloat32(1.001f));
#endif
}
@@ -117,6 +117,6 @@ void dgCollision::SerializeLow(dgSerialize callback, void *const userData) const
/*
void dgCollision::Serialize(dgSerialize callback, void* const userData) const
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
}
*/
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollision.h b/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
index f86209c243b..29c0a8782c8 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollision.h
@@ -237,7 +237,7 @@ public:
virtual void DebugCollision(const dgMatrix &matrix, OnDebugCollisionMeshCallback callback, void *const userData) const = 0;
virtual dgFloat32 RayCast(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const = 0;
virtual dgFloat32 RayCastSimd(const dgVector &localP0, const dgVector &localP1, dgContactPoint &contactOut, OnRayPrecastAction preFilter, const dgBody *const body, void *const userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
};
virtual dgFloat32 GetVolume() const = 0;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionBVH.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionBVH.cpp
index 6966956c253..a5655a74f38 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionBVH.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionBVH.cpp
@@ -67,7 +67,7 @@ void dgCollisionBVH::AddFace(dgInt32 vertexCount,
dgInt32 indexList[256];
faceArray = vertexCount;
- _ASSERTE(vertexCount < dgInt32(sizeof(indexList) / sizeof(indexList[0])));
+ NEWTON_ASSERT(vertexCount < dgInt32(sizeof(indexList) / sizeof(indexList[0])));
for (dgInt32 i = 0; i < vertexCount; i++) {
indexList[i] = i;
}
@@ -140,9 +140,9 @@ dgIntersectStatus dgCollisionBVH::CollectVertexListIndexList(void *context,
j += 3;
}
- _ASSERTE(j <= data.m_maxIndexCount);
+ NEWTON_ASSERT(j <= data.m_maxIndexCount);
data.m_triangleCount = k;
- _ASSERTE((data.m_triangleCount * 3) <= data.m_maxIndexCount);
+ NEWTON_ASSERT((data.m_triangleCount * 3) <= data.m_maxIndexCount);
return t_ContinueSearh;
}
@@ -158,7 +158,7 @@ dgIntersectStatus dgCollisionBVH::GetTriangleCount(void *context,
}
data.m_triangleCount += (indexCount - 2);
- _ASSERTE((data.m_triangleCount * 3) <= data.m_maxIndexCount);
+ NEWTON_ASSERT((data.m_triangleCount * 3) <= data.m_maxIndexCount);
return t_ContinueSearh;
}
@@ -360,12 +360,12 @@ dgIntersectStatus dgCollisionBVH::GetPolygon(void *context,
const dgInt32 *const indexArray, dgInt32 indexCount) {
dgPolygonMeshDesc &data = (*(dgPolygonMeshDesc *)context);
if (data.m_faceCount >= DG_MAX_COLLIDING_FACES) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return t_StopSearh;
}
if ((data.m_globalIndexCount + indexCount) >= DG_MAX_COLLIDING_VERTEX) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return t_StopSearh;
}
@@ -384,7 +384,7 @@ dgIntersectStatus dgCollisionBVH::GetPolygon(void *context,
indexArray[-1], indexCount, &triplex[0].m_x, sizeof(dgTriplex));
}
- _ASSERTE(data.m_vertex == polygon);
+ NEWTON_ASSERT(data.m_vertex == polygon);
data.m_userAttribute[data.m_faceCount] = indexArray[-1];
data.m_faceIndexCount[data.m_faceCount] = indexCount;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionBox.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionBox.cpp
index 9962d90bf25..eae87730e9e 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionBox.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionBox.cpp
@@ -123,7 +123,7 @@ void dgCollisionBox::Init(dgFloat32 size_x, dgFloat32 size_y, dgFloat32 size_z)
dgCollisionBox::~dgCollisionBox() {
// m_shapeRefCount --;
- // _ASSERTE (m_shapeRefCount >= 0);
+ // NEWTON_ASSERT (m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -131,7 +131,7 @@ dgCollisionBox::~dgCollisionBox() {
void dgCollisionBox::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgInt32 dgCollisionBox::CalculateSignature() const {
@@ -170,7 +170,7 @@ dgVector dgCollisionBox::SupportVertexSimd(const dgVector &dir) const {
}
dgVector dgCollisionBox::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
#if 0
dgFloatSign *const ptr = (dgFloatSign *) &dir;
@@ -355,7 +355,7 @@ dgFloat32 dgCollisionBox::RayCast(const dgVector &localP0,
}
if (tmin >= dgFloat32(0.0f)) {
- _ASSERTE(tmin < 1.0f);
+ NEWTON_ASSERT(tmin < 1.0f);
contactOut.m_normal = dgVector(dgFloat32(0.0f), dgFloat32(0.0f),
dgFloat32(0.0f), dgFloat32(0.0f));
contactOut.m_normal[index] = signDir;
@@ -441,13 +441,13 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersection(const dgVector &normal,
dgInt32 count = 0;
if (edge) {
- _ASSERTE(test[edge->m_vertex] > dgFloat32(0.0f));
+ NEWTON_ASSERT(test[edge->m_vertex] > dgFloat32(0.0f));
dgConvexSimplexEdge *ptr = edge;
dgConvexSimplexEdge *firstEdge = NULL;
dgFloat32 side0 = test[edge->m_vertex];
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
dgFloat32 side1 = test[ptr->m_twin->m_vertex];
if (side1 < side0) {
if (side1 < dgFloat32(0.0f)) {
@@ -481,8 +481,8 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersection(const dgVector &normal,
}
}
- _ASSERTE(t <= dgFloat32(0.01f));
- _ASSERTE(t >= dgFloat32(-1.05f));
+ NEWTON_ASSERT(t <= dgFloat32(0.01f));
+ NEWTON_ASSERT(t >= dgFloat32(-1.05f));
contactsOut[count] = m_vertex[ptr->m_vertex] - dp.Scale(t);
count++;
@@ -490,11 +490,11 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersection(const dgVector &normal,
for (; ptr1 != ptr; ptr1 = ptr1->m_next) {
dgInt32 index0 = ptr1->m_twin->m_vertex;
if (test[index0] >= dgFloat32(0.0f)) {
- _ASSERTE(test[ptr1->m_vertex] <= dgFloat32(0.0f));
+ NEWTON_ASSERT(test[ptr1->m_vertex] <= dgFloat32(0.0f));
break;
}
}
- _ASSERTE(ptr != ptr1);
+ NEWTON_ASSERT(ptr != ptr1);
ptr = ptr1->m_twin;
} while ((ptr != edge) && (count < 8));
@@ -582,7 +582,7 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersectionSimd(const dgVector &normal,
firstEdge = NULL;
side0 = test[edge->m_vertex];
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
side1 = test[ptr->m_twin->m_vertex];
if (side1 < side0) {
if (side1 < dgFloat32(0.0f)) {
@@ -606,8 +606,8 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersectionSimd(const dgVector &normal,
// dgVector dp (m_vertex[index1] - m_vertex[index0]);
// contactsOut[count] = m_vertex[index0] - dp.Scale (test[index0] / (plane % dp));
- _ASSERTE(m_vertex[index0].m_w == dgFloat32(1.0f));
- _ASSERTE(m_vertex[index1].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[index0].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[index1].m_w == dgFloat32(1.0f));
p1p0 =
simd_sub_v(*(simd_type *)&m_vertex[index1], *(simd_type *)&m_vertex[index0]);
dot = simd_mul_v(p1p0, *(simd_type *)&plane);
@@ -619,8 +619,8 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersectionSimd(const dgVector &normal,
den =
simd_min_s(simd_max_s(den, *(simd_type *)&m_negOne), *(simd_type *)&m_zero);
- _ASSERTE(((dgFloat32 *)&den)[0] <= dgFloat32(0.0f));
- _ASSERTE(((dgFloat32 *)&den)[0] >= dgFloat32(-1.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&den)[0] <= dgFloat32(0.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&den)[0] >= dgFloat32(-1.0f));
(*(simd_type *)&contactsOut[count]) =
simd_mul_sub_v(*(simd_type *)&m_vertex[index0], p1p0, simd_permut_v(den, den, PURMUT_MASK(3, 0, 0, 0)));
@@ -628,11 +628,11 @@ dgInt32 dgCollisionBox::CalculatePlaneIntersectionSimd(const dgVector &normal,
for (ptr1 = ptr->m_next; ptr1 != ptr; ptr1 = ptr1->m_next) {
index0 = ptr1->m_twin->m_vertex;
if (test[index0] >= dgFloat32(0.0f)) {
- _ASSERTE(test[ptr1->m_vertex] <= dgFloat32(0.0f));
+ NEWTON_ASSERT(test[ptr1->m_vertex] <= dgFloat32(0.0f));
break;
}
}
- _ASSERTE(ptr != ptr1);
+ NEWTON_ASSERT(ptr != ptr1);
ptr = ptr1->m_twin;
} while ((ptr != edge) && (count < 8));
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCapsule.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCapsule.cpp
index de05061e590..5c352eb272f 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCapsule.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCapsule.cpp
@@ -47,7 +47,7 @@ dgCollisionCapsule::dgCollisionCapsule(dgWorld *const world,
dgCollisionCapsule::~dgCollisionCapsule() {
m_shapeRefCount--;
- _ASSERTE(m_shapeRefCount >= 0);
+ NEWTON_ASSERT(m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -142,7 +142,7 @@ void dgCollisionCapsule::Init(dgFloat32 radius, dgFloat32 height) {
polyhedra.AddFace(DG_CAPSULE_SEGMENTS, wireframe);
polyhedra.EndFace();
- _ASSERTE(SanityCheck(polyhedra));
+ NEWTON_ASSERT(SanityCheck(polyhedra));
dgUnsigned64 i = 0;
dgPolyhedra::Iterator iter(polyhedra);
@@ -190,9 +190,9 @@ void dgCollisionCapsule::TesselateTriangle(dgInt32 level, dgFloat32 side,
const dgVector &p0, const dgVector &p1, const dgVector &p2, dgInt32 &count,
dgVector *ouput) const {
if (level) {
- _ASSERTE(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
dgVector p01(p0 + p1);
dgVector p12(p1 + p2);
dgVector p20(p2 + p0);
@@ -201,9 +201,9 @@ void dgCollisionCapsule::TesselateTriangle(dgInt32 level, dgFloat32 side,
p12 = p12.Scale(dgFloat32(1.0f) / dgSqrt(p12 % p12));
p20 = p20.Scale(dgFloat32(1.0f) / dgSqrt(p20 % p20));
- _ASSERTE(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
TesselateTriangle(level - 1, side, p0, p01, p20, count, ouput);
TesselateTriangle(level - 1, side, p1, p12, p01, count, ouput);
@@ -301,7 +301,7 @@ void dgCollisionCapsule::DebugCollision(const dgMatrix &matrixPtr,
void dgCollisionCapsule::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgVector dgCollisionCapsule::SupportVertexSimd(const dgVector &dir) const {
@@ -310,7 +310,7 @@ dgVector dgCollisionCapsule::SupportVertexSimd(const dgVector &dir) const {
dgInt32 index;
dgFloatSign *ptr;
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
ptr = (dgFloatSign *)&dir;
index = -(ptr[0].m_integer.m_iVal >> 31);
@@ -327,7 +327,7 @@ dgVector dgCollisionCapsule::SupportVertex(const dgVector &dir) const {
dgInt32 index;
const dgFloatSign *ptr;
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
ptr = (const dgFloatSign *)&dir;
index = -(ptr[0].m_integer.m_iVal >> 31);
@@ -550,7 +550,7 @@ dgInt32 dgCollisionCapsule::CalculatePlaneIntersection(const dgVector &normal,
dgFloat32 magInv = dgRsqrt(normal.m_y * normal.m_y + normal.m_z * normal.m_z);
dgFloat32 cosAng = normal.m_y * magInv;
dgFloat32 sinAng = normal.m_z * magInv;
- _ASSERTE(dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
dgVector normal1(normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng, dgFloat32(0.0f), dgFloat32(0.0f));
dgVector origin1(origin.m_x, origin.m_y * cosAng + origin.m_z * sinAng,
origin.m_z * cosAng - origin.m_y * sinAng, dgFloat32(0.0f));
@@ -598,7 +598,7 @@ dgInt32 dgCollisionCapsule::CalculatePlaneIntersection(const dgVector &normal,
dgFloat32 c = d * d - m_radius * m_radius * plane.m_y * plane.m_y;
dgFloat32 desc = b * b - dgFloat32(4.0f) * a * c;
if (desc > dgFloat32(0.0f)) {
- _ASSERTE(dgAbsf(a) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(a) > dgFloat32(0.0f));
desc = dgSqrt(desc);
a = -dgFloat32(0.5f) * b / a;
dgFloat32 x0 = a + desc;
@@ -607,8 +607,8 @@ dgInt32 dgCollisionCapsule::CalculatePlaneIntersection(const dgVector &normal,
x0 = x1;
}
if (x0 < 0.0f) {
- _ASSERTE(x0 <= dgFloat32(0.0f));
- _ASSERTE(dgAbsf(plane.m_y) > dgFloat32(0.0f));
+ NEWTON_ASSERT(x0 <= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(plane.m_y) > dgFloat32(0.0f));
dgFloat32 y = -(plane.m_x * x0 + d) / plane.m_y;
contactsOut[count] = dgVector(x0 + r, y, dgFloat32(0.0f),
dgFloat32(0.0f));
@@ -641,7 +641,7 @@ dgInt32 dgCollisionCapsule::CalculatePlaneIntersection(const dgVector &normal,
dgFloat32 c = d * d - m_radius * m_radius * plane.m_y * plane.m_y;
dgFloat32 desc = b * b - dgFloat32(4.0f) * a * c;
if (desc > dgFloat32(0.0f)) {
- _ASSERTE(dgAbsf(a) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(a) > dgFloat32(0.0f));
desc = dgSqrt(desc);
a = -dgFloat32(0.5f) * b / a;
dgFloat32 x0 = a + desc;
@@ -650,8 +650,8 @@ dgInt32 dgCollisionCapsule::CalculatePlaneIntersection(const dgVector &normal,
x0 = x1;
}
if (x0 > 0.0f) {
- _ASSERTE(x0 >= dgFloat32(0.0f));
- _ASSERTE(dgAbsf(plane.m_y) > dgFloat32(0.0f));
+ NEWTON_ASSERT(x0 >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(plane.m_y) > dgFloat32(0.0f));
dgFloat32 y = -(plane.m_x * x0 + d) / plane.m_y;
contactsOut[count] = dgVector(x0 + r, y, dgFloat32(0.0f),
dgFloat32(0.0f));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionChamferCylinder.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionChamferCylinder.cpp
index 1d65ec84ea8..4c66111826d 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionChamferCylinder.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionChamferCylinder.cpp
@@ -48,7 +48,7 @@ dgCollisionChamferCylinder::dgCollisionChamferCylinder(dgWorld *const world,
dgCollisionChamferCylinder::~dgCollisionChamferCylinder() {
m_shapeRefCount--;
- _ASSERTE(m_shapeRefCount >= 0);
+ NEWTON_ASSERT(m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -145,7 +145,7 @@ void dgCollisionChamferCylinder::Init(dgFloat32 radius, dgFloat32 height) {
polyhedra.AddFace(DG_CHAMFERCYLINDER_BRAKES, wireframe);
polyhedra.EndFace();
- _ASSERTE(SanityCheck(polyhedra));
+ NEWTON_ASSERT(SanityCheck(polyhedra));
dgUnsigned64 i = 0;
dgPolyhedra::Iterator iter(polyhedra);
@@ -253,13 +253,13 @@ dgInt32 dgCollisionChamferCylinder::CalculateSignature() const {
void dgCollisionChamferCylinder::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
/*
DG_INLINE_FUNTION dgVector dgCollisionChamferCylinder::QuatizedSupportVertexSimd (const dgVector& dir) const
{
- _ASSERTE (dgAbsf(dir % dir - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf(dir % dir - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
dgVector sideDir (dgFloat32 (0.0f), dir.m_y, dir.m_z, dgFloat32 (0.0f));
sideDir = sideDir.Scale (m_radius * dgRsqrt (sideDir % sideDir + dgFloat32 (1.0e-14f)));
@@ -268,7 +268,7 @@ void dgCollisionChamferCylinder::SetCollisionBBox(const dgVector &p0__,
DG_INLINE_FUNTION dgVector dgCollisionChamferCylinder::QuatizedSupportVertex (const dgVector& dir) const
{
- _ASSERTE (dgAbsf(dir % dir - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf(dir % dir - dgFloat32 (1.0f)) < dgFloat32 (1.0e-3f));
dgVector sideDir (dgFloat32 (0.0f), dir.m_y, dir.m_z, dgFloat32 (0.0f));
sideDir = sideDir.Scale (m_radius * dgRsqrt (sideDir % sideDir + dgFloat32 (1.0e-14f)));
@@ -282,7 +282,7 @@ dgVector dgCollisionChamferCylinder::SupportVertexSimd(
}
dgVector dgCollisionChamferCylinder::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
if (dgAbsf(dir.m_x) > dgFloat32(0.9998f)) {
dgFloat32 x0;
@@ -290,7 +290,7 @@ dgVector dgCollisionChamferCylinder::SupportVertex(const dgVector &dir) const {
return dgVector(x0, dgFloat32(0.0f), m_radius, dgFloat32(0.0f));
}
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
dgVector sideDir(dgFloat32(0.0f), dir.m_y, dir.m_z, dgFloat32(0.0f));
sideDir = sideDir.Scale(
@@ -398,7 +398,7 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
dgRsqrt(normal.m_y * normal.m_y + normal.m_z * normal.m_z);
dgFloat32 cosAng = normal.m_y * magInv;
dgFloat32 sinAng = normal.m_z * magInv;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
dgVector normal1(normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng,
dgFloat32(0.0f), dgFloat32(0.0f));
@@ -431,7 +431,7 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
} else {
dgVector dp(m_silhuette[1] - m_silhuette[0]);
dgFloat32 den = normal1 % dp;
- _ASSERTE(dgAbsf(den) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(den) > dgFloat32(0.0f));
test0 = -plane.Evalue(m_silhuette[0]) / den;
if ((test0 <= dgFloat32(1.0)) && (test0 >= dgFloat32(0.0f))) {
contactsOut[count] = m_silhuette[0] + dp.Scale(test0);
@@ -448,7 +448,7 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
dgFloat32 c = d * d - m_height * m_height * plane.m_x * plane.m_x;
dgFloat32 desc = b * b - dgFloat32(4.0f) * a * c;
if (desc > dgFloat32(0.0f)) {
- _ASSERTE(dgAbsf(a) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(a) > dgFloat32(0.0f));
desc = dgSqrt(desc);
a = -dgFloat32(0.5f) * b / a;
dgFloat32 y0 = a + desc;
@@ -456,8 +456,8 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
if (y0 > dgFloat32(0.0f)) {
y0 = y1;
}
- _ASSERTE(y0 < dgFloat32(0.0f));
- _ASSERTE(dgAbsf(plane.m_x) > dgFloat32(0.0f));
+ NEWTON_ASSERT(y0 < dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(plane.m_x) > dgFloat32(0.0f));
dgFloat32 x = -(plane.m_y * y0 + d) / plane.m_x;
contactsOut[count] = dgVector(x, y0 + r, dgFloat32(0.0f),
dgFloat32(0.0f));
@@ -469,7 +469,7 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
if (count < 2) {
dgVector dpp(m_silhuette[3] - m_silhuette[2]);
den = normal1 % dpp;
- _ASSERTE(dgAbsf(den) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(den) > dgFloat32(0.0f));
test0 = -plane.Evalue(m_silhuette[2]) / den;
if ((test0 <= dgFloat32(1.0)) && (test0 >= dgFloat32(0.0f))) {
contactsOut[count] = m_silhuette[2] + dpp.Scale(test0);
@@ -489,7 +489,7 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
dgFloat32 c = d * d - m_height * m_height * plane.m_x * plane.m_x;
dgFloat32 desc = b * b - dgFloat32(4.0f) * a * c;
if (desc > dgFloat32(0.0f)) {
- _ASSERTE(dgAbsf(a) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(a) > dgFloat32(0.0f));
desc = dgSqrt(desc);
a = -dgFloat32(0.5f) * b / a;
dgFloat32 y0 = a + desc;
@@ -497,8 +497,8 @@ dgInt32 dgCollisionChamferCylinder::CalculatePlaneIntersection(
if (y0 < dgFloat32(0.0f)) {
y0 = y1;
}
- _ASSERTE(y0 > dgFloat32(0.0f));
- _ASSERTE(dgAbsf(plane.m_x) > dgFloat32(0.0f));
+ NEWTON_ASSERT(y0 > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(plane.m_x) > dgFloat32(0.0f));
dgFloat32 x = -(plane.m_y * y0 + d) / plane.m_x;
contactsOut[count] = dgVector(x, y0 + r, dgFloat32(0.0f),
dgFloat32(0.0f));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompound.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompound.cpp
index 9ee71dfa384..2206a7de173 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompound.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompound.cpp
@@ -85,7 +85,7 @@ dgCollisionCompound::OOBBTestData::OOBBTestData(const dgMatrix &matrix,
m_extends[i][j] = dgVector(c - d, c + d, dgFloat32(0.0f),
dgFloat32(0.0f));
- _ASSERTE(m_extends[i][j].m_x <= m_extends[i][j].m_y);
+ NEWTON_ASSERT(m_extends[i][j].m_x <= m_extends[i][j].m_y);
m_crossAxisAbs[i][j] = dgVector(dgAbsf(axis.m_x), dgAbsf(axis.m_y),
dgAbsf(axis.m_z), dgFloat32(0.0f));
}
@@ -184,14 +184,14 @@ bool dgCollisionCompound::dgNodeBase::BoxTest(const OOBBTestData &data,
c = m_origin % axis;
x0 = c - d;
x1 = c + d;
- _ASSERTE(x0 <= x1);
+ NEWTON_ASSERT(x0 <= x1);
const dgVector &axisDotAbs = data.m_crossAxisDotAbs[i][j];
d = otherNode->m_size.m_x * axisDotAbs.m_x + otherNode->m_size.m_y * axisDotAbs.m_y + otherNode->m_size.m_z * axisDotAbs.m_z + dgFloat32(1.0e-3f);
c = otherOrigin % axis;
z0 = c - d;
z1 = c + d;
- _ASSERTE(z0 <= z1);
+ NEWTON_ASSERT(z0 <= z1);
if ((x1 < z0) || (x0 > z1)) {
return false;
@@ -227,7 +227,7 @@ bool dgCollisionCompound::dgNodeBase::BoxTest(const OOBBTestData &data) const {
x0 = c - d;
x1 = c + d;
- _ASSERTE(x0 <= x1);
+ NEWTON_ASSERT(x0 <= x1);
const dgVector &extend = data.m_extends[i][j];
if ((x1 < extend.m_x) || (x0 > extend.m_y)) {
return false;
@@ -396,7 +396,7 @@ dgCollisionCompound::dgCollisionCompound(dgWorld *const world,
if (node->m_left == NULL) {
node->m_left = newNode;
} else {
- _ASSERTE(!node->m_right);
+ NEWTON_ASSERT(!node->m_right);
node->m_right = newNode;
}
break;
@@ -484,11 +484,11 @@ void dgCollisionCompound::LinkParentNodes() {
void dgCollisionCompound::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgInt32 dgCollisionCompound::CalculateSignature() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
}
@@ -567,14 +567,14 @@ dgFloat32 dgCollisionCompound::RayCast(const dgVector &localP0,
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -619,14 +619,14 @@ dgFloat32 dgCollisionCompound::RayCastSimd(const dgVector &localP0,
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -718,13 +718,13 @@ void dgCollisionCompound::CalculateInertia(dgVector &inertia,
// crossInertia.m_y += totalCrossInertia.m_x + origin.m_z * origin.m_x;
// crossInertia.m_z += totalCrossInertia.m_x + origin.m_x * origin.m_y;
- _ASSERTE(inertia[0] > 0.0f);
- _ASSERTE(inertia[1] > 0.0f);
- _ASSERTE(inertia[2] > 0.0f);
+ NEWTON_ASSERT(inertia[0] > 0.0f);
+ NEWTON_ASSERT(inertia[1] > 0.0f);
+ NEWTON_ASSERT(inertia[2] > 0.0f);
}
void dgCollisionCompound::AddCollision(dgCollisionConvex *part) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
dgInt32 i;
dgInt8 *ptr;
@@ -732,7 +732,7 @@ void dgCollisionCompound::AddCollision(dgCollisionConvex *part) {
dgMatrix* collisionMatrix;
AABB* aabb;
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
if (m_count >= m_maxCount) {
m_maxCount = m_maxCount * 2;
@@ -947,7 +947,7 @@ void dgCollisionCompound::Serialize(dgSerialize callback,
bool dgCollisionCompound::OOBBTest(const dgMatrix &matrix,
const dgCollisionConvex *const shape, void *const cacheOrder) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return true;
}
@@ -1057,7 +1057,7 @@ bool dgCollisionCompound::OOBBTest(const dgMatrix &matrix,
}
}
- _ASSERTE (bestProxi != -1);
+ NEWTON_ASSERT (bestProxi != -1);
dgHeapNodePair pair;
pair.m_nodeA = i;
@@ -1099,7 +1099,7 @@ bool dgCollisionCompound::OOBBTest(const dgMatrix &matrix,
}
}
- _ASSERTE (newCount < count);
+ NEWTON_ASSERT (newCount < count);
count = newCount;
}
return proxiArray[0];
@@ -1220,8 +1220,8 @@ dgFloat32 dgCollisionCompound::CalculateSurfaceArea(dgNodeBase *const node0,
}
void dgCollisionCompound::ImproveNodeFitness(dgNodeBase *const node) const {
- _ASSERTE(node->m_left);
- _ASSERTE(node->m_right);
+ NEWTON_ASSERT(node->m_left);
+ NEWTON_ASSERT(node->m_right);
if (node->m_parent) {
if (node->m_parent->m_left == node) {
@@ -1249,7 +1249,7 @@ void dgCollisionCompound::ImproveNodeFitness(dgNodeBase *const node) const {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
}
@@ -1276,7 +1276,7 @@ void dgCollisionCompound::ImproveNodeFitness(dgNodeBase *const node) const {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
}
@@ -1318,7 +1318,7 @@ void dgCollisionCompound::ImproveNodeFitness(dgNodeBase *const node) const {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
}
@@ -1346,7 +1346,7 @@ void dgCollisionCompound::ImproveNodeFitness(dgNodeBase *const node) const {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
}
@@ -1412,7 +1412,7 @@ dgCollisionCompound::dgNodeBase *dgCollisionCompound::BuildTree(dgInt32 count,
} while (maxPasses && (newCost < prevCost));
if (tree->m_parent) {
- _ASSERTE(index);
+ NEWTON_ASSERT(index);
for (tree = proxiArray[index - 1]; tree->m_parent; tree = tree->m_parent)
;
}
@@ -1424,7 +1424,7 @@ dgInt32 dgCollisionCompound::CalculateContacts(
dgInt32 useSimd) const {
dgInt32 contactCount = 0;
if (m_root) {
- _ASSERTE(IsType(dgCollision::dgCollisionCompound_RTTI));
+ NEWTON_ASSERT(IsType(dgCollision::dgCollisionCompound_RTTI));
if (pair->m_body1->m_collision->IsType(dgCollision::dgConvexCollision_RTTI)) {
contactCount = CalculateContactsToSingle(pair, proxy, useSimd);
} else if (pair->m_body1->m_collision->IsType(
@@ -1437,7 +1437,7 @@ dgInt32 dgCollisionCompound::CalculateContacts(
dgCollision::dgCollisionHeightField_RTTI)) {
contactCount = CalculateContactsToHeightField(pair, proxy, useSimd);
} else {
- _ASSERTE(
+ NEWTON_ASSERT(
pair->m_body1->m_collision->IsType(dgCollision::dgCollisionUserMesh_RTTI));
contactCount = CalculateContactsBruteForce(pair, proxy, useSimd);
}
@@ -1456,8 +1456,8 @@ dgInt32 dgCollisionCompound::CalculateContactsToSingle(
dgBody *const otherBody = pair->m_body1;
dgBody *const compoundBody = pair->m_body0;
- _ASSERTE(pair->m_body0->m_collision == this);
- _ASSERTE(
+ NEWTON_ASSERT(pair->m_body0->m_collision == this);
+ NEWTON_ASSERT(
otherBody->m_collision->IsType(dgCollision::dgConvexCollision_RTTI));
// dgInt32 lru = m_world->m_broadPhaseLru;
@@ -1492,7 +1492,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToSingle(
stack--;
const dgNodeBase *const me = stackPool[stack];
- _ASSERTE(me);
+ NEWTON_ASSERT(me);
if (me->BoxTest(data)) {
if (me->m_type == m_leaf) {
@@ -1528,14 +1528,14 @@ dgInt32 dgCollisionCompound::CalculateContactsToSingle(
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -1553,7 +1553,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCompound(
dgBody *const myBody = pair->m_body0;
dgBody *const otherBody = pair->m_body1;
- _ASSERTE(pair->m_body0->m_collision == this);
+ NEWTON_ASSERT(pair->m_body0->m_collision == this);
dgCollisionCompound *const otherCompound =
(dgCollisionCompound *)otherBody->m_collision;
@@ -1574,7 +1574,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCompound(
const dgNodeBase *const me = stackPool[stack][0];
const dgNodeBase *const other = stackPool[stack][1];
- _ASSERTE(me && other);
+ NEWTON_ASSERT(me && other);
if (me->BoxTest(data, other)) {
if ((me->m_type == m_leaf) && (other->m_type == m_leaf)) {
@@ -1608,54 +1608,54 @@ dgInt32 dgCollisionCompound::CalculateContactsToCompound(
} else if (me->m_type == m_leaf) {
// dgNode* const otherNode = (dgNode*)other;
- _ASSERTE(other->m_type == m_node);
+ NEWTON_ASSERT(other->m_type == m_node);
stackPool[stack][0] = me;
stackPool[stack][1] = other->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack][0] = me;
stackPool[stack][1] = other->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
} else if (other->m_type == m_leaf) {
// dgNode* const myNode = (dgNode*)me;
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack][0] = me->m_left;
stackPool[stack][1] = other;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack][0] = me->m_right;
stackPool[stack][1] = other;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
} else {
- _ASSERTE(me->m_type == m_node);
- _ASSERTE(other->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
+ NEWTON_ASSERT(other->m_type == m_node);
stackPool[stack][0] = me->m_left;
stackPool[stack][1] = other->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack][0] = me->m_left;
stackPool[stack][1] = other->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack][0] = me->m_right;
stackPool[stack][1] = other->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack][0] = me->m_right;
stackPool[stack][1] = other->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -1681,7 +1681,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCollisionTree(
dgBody *const myBody = pair->m_body0;
dgBody *const treeBody = pair->m_body1;
- _ASSERTE(pair->m_body0->m_collision == this);
+ NEWTON_ASSERT(pair->m_body0->m_collision == this);
dgCollisionBVH *const treeCollision = (dgCollisionBVH *)treeBody->m_collision;
// dgInt32 lru = m_world->m_broadPhaseLru;
@@ -1713,7 +1713,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCollisionTree(
const void *const other = stackPool[stack].m_treeNode;
treeNodeIsLeaf = stackPool[stack].m_treeNodeIsLeaf;
- _ASSERTE(me && other);
+ NEWTON_ASSERT(me && other);
treeCollision->GetNodeAABB(other, nodeProxi.m_p0, nodeProxi.m_p1);
nodeProxi.m_size = (nodeProxi.m_p1 - nodeProxi.m_p0).Scale(dgFloat32(0.5f));
@@ -1721,7 +1721,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCollisionTree(
dgVector size(nodeProxi.m_size.m_y, nodeProxi.m_size.m_z,
nodeProxi.m_size.m_x, dgFloat32(0.0f));
nodeProxi.m_area = nodeProxi.m_size % size;
- _ASSERTE(nodeProxi.m_area > dgFloat32(0.0f));
+ NEWTON_ASSERT(nodeProxi.m_area > dgFloat32(0.0f));
if (me->BoxTest(data, &nodeProxi)) {
if ((me->m_type == m_leaf) && treeNodeIsLeaf) {
@@ -1808,16 +1808,16 @@ dgInt32 dgCollisionCompound::CalculateContactsToCollisionTree(
stackPool[stack].m_treeNode = other;
stackPool[stack].m_treeNodeIsLeaf = 1;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack].m_myNode = me->m_right;
stackPool[stack].m_treeNode = other;
stackPool[stack].m_treeNodeIsLeaf = 1;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
} else if (nodeProxi.m_area > me->m_area) {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
const void *const frontNode = treeCollision->GetFrontNode(other);
const void *const backNode = treeCollision->GetBackNode(other);
if (backNode && frontNode) {
@@ -1875,7 +1875,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToCollisionTree(
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack].m_myNode = me->m_left;
stackPool[stack].m_treeNode = other;
stackPool[stack].m_treeNodeIsLeaf = treeNodeIsLeaf;
@@ -1909,7 +1909,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToHeightField(
dgBody *const myBody = pair->m_body0;
dgBody *const terrainBody = pair->m_body1;
- _ASSERTE(pair->m_body0->m_collision == this);
+ NEWTON_ASSERT(pair->m_body0->m_collision == this);
dgCollisionHeightField *const terrainCollision =
(dgCollisionHeightField *)terrainBody->m_collision;
@@ -1969,7 +1969,7 @@ dgInt32 dgCollisionCompound::CalculateContactsToHeightField(
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
@@ -1993,7 +1993,7 @@ dgInt32 dgCollisionCompound::CalculateContactsBruteForce(
dgBody *const myBody = pair->m_body0;
dgBody *const userBody = pair->m_body1;
- _ASSERTE(pair->m_body0->m_collision == this);
+ NEWTON_ASSERT(pair->m_body0->m_collision == this);
dgCollisionMesh *const userCollision =
(dgCollisionMesh *)userBody->m_collision;
@@ -2043,7 +2043,7 @@ dgInt32 dgCollisionCompound::CalculateContactsBruteForce(
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
@@ -2063,7 +2063,7 @@ dgInt32 dgCollisionCompound::ClosestDitance(dgBody *const compoundBody,
}
#if 0
- _ASSERTE(compoundBody->m_collision == this);
+ NEWTON_ASSERT(compoundBody->m_collision == this);
dgCollisionConvex *const collisionB = (dgCollisionConvex *) bodyB->m_collision;
// dgInt32 lru;
@@ -2078,8 +2078,8 @@ dgInt32 dgCollisionCompound::ClosestDitance(dgBody *const compoundBody,
// otherBody = pair->m_body1;
// compoundBody = pair->m_body0;
- // _ASSERTE (pair->m_body0->m_collision == this);
- // _ASSERTE (otherBody->m_collision->IsType (dgCollision::dgConvexCollision_RTTI));
+ // NEWTON_ASSERT (pair->m_body0->m_collision == this);
+ // NEWTON_ASSERT (otherBody->m_collision->IsType (dgCollision::dgConvexCollision_RTTI));
// lru = m_world->m_broadPhaseLru;
// proxy.m_referenceBody = compoundBody;
@@ -2118,13 +2118,13 @@ dgInt32 dgCollisionCompound::ClosestDitance(dgBody *const compoundBody,
dgFloat32 dist = distPool[stack];
const dgNodeBase *const me = stackPool[stack];
- _ASSERTE(me);
+ NEWTON_ASSERT(me);
// if (me->BoxTest (data)) {
if (dist < baseDist) {
if (me->m_type == m_leaf) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
dgInt32 processContacts;
@@ -2167,27 +2167,27 @@ dgInt32 dgCollisionCompound::ClosestDitance(dgBody *const compoundBody,
rightDist = right->BoxClosestDistance(points, 8);
}
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
if (leftDist > rightDist) {
distPool[stack] = leftDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
distPool[stack] = rightDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
} else {
distPool[stack] = rightDist;
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
distPool[stack] = leftDist;
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -2243,7 +2243,7 @@ dgInt32 dgCollisionCompound::ClosestDitance(dgBody *const compoundBody,
dgCollisionParamProxy proxy(0);
dgContactPoint contacts[16];
- _ASSERTE(
+ NEWTON_ASSERT(
bodyB->m_collision->IsType(dgCollision::dgCollisionCompound_RTTI));
dgCollisionCompound *const compoundCollision1 =
(dgCollisionCompound *)bodyB->m_collision;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompoundBreakable.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompoundBreakable.cpp
index 8cf81a1ab9f..3b6a4b2a183 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompoundBreakable.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCompoundBreakable.cpp
@@ -513,12 +513,12 @@ void dgCollisionCompoundBreakable::dgDebriGraph::Serialize(dgSerialize callback,
void dgCollisionCompoundBreakable::dgDebriGraph::AddNode(
dgFlatVertexArray &flatArray, dgMeshEffect *solid, dgInt32 clipperMaterial,
dgInt32 id, dgFloat32 density, dgFloat32 padding) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
dgCollision* collision;
collision = solid->CreateConvexCollision(dgFloat32 (0.005f), id, padding, dgGetIdentityMatrix());
- _ASSERTE (collision);
+ NEWTON_ASSERT (collision);
if (collision) {
dgGraph<dgDebriNodeInfo, dgSharedNodeMesh>::dgListNode* node;
dgInt32 vertexCount;
@@ -583,7 +583,7 @@ void dgCollisionCompoundBreakable::dgDebriGraph::AddNode(
flatArray[vertexCount].m_point[9] = uv1[j].m_y;
segment->m_indexes[i] = vertexCount - baseVertexCount;
vertexCount ++;
- // _ASSERTE ((vertexCount - baseVertexCount) < dgInt32 (indexBuffer.GetElementsCount()));
+ // NEWTON_ASSERT ((vertexCount - baseVertexCount) < dgInt32 (indexBuffer.GetElementsCount()));
}
}
solid->MaterialGeomteryEnd(geometryHandle);
@@ -756,7 +756,7 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(dgInt32 count,
rootSegment.m_faceCount = rootIndexCount / 3;
segment.m_faceOffset = acc;
- // _ASSERTE (acc == segment.m_faceOffset);
+ // NEWTON_ASSERT (acc == segment.m_faceOffset);
acc += segment.m_faceCount;
}
}
@@ -791,7 +791,7 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(dgInt32 count,
otherShape = (dgCollisionConvexIntance *)treeNode->m_shape;
if (otherShape->m_graphNode != node) {
dgGraphNode<dgDebriNodeInfo, dgSharedNodeMesh>::dgListNode *adjacentEdge;
- // _ASSERTE (otherShape->m_graphNode != node)
+ // NEWTON_ASSERT (otherShape->m_graphNode != node)
for (adjacentEdge = node->GetInfo().GetFirst(); adjacentEdge;
adjacentEdge = adjacentEdge->GetNext()) {
if (adjacentEdge->GetInfo().m_node == otherShape->m_graphNode) {
@@ -825,7 +825,7 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(dgInt32 count,
}
} else {
- _ASSERTE(treeNode->m_type == m_node);
+ NEWTON_ASSERT(treeNode->m_type == m_node);
pool[stack] = treeNode->m_right;
stack++;
pool[stack] = treeNode->m_left;
@@ -877,7 +877,7 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(
info.m_index = stack;
info.m_node = myNode;
graphNodeMap.Insert(info, nodeInfo.m_shape);
- _ASSERTE(m_array[stack] == nodeInfo.m_shape);
+ NEWTON_ASSERT(m_array[stack] == nodeInfo.m_shape);
stack++;
}
@@ -896,8 +896,8 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(
dgCompoundBreakableFilterData &info =
graphNodeMap.Find(me->m_shape)->GetInfo();
index = info.m_index;
- _ASSERTE(m_array[index] == me->m_shape);
- _ASSERTE(!info.m_node->GetInfo().m_nodeData.m_shape);
+ NEWTON_ASSERT(m_array[index] == me->m_shape);
+ NEWTON_ASSERT(!info.m_node->GetInfo().m_nodeData.m_shape);
// newShape = new dgCollisionConvexIntance (((dgCollisionConvexIntance*) me->m_shape)->m_myShape, info.m_node, 0);
newShape = new (m_allocator) dgCollisionConvexIntance(
@@ -913,7 +913,7 @@ dgCollisionCompoundBreakable::dgCollisionCompoundBreakable(
newShape->AddRef();
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
@@ -999,7 +999,7 @@ void dgCollisionCompoundBreakable::LinkNodes() {
count++;
#endif
} else {
- _ASSERTE(node->m_type == m_node);
+ NEWTON_ASSERT(node->m_type == m_node);
// if (node->m_type == m_node) {
pool[stack] = node->m_right;
stack++;
@@ -1127,7 +1127,7 @@ dgInt32 dgCollisionCompoundBreakable::GetSegmentsInRadius(
stack--;
me = stackPool[stack];
- _ASSERTE(me);
+ NEWTON_ASSERT(me);
if (dgOverlapTest(me->m_p0, me->m_p1, p0, p1)) {
@@ -1153,14 +1153,14 @@ dgInt32 dgCollisionCompoundBreakable::GetSegmentsInRadius(
}
}
} else {
- _ASSERTE(me->m_type == m_node);
+ NEWTON_ASSERT(me->m_type == m_node);
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
stackPool[stack] = me->m_right;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNodeBase *)));
}
}
}
@@ -1312,7 +1312,7 @@ void dgCollisionCompoundBreakable::SetAnchoredParts(dgInt32 count,
if (leadingIndex >= dgInt32(sizeof(queue) / sizeof(queue[0]))) {
leadingIndex = 0;
}
- _ASSERTE(leadingIndex != trealingIndex);
+ NEWTON_ASSERT(leadingIndex != trealingIndex);
}
}
}
@@ -1368,7 +1368,7 @@ void dgCollisionCompoundBreakable::DeleteComponent(
}
shape = (dgCollisionConvexIntance *)node->GetInfo().m_nodeData.m_shape;
- _ASSERTE(
+ NEWTON_ASSERT(
shape->m_graphNode->GetInfo().GetFirst() == node->GetInfo().GetFirst());
m_conectivity.DeleteNode(node);
@@ -1388,7 +1388,7 @@ void dgCollisionCompoundBreakable::DeleteComponent(
dgBody *dgCollisionCompoundBreakable::CreateComponentBody(
dgDebriGraph::dgListNode *node) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return NULL;
/*
dgFloat32 Ixx;
@@ -1402,7 +1402,7 @@ dgBody *dgCollisionCompoundBreakable::CreateComponentBody(
dgCollisionConvexIntance* shape;
shape = (dgCollisionConvexIntance*) node->GetInfo().m_nodeData.m_shape;
- _ASSERTE (shape->m_graphNode->GetInfo().GetFirst() == node->GetInfo().GetFirst());
+ NEWTON_ASSERT (shape->m_graphNode->GetInfo().GetFirst() == node->GetInfo().GetFirst());
body = m_world->CreateBody(shape->m_myShape);
@@ -1413,7 +1413,7 @@ dgBody *dgCollisionCompoundBreakable::CreateComponentBody(
Iyy = shape->m_inertia.m_y;
Izz = shape->m_inertia.m_z;
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
mass = 1.0f;
Ixx = shape->m_inertia.m_x/shape->m_inertia.m_w;
Iyy = shape->m_inertia.m_y/shape->m_inertia.m_w;
@@ -1478,7 +1478,7 @@ void dgCollisionCompoundBreakable::DeleteComponentEnd() {
count--;
rootNode = stack[count];
- _ASSERTE(node->GetInfo().m_nodeData.m_commonData.m_lru == m_lru);
+ NEWTON_ASSERT(node->GetInfo().m_nodeData.m_commonData.m_lru == m_lru);
newIslandPieces[piecesCount] = rootNode;
piecesCount++;
@@ -1527,7 +1527,7 @@ void dgCollisionCompoundBreakable::DeleteComponentEnd() {
xxxx++;
#ifdef _DEBUG
for (dgInt32 j = i + 1; j < piecesCount; j++) {
- _ASSERTE(newIslandPieces[i] != newIslandPieces[j]);
+ NEWTON_ASSERT(newIslandPieces[i] != newIslandPieces[j]);
}
#endif
}
@@ -1568,7 +1568,7 @@ void dgCollisionCompoundBreakable::DeleteComponentEnd() {
}
for (dgDebriGraph::dgListNode* node = m_conectivity.GetFirst(); node != m_conectivity.GetLast(); node = node->GetNext()) {
- // _ASSERTE (node->GetInfo().m_nodeData.m_commonData.m_lru == m_lru);
+ // NEWTON_ASSERT (node->GetInfo().m_nodeData.m_commonData.m_lru == m_lru);
}
*/
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCone.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCone.cpp
index 4560dacb6ae..146bbad8157 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCone.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCone.cpp
@@ -47,7 +47,7 @@ dgCollisionCone::dgCollisionCone(dgWorld *const world,
dgCollisionCone::~dgCollisionCone() {
m_shapeRefCount--;
- _ASSERTE(m_shapeRefCount >= 0);
+ NEWTON_ASSERT(m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -95,7 +95,7 @@ void dgCollisionCone::Init(dgFloat32 radius, dgFloat32 height) {
polyhedra.AddFace(DG_CONE_SEGMENTS, wireframe);
polyhedra.EndFace();
- _ASSERTE(SanityCheck(polyhedra));
+ NEWTON_ASSERT(SanityCheck(polyhedra));
dgUnsigned64 i = 0;
dgPolyhedra::Iterator iter(polyhedra);
@@ -182,7 +182,7 @@ void dgCollisionCone::DebugCollision(const dgMatrix &matrixPtr,
void dgCollisionCone::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgVector dgCollisionCone::SupportVertexSimd(const dgVector &dir) const {
@@ -190,7 +190,7 @@ dgVector dgCollisionCone::SupportVertexSimd(const dgVector &dir) const {
}
dgVector dgCollisionCone::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
if (dir.m_x > m_sinAngle) {
return dgVector(m_height, dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f));
@@ -278,7 +278,7 @@ dgInt32 dgCollisionCone::CalculatePlaneIntersection(const dgVector &normal,
magInv = dgRsqrt(normal.m_y * normal.m_y + normal.m_z * normal.m_z);
cosAng = normal.m_y * magInv;
sinAng = normal.m_z * magInv;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
// dgVector normal1 (normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng,
// normal.m_z * cosAng - normal.m_y * sinAng, dgFloat32 (0.0f));
@@ -339,7 +339,7 @@ dgInt32 dgCollisionCone::CalculatePlaneIntersectionSimd(const dgVector &normal,
cosAng = normal.m_y * magInv;
sinAng = normal.m_z * magInv;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
// dgVector normal1 (normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng,
// normal.m_z * cosAng - normal.m_y * sinAng, dgFloat32 (0.0f));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvex.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvex.cpp
index 3d4f3c9024c..3cc8722c501 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvex.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvex.cpp
@@ -19,6 +19,8 @@
* 3. This notice may not be removed or altered from any source distribution.
*/
+#include <stdint.h>
+
#include "dgCollisionConvex.h"
#include "dgBody.h"
#include "dgCollisionConvexHull.h"
@@ -169,11 +171,11 @@ void dgCollisionConvex::SetVolumeAndCG() {
dgConvexSimplexEdge *edge = face;
dgInt32 count = 0;
do {
- _ASSERTE((edge - m_simplex) >= 0);
+ NEWTON_ASSERT((edge - m_simplex) >= 0);
edgeMarks[dgInt32(edge - m_simplex)] = '1';
faceVertex[count] = m_vertex[edge->m_vertex];
count++;
- _ASSERTE(count < dgInt32(sizeof(faceVertex) / sizeof(faceVertex[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(faceVertex) / sizeof(faceVertex[0])));
edge = edge->m_next;
} while (edge != face);
@@ -194,13 +196,13 @@ void dgCollisionConvex::SetVolumeAndCG() {
for (dgInt32 i = 0; i < count; i++) {
m_supportVertexStarCuadrant[i] = GetSupportEdge(m_multiResDir[i]);
}
- _ASSERTE(
+ NEWTON_ASSERT(
m_supportVertexStarCuadrant[4] == GetSupportEdge(m_multiResDir[0].Scale(-1.0f)));
- _ASSERTE(
+ NEWTON_ASSERT(
m_supportVertexStarCuadrant[5] == GetSupportEdge(m_multiResDir[1].Scale(-1.0f)));
- _ASSERTE(
+ NEWTON_ASSERT(
m_supportVertexStarCuadrant[6] == GetSupportEdge(m_multiResDir[2].Scale(-1.0f)));
- _ASSERTE(
+ NEWTON_ASSERT(
m_supportVertexStarCuadrant[7] == GetSupportEdge(m_multiResDir[3].Scale(-1.0f)));
// calculate the origin of the bound box of this primitive
@@ -345,8 +347,8 @@ void dgCollisionConvex::CalcAABB(const dgMatrix &matrix, dgVector &p0,
dgVector err1(p1 - q1);
dgFloat32 err;
err = GetMax(size.m_x, size.m_y, size.m_z) * 0.5f;
- _ASSERTE((err0 % err0) < err * err);
- _ASSERTE((err1 % err1) < err * err);
+ NEWTON_ASSERT((err0 % err0) < err * err);
+ NEWTON_ASSERT((err1 % err1) < err * err);
#endif
}
@@ -379,7 +381,7 @@ void dgCollisionConvex::CalcAABBSimd(const dgMatrix &matrix, dgVector &p0,
dgConvexSimplexEdge *dgCollisionConvex::GetSupportEdge(
const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
dgConvexSimplexEdge *edge = &m_simplex[0];
dgFloat32 side0 = m_vertex[edge->m_vertex] % dir;
@@ -422,12 +424,12 @@ dgFloat32 dgCollisionConvex::CalculateMassProperties(dgVector &inertia,
dgConvexMassData localData1;
DebugCollision (dgGetIdentityMatrix(), CalculateInertia, &localData1);
volume1 = localData1.MassProperties (centerOfMass1, inertia1, crossInertia1);
- _ASSERTE (dgAbsf (volume1 - volume) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf (volume1 - volume) < dgFloat32 (1.0e-3f));
for (dgInt32 i = 0; i < 3; i ++) {
- _ASSERTE (dgAbsf (inertia[i] - inertia1[i]) < dgFloat32 (1.0e-3f));
- _ASSERTE (dgAbsf (crossInertia[i] - crossInertia1[i]) < dgFloat32 (1.0e-3f));
- _ASSERTE (dgAbsf (centerOfMass[i] - centerOfMass1[i]) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf (inertia[i] - inertia1[i]) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf (crossInertia[i] - crossInertia1[i]) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf (centerOfMass[i] - centerOfMass1[i]) < dgFloat32 (1.0e-3f));
}
#endif
*/
@@ -475,9 +477,9 @@ void dgCollisionConvex::CalculateInertia(dgVector &inertiaOut,
if (inertiaOut.m_z < dgFloat32(1.0e-3f))
inertiaOut.m_z = dgFloat32(1.0e-3f);
- _ASSERTE(inertiaOut[0] > 0.0f);
- _ASSERTE(inertiaOut[1] > 0.0f);
- _ASSERTE(inertiaOut[2] > 0.0f);
+ NEWTON_ASSERT(inertiaOut[0] > 0.0f);
+ NEWTON_ASSERT(inertiaOut[1] > 0.0f);
+ NEWTON_ASSERT(inertiaOut[2] > 0.0f);
}
dgFloat32 dgCollisionConvex::GetVolume() const {
@@ -487,7 +489,7 @@ dgFloat32 dgCollisionConvex::GetVolume() const {
dgVector centerOfMass;
dgVector crossInertia;
volume = CalculateMassProperties(inertia, crossInertia, centerOfMass);
- _ASSERTE(m_volume.m_w >= dgFloat32(0.7f) * volume);
+ NEWTON_ASSERT(m_volume.m_w >= dgFloat32(0.7f) * volume);
#endif
return m_volume.m_w;
@@ -578,9 +580,9 @@ dgInt32 dgCollisionConvex::RayCastClosestFace(dgVector *tetrahedrum,
dist = (e1 * e0) % e2;
// return (volume >= dgFloat32 (0.0f));
if (dist <= dgFloat32(0.0f)) {
- //_ASSERTE (0);
+ //NEWTON_ASSERT (0);
Swap(tetrahedrum[1], tetrahedrum[2]);
- //_ASSERTE (CheckTetraHedronVolume ());
+ //NEWTON_ASSERT (CheckTetraHedronVolume ());
}
}
}
@@ -768,7 +770,7 @@ dgVector dgCollisionConvex::CalculateVolumeIntegral(const dgPlane &plane) const
m_vertex[edge->m_vertex] - m_vertex[edge->m_prev->m_vertex]);
faceVertex[count] = m_vertex[edge->m_prev->m_vertex] - dp.Scale(size0 / (plane % dp));
count++;
- _ASSERTE(count < dgInt32(sizeof(faceVertex) / sizeof(faceVertex[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(faceVertex) / sizeof(faceVertex[0])));
}
if (!capEdge) {
@@ -833,7 +835,7 @@ dgVector dgCollisionConvex::CalculateVolumeIntegral(const dgPlane &plane) const
dgVector dgCollisionConvex::SupportVertex(const dgVector &direction) const {
const dgVector dir(direction.m_x, direction.m_y, direction.m_z, dgFloat32(0.0f));
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
dgInt32 index = 0;
dgFloat32 side0 = dgFloat32(-1.0e20f);
@@ -874,15 +876,15 @@ dgVector dgCollisionConvex::SupportVertex(const dgVector &direction) const {
ptr = ptr->m_twin->m_next;
maxCount--;
} while ((ptr != edge) && maxCount);
- _ASSERTE(maxCount);
+ NEWTON_ASSERT(maxCount);
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
return m_vertex[index];
}
dgVector dgCollisionConvex::SupportVertexSimd(const dgVector &direction) const {
#ifdef DG_BUILD_SIMD_CODE
- _ASSERTE(dgAbsf(direction % direction - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(direction % direction - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
simd_type dir_x = simd_set1(direction.m_x);
simd_type dir_y = simd_set1(direction.m_y);
@@ -907,7 +909,7 @@ dgVector dgCollisionConvex::SupportVertexSimd(const dgVector &direction) const {
index = edge->m_vertex;
simd_type dir = simd_set(direction.m_x, direction.m_y, direction.m_z, dgFloat32(0.0f));
- _ASSERTE(m_vertex[edge->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[edge->m_vertex].m_w == dgFloat32(1.0f));
simd_type side0 = simd_mul_v(*(simd_type *)&m_vertex[edge->m_vertex], dir);
side0 = simd_add_s(simd_add_v(side0, simd_move_hl_v(side0, side0)), simd_permut_v(side0, side0, PURMUT_MASK(3, 3, 3, 1)));
@@ -922,7 +924,7 @@ dgVector dgCollisionConvex::SupportVertexSimd(const dgVector &direction) const {
dgInt32 index1 = ptr->m_twin->m_vertex;
if (cache[index1 & (sizeof(cache) / sizeof(cache[0]) - 1)] != index1) {
cache[index1 & (sizeof(cache) / sizeof(cache[0]) - 1)] = dgInt16(index1);
- _ASSERTE(m_vertex[index1].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[index1].m_w == dgFloat32(1.0f));
simd_type side1 = simd_mul_v(*(simd_type *)&m_vertex[index1], dir);
side1 = simd_add_s(simd_add_v(side1, simd_move_hl_v(side1, side1)), simd_permut_v(side1, side1, PURMUT_MASK(3, 3, 3, 1)));
if (simd_store_is(simd_cmpgt_s(side1, side0))) {
@@ -935,9 +937,9 @@ dgVector dgCollisionConvex::SupportVertexSimd(const dgVector &direction) const {
ptr = ptr->m_twin->m_next;
maxCount--;
} while ((ptr != edge) && maxCount);
- _ASSERTE(maxCount);
+ NEWTON_ASSERT(maxCount);
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
return m_vertex[index];
#else
return 0;
@@ -950,7 +952,7 @@ bool dgCollisionConvex::SanityCheck(dgInt32 count, const dgVector &normal,
dgInt32 j = count - 1;
for (dgInt32 i = 0; i < count; i++) {
dgVector error(contactsOut[i] - contactsOut[j]);
- // _ASSERTE ((error % error) > dgFloat32 (1.0e-20f));
+ // NEWTON_ASSERT ((error % error) > dgFloat32 (1.0e-20f));
if ((error % error) <= dgFloat32(1.0e-20f)) {
return false;
}
@@ -966,11 +968,11 @@ bool dgCollisionConvex::SanityCheck(dgInt32 count, const dgVector &normal,
n += e0 * e1;
e0 = e1;
}
- _ASSERTE((n % n) > dgFloat32(0.0f));
+ NEWTON_ASSERT((n % n) > dgFloat32(0.0f));
n = n.Scale(dgFloat32(1.0f) / dgSqrt(n % n));
dgFloat32 projection;
projection = n % normal;
- _ASSERTE(projection > dgFloat32(0.9f));
+ NEWTON_ASSERT(projection > dgFloat32(0.9f));
if (projection < dgFloat32(0.9f)) {
return false;
}
@@ -981,7 +983,7 @@ bool dgCollisionConvex::SanityCheck(dgInt32 count, const dgVector &normal,
dgVector e1(contactsOut[i] - contactsOut[j]);
dgVector nx(e0 * e1);
dgFloat32 error = nx % normal;
- _ASSERTE(error >= dgFloat32(-1.0e-4f));
+ NEWTON_ASSERT(error >= dgFloat32(-1.0e-4f));
if (error < dgFloat32(-1.0e-4f)) {
return false;
}
@@ -998,7 +1000,7 @@ dgInt32 dgCollisionConvex::SimplifyClipPolygon(dgInt32 count,
dgInt8 mark[DG_MAX_VERTEX_CLIP_FACE * 8];
dgInt8 buffer[8 * DG_MAX_VERTEX_CLIP_FACE * (sizeof(dgInt32) + sizeof(dgFloat32))];
- _ASSERTE(count < dgInt32(sizeof(mark) / sizeof(mark[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(mark) / sizeof(mark[0])));
dgUpHeap<dgInt32, dgFloat32> sortHeap(buffer, sizeof(buffer));
while (count > DG_MAX_VERTEX_CLIP_FACE) {
@@ -1051,7 +1053,7 @@ dgInt32 dgCollisionConvex::RectifyConvexSlice(dgInt32 count,
const dgVector &normal, dgVector *const contactsOut) const {
DG_CONVEX_FIXUP_FACE linkFace[DG_CLIP_MAX_POINT_COUNT * 2];
- _ASSERTE(count > 2);
+ NEWTON_ASSERT(count > 2);
DG_CONVEX_FIXUP_FACE *poly = &linkFace[0];
for (dgInt32 i = 0; i < count; i++) {
@@ -1131,14 +1133,14 @@ dgInt32 dgCollisionConvex::RectifyConvexSlice(dgInt32 count,
}
}
count = newCount;
- _ASSERTE(tmpCount == count);
+ NEWTON_ASSERT(tmpCount == count);
}
if (count > DG_MAX_VERTEX_CLIP_FACE) {
count = SimplifyClipPolygon(count, normal, contactsOut);
}
- _ASSERTE(SanityCheck(count, normal, contactsOut));
+ NEWTON_ASSERT(SanityCheck(count, normal, contactsOut));
return count;
}
@@ -1163,7 +1165,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
dgPlane plane(normal, -(normal % origin));
simd_type planeSimdD = *(simd_type *)&plane;
- _ASSERTE(m_vertex[edge->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[edge->m_vertex].m_w == dgFloat32(1.0f));
// side0 = plane.Evalue(m_vertex[edge->m_vertex]);
// simd_type tmp_ = simd_mul_v (planeSimdD, *(simd_type*)&m_vertex[edge->m_vertex]);
// tmp_ = simd_add_v (tmp_, simd_move_hl_v (tmp_, tmp_));
@@ -1184,7 +1186,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
if (simd_store_is(simd_cmpgt_s(side0, zero))) {
dgConvexSimplexEdge *ptr = edge;
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
// side1 = plane.Evalue (m_vertex[ptr->m_twin->m_vertex]);
// simd_type tmp = simd_mul_v (planeSimdD, *(simd_type*)&m_vertex[ptr->m_twin->m_vertex]);
// tmp = simd_add_v (tmp, simd_move_hl_v (tmp, tmp));
@@ -1255,7 +1257,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
} else if (simd_store_is(simd_cmplt_s(side0, zero))) {
dgConvexSimplexEdge *ptr = edge;
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
// side1 = plane.Evalue (m_vertex[ptr->m_twin->m_vertex]);
// simd_type tmp = simd_mul_v (planeSimdD, *(simd_type*)&m_vertex[ptr->m_twin->m_vertex]);
// tmp = simd_add_v (tmp, simd_move_hl_v (tmp, tmp));
@@ -1328,27 +1330,27 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
do {
// if (side0 > dgFloat32 (0.0f)) {
if (simd_store_is(simd_cmpgt_s(side0, zero))) {
- // _ASSERTE (plane.Evalue (m_vertex[ptr->m_vertex]) > dgFloat32 (0.0f));
- // _ASSERTE (plane.Evalue (m_vertex[ptr->m_twin->m_vertex]) < dgFloat32 (0.0f));
+ // NEWTON_ASSERT (plane.Evalue (m_vertex[ptr->m_vertex]) > dgFloat32 (0.0f));
+ // NEWTON_ASSERT (plane.Evalue (m_vertex[ptr->m_twin->m_vertex]) < dgFloat32 (0.0f));
// dgVector dp (m_vertex[ptr->m_twin->m_vertex] - m_vertex[ptr->m_vertex]);
simd_type deltaP =
simd_sub_v(*(simd_type *)&m_vertex[ptr->m_twin->m_vertex], *(simd_type *)&m_vertex[ptr->m_vertex]);
- _ASSERTE(((dgFloat32 *)&deltaP)[3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&deltaP)[3] == dgFloat32(0.0f));
// t = plane % dp;
simd_type tmp = simd_mul_v(planeSimdD, deltaP);
tmp =
simd_add_s(simd_add_v(tmp, simd_move_hl_v(tmp, tmp)), simd_permut_v(tmp, tmp, PURMUT_MASK(3, 3, 3, 1)));
- _ASSERTE(((dgFloat32 *)&tmp)[3] <= dgFloat32(0.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&tmp)[3] <= dgFloat32(0.0f));
- // _ASSERTE (t <= 0.0f);
+ // NEWTON_ASSERT (t <= 0.0f);
// if (t < dgFloat32 (0.0f)) {
// t = side0 / t;
// }
- // _ASSERTE (t <= dgFloat32 (0.01f));
- // _ASSERTE (t >= dgFloat32 (-1.05f));
+ // NEWTON_ASSERT (t <= dgFloat32 (0.01f));
+ // NEWTON_ASSERT (t >= dgFloat32 (-1.05f));
// contactsOut[count] = m_vertex[ptr->m_vertex] - dp.Scale (t);
tmp = simd_min_s(*(simd_type *)&m_negativeTiny, tmp);
@@ -1357,15 +1359,15 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
den =
simd_mul_s(side0, simd_mul_sub_s(simd_add_s(den, den), simd_mul_s(den, tmp), den));
den = simd_min_s(simd_max_s(den, *(simd_type *)&m_negOne), zero);
- _ASSERTE(((dgFloat32 *)&den)[0] <= dgFloat32(0.0f));
- _ASSERTE(((dgFloat32 *)&den)[0] >= dgFloat32(-1.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&den)[0] <= dgFloat32(0.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&den)[0] >= dgFloat32(-1.0f));
*((simd_type *)&contactsOut[count]) =
simd_mul_sub_v(*((simd_type *)&m_vertex[ptr->m_vertex]), deltaP, simd_permut_v(den, den, PURMUT_MASK(3, 0, 0, 0)));
dgConvexSimplexEdge *ptr1 = ptr->m_next;
for (; ptr1 != ptr; ptr1 = ptr1->m_next) {
// side0 = plane.Evalue (m_vertex[ptr1->m_twin->m_vertex]);
- _ASSERTE(m_vertex[ptr1->m_twin->m_vertex].m_w = dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr1->m_twin->m_vertex].m_w = dgFloat32(1.0f));
// tmp = simd_mul_v (planeSimdD, *(simd_type*)&m_vertex[ptr1->m_twin->m_vertex]);
// tmp = simd_add_v (tmp, simd_move_hl_v (tmp, tmp));
// tmp = simd_add_s(tmp, simd_permut_v (tmp, tmp, PURMUT_MASK (3,3,3,1)));
@@ -1381,7 +1383,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
break;
}
}
- _ASSERTE(ptr1 != ptr);
+ NEWTON_ASSERT(ptr1 != ptr);
ptr = ptr1->m_twin;
} else {
// contactsOut[count] = m_vertex[ptr->m_vertex];
@@ -1392,12 +1394,12 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
// ptr1 = ptr1->m_twin->m_next;
// side0 = plane.Evalue (m_vertex[ptr1->m_twin->m_vertex]);
// } while ((ptr1 != ptr) && (side0 < dgFloat32 (0.0f)));
- // _ASSERTE (ptr1 != ptr);
+ // NEWTON_ASSERT (ptr1 != ptr);
// do {
// ptr1 = ptr1->m_twin->m_next;
// side0 = plane.Evalue (m_vertex[ptr1->m_twin->m_vertex]);
// } while ((ptr1 != ptr) && (side0 > dgFloat32 (0.0f)));
- // _ASSERTE (side0 <= dgFloat32 (0.0f));
+ // NEWTON_ASSERT (side0 <= dgFloat32 (0.0f));
// ptr = ptr1;
// }
contactsOut[count] = m_vertex[ptr->m_vertex];
@@ -1435,7 +1437,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersectionSimd(
}
} while ((ptr != firstEdge) && (maxCount < DG_CLIP_MAX_COUNT));
- _ASSERTE(
+ NEWTON_ASSERT(
maxCount < DG_CLIP_MAX_COUNT);
if (count > 1) {
@@ -1460,7 +1462,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
if (side0 > dgFloat32(0.0f)) {
dgConvexSimplexEdge *ptr = edge;
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
side1 = plane.Evalue(m_vertex[ptr->m_twin->m_vertex]);
if (side1 < side0) {
if (side1 < dgFloat32(0.0f)) {
@@ -1492,7 +1494,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
} else if (side0 < dgFloat32(0.0f)) {
dgConvexSimplexEdge *ptr = edge;
do {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
side1 = plane.Evalue(m_vertex[ptr->m_twin->m_vertex]);
if (side1 > side0) {
if (side1 >= dgFloat32(0.0f)) {
@@ -1515,7 +1517,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
side0 = plane.Evalue(m_vertex[ptr->m_vertex]);
dgFloat32 side1 = plane.Evalue(m_vertex[ptr->m_twin->m_vertex]);
if ((side1 < dgFloat32(0.0f)) && (side0 > dgFloat32(0.0f))) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
firstEdge = ptr;
break;
}
@@ -1526,20 +1528,20 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
dgInt32 count = 0;
if (firstEdge) {
- _ASSERTE(side0 >= dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(side0 >= dgFloat32(0.0f));
+ NEWTON_ASSERT(
(side1 = plane.Evalue(m_vertex[firstEdge->m_vertex])) >= dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(
(side1 = plane.Evalue(m_vertex[firstEdge->m_twin->m_vertex])) < dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(side0 - plane.Evalue(m_vertex[firstEdge->m_vertex])) < dgFloat32(1.0e-5f));
dgInt32 maxCount = 0;
dgConvexSimplexEdge *ptr = firstEdge;
do {
if (side0 > dgFloat32(0.0f)) {
- _ASSERTE(plane.Evalue(m_vertex[ptr->m_vertex]) > dgFloat32(0.0f));
- _ASSERTE(
+ NEWTON_ASSERT(plane.Evalue(m_vertex[ptr->m_vertex]) > dgFloat32(0.0f));
+ NEWTON_ASSERT(
plane.Evalue(m_vertex[ptr->m_twin->m_vertex]) < dgFloat32(0.0f));
dgVector dp(m_vertex[ptr->m_twin->m_vertex] - m_vertex[ptr->m_vertex]);
@@ -1556,25 +1558,25 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
}
}
- _ASSERTE(t <= dgFloat32(0.01f));
- _ASSERTE(t >= dgFloat32(-1.05f));
+ NEWTON_ASSERT(t <= dgFloat32(0.01f));
+ NEWTON_ASSERT(t >= dgFloat32(-1.05f));
contactsOut[count] = m_vertex[ptr->m_vertex] - dp.Scale(t);
dgConvexSimplexEdge *ptr1 = ptr->m_next;
for (; ptr1 != ptr; ptr1 = ptr1->m_next) {
- _ASSERTE(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr->m_twin->m_vertex].m_w == dgFloat32(1.0f));
side0 = plane.Evalue(m_vertex[ptr1->m_twin->m_vertex]);
if (side0 >= dgFloat32(0.0f)) {
break;
}
}
- _ASSERTE(ptr1 != ptr);
+ NEWTON_ASSERT(ptr1 != ptr);
ptr = ptr1->m_twin;
} else {
contactsOut[count] = m_vertex[ptr->m_vertex];
dgConvexSimplexEdge *ptr1 = ptr->m_next;
for (; ptr1 != ptr; ptr1 = ptr1->m_next) {
- _ASSERTE(m_vertex[ptr1->m_twin->m_vertex].m_w == dgFloat32(1.0f));
+ NEWTON_ASSERT(m_vertex[ptr1->m_twin->m_vertex].m_w == dgFloat32(1.0f));
side0 = plane.Evalue(m_vertex[ptr1->m_twin->m_vertex]);
if (side0 >= dgFloat32(0.0f)) {
break;
@@ -1597,7 +1599,7 @@ dgInt32 dgCollisionConvex::CalculatePlaneIntersection(const dgVector &normal,
}
} while ((ptr != firstEdge) && (maxCount < DG_CLIP_MAX_COUNT));
- _ASSERTE(
+ NEWTON_ASSERT(
maxCount < DG_CLIP_MAX_COUNT);
if (count > 2) {
@@ -1827,7 +1829,7 @@ dgFloat32 dgCollisionConvex::RayCast(const dgVector &localP0,
return dgFloat32(1.2f);
}
} else {
- _ASSERTE(D >= dgFloat32(0.0f));
+ NEWTON_ASSERT(D >= dgFloat32(0.0f));
// then segment S is leaving W across face Fi
tL = GetMin(tL, t);
if (tL < tE) {
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexHull.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexHull.cpp
index 436dbcf8597..7943b2d8eff 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexHull.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexHull.cpp
@@ -89,13 +89,13 @@ dgCollisionConvexHull::dgCollisionConvexHull(dgMemoryAllocator *const allocator,
dgPlane plane(normal, dgFloat32(0.0f));
dgVector planeSupport(SupportVertex(plane));
plane.m_w = -(plane % planeSupport);
- // _ASSERTE (plane.Evalue(m_boxOrigin) < 0.0f);
+ // NEWTON_ASSERT (plane.Evalue(m_boxOrigin) < 0.0f);
dgPlane &tmpPlane = planesArray[planeCount];
tmpPlane = plane;
planesArray[planeCount].m_index = i;
planesArray[planeCount].m_face = face;
planeCount++;
- _ASSERTE(planeCount < dgInt32(sizeof(planesArray) / sizeof(planesArray[0])));
+ NEWTON_ASSERT(planeCount < dgInt32(sizeof(planesArray) / sizeof(planesArray[0])));
}
}
}
@@ -113,7 +113,7 @@ dgCollisionConvexHull::dgCollisionConvexHull(dgMemoryAllocator *const allocator,
break;
}
}
- _ASSERTE(j < m_faceCount);
+ NEWTON_ASSERT(j < m_faceCount);
}
m_boundPlanesCount++;
}
@@ -197,7 +197,7 @@ dgBigVector dgCollisionConvexHull::FaceNormal(const dgEdge *face,
dgBigVector n1(e1 * e2);
#ifdef _DEBUG
dgFloat64 mag = normal % n1;
- _ASSERTE(mag >= -dgFloat32(0.1f));
+ NEWTON_ASSERT(mag >= -dgFloat32(0.1f));
#endif
normal += n1;
e1 = e2;
@@ -214,7 +214,7 @@ dgBigVector dgCollisionConvexHull::FaceNormal(const dgEdge *face,
pool[edge->m_next->m_incidentVertex] - pool[edge->m_incidentVertex]);
dgBigVector n1(e0 * e1);
dgFloat64 x = normal % n1;
- _ASSERTE(x > -dgFloat64(0.01f));
+ NEWTON_ASSERT(x > -dgFloat64(0.01f));
e0 = e1;
edge = edge->m_next;
} while (edge != face);
@@ -258,8 +258,8 @@ bool dgCollisionConvexHull::RemoveCoplanarEdge(dgPolyhedra &polyhedra,
dgBigVector e0(
hullVertexArray[edge0->m_incidentVertex] - hullVertexArray[edge0->m_prev->m_incidentVertex]);
- _ASSERTE((e0 % e0) >= dgFloat64(0.0f));
- _ASSERTE((e1 % e1) >= dgFloat64(0.0f));
+ NEWTON_ASSERT((e0 % e0) >= dgFloat64(0.0f));
+ NEWTON_ASSERT((e1 % e1) >= dgFloat64(0.0f));
e0 = e0.Scale(dgFloat64(1.0f) / sqrt(e0 % e0));
e1 = e1.Scale(dgFloat64(1.0f) / sqrt(e1 % e1));
@@ -272,8 +272,8 @@ bool dgCollisionConvexHull::RemoveCoplanarEdge(dgPolyhedra &polyhedra,
hullVertexArray[edge0->m_next->m_next->m_incidentVertex] - hullVertexArray[edge0->m_twin->m_incidentVertex]);
dgBigVector ee0(
hullVertexArray[edge0->m_twin->m_incidentVertex] - hullVertexArray[edge0->m_twin->m_prev->m_incidentVertex]);
- _ASSERTE((ee0 % ee0) >= dgFloat64(0.0f));
- _ASSERTE((ee1 % ee1) >= dgFloat64(0.0f));
+ NEWTON_ASSERT((ee0 % ee0) >= dgFloat64(0.0f));
+ NEWTON_ASSERT((ee1 % ee1) >= dgFloat64(0.0f));
// ee0 = ee0.Scale (dgRsqrt (ee0 % ee0));
// ee1 = ee1.Scale (dgRsqrt (ee1 % ee1));
ee0 = ee0.Scale(dgFloat64(1.0f) / sqrt(ee0 % ee0));
@@ -282,8 +282,8 @@ bool dgCollisionConvexHull::RemoveCoplanarEdge(dgPolyhedra &polyhedra,
dgBigVector nn1(ee0 * ee1);
projection = nn1 % normal0;
if (projection >= DG_MAX_EDGE_ANGLE) {
- _ASSERTE(&(*iter) != edge0);
- _ASSERTE(&(*iter) != edge0->m_twin);
+ NEWTON_ASSERT(&(*iter) != edge0);
+ NEWTON_ASSERT(&(*iter) != edge0->m_twin);
polyhedra.DeleteEdge(edge0);
removeEdge = true;
}
@@ -408,7 +408,7 @@ bool dgCollisionConvexHull::Create(dgInt32 count, dgInt32 strideInBytes,
} else if ((dist21 >= dist10) && (dist21 >= dist20)) {
index = 0;
}
- _ASSERTE(index != -1);
+ NEWTON_ASSERT(index != -1);
mask[face.m_index[index]] = 0;
}
}
@@ -459,7 +459,7 @@ bool dgCollisionConvexHull::Create(dgInt32 count, dgInt32 strideInBytes,
dgStack<dgEdge *> stack(1024 + maxEdgeCount);
dgEdge *firstFace = &polyhedra.GetRoot()->GetInfo();
- _ASSERTE(firstFace->m_twin->m_next != firstFace);
+ NEWTON_ASSERT(firstFace->m_twin->m_next != firstFace);
dgInt32 stackIndex = 1;
stack[0] = firstFace;
@@ -542,7 +542,7 @@ bool dgCollisionConvexHull::Create(dgInt32 count, dgInt32 strideInBytes,
if (!mark[i]) {
dgConvexSimplexEdge *ptr = face;
do {
- _ASSERTE((ptr - m_simplex) >= 0);
+ NEWTON_ASSERT((ptr - m_simplex) >= 0);
mark[dgInt32(ptr - m_simplex)] = '1';
ptr = ptr->m_next;
} while (ptr != face);
@@ -561,7 +561,7 @@ bool dgCollisionConvexHull::Create(dgInt32 count, dgInt32 strideInBytes,
}
dgInt32 dgCollisionConvexHull::CalculateSignature() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgInt32(GetSignature());
}
@@ -575,7 +575,7 @@ dgFloat32 dgCollisionConvexHull::GetBreakImpulse() const {
void dgCollisionConvexHull::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionConvexHull::DebugCollision(const dgMatrix &matrixPtr,
@@ -649,7 +649,7 @@ void dgCollisionConvexHull::Serialize(dgSerialize callback,
bool dgCollisionConvexHull::OOBBTest(const dgMatrix &matrix,
const dgCollisionConvex *const shape, void *const cacheOrder) const {
bool ret;
- _ASSERTE(cacheOrder);
+ NEWTON_ASSERT(cacheOrder);
ret = dgCollisionConvex::OOBBTest(matrix, shape, cacheOrder);
if (ret) {
@@ -691,7 +691,7 @@ bool dgCollisionConvexHull::OOBBTest(const dgMatrix &matrix,
dir.m_w = dgFloat32(0.0f);
dgVector p(matrix.TransformVector(shape->SupportVertex(dir)));
- //_ASSERTE ((normal % (m_boxOrigin - p0)) < 0.0f);
+ //NEWTON_ASSERT ((normal % (m_boxOrigin - p0)) < 0.0f);
dist = normal % (p - p0);
if (dist > dgFloat32(0.1f)) {
for (dgInt32 j = 0;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexModifier.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexModifier.cpp
index b2cc25314cf..4ab6b5a94bc 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexModifier.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionConvexModifier.cpp
@@ -147,10 +147,10 @@ void dgCollisionConvexModifier::ModifierSetMatrix(const dgMatrix &matrix) {
// check the the matrix is correctly inverted
dgMatrix tmp(m_modifierInvMatrix * m_modifierMatrix);
for (i = 0; i < 4; i++) {
- _ASSERTE(dgAbsf(tmp[i][i] - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT(dgAbsf(tmp[i][i] - dgFloat32(1.0f)) < dgFloat32(1.0e-5f));
for (j = i + 1; j < 4; j++) {
- _ASSERTE(dgAbsf(tmp[i][j]) < dgFloat32(1.0e-5f));
- _ASSERTE(dgAbsf(tmp[j][i]) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT(dgAbsf(tmp[i][j]) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT(dgAbsf(tmp[j][i]) < dgFloat32(1.0e-5f));
}
}
#endif
@@ -162,7 +162,7 @@ dgInt32 dgCollisionConvexModifier::CalculateSignature() const {
void dgCollisionConvexModifier::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionConvexModifier::CalcAABB(const dgMatrix &matrix, dgVector &p0,
@@ -189,12 +189,12 @@ void dgCollisionConvexModifier::CalcAABBSimd(const dgMatrix &matrix,
}
dgVector dgCollisionConvexModifier::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
dgVector dir1(m_modifierMatrix.UnrotateVector(dir));
dir1 = dir1.Scale(dgRsqrt(dir1 % dir1));
- _ASSERTE(dgAbsf(dir1 % dir1 - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(dgAbsf(dir1 % dir1 - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
return m_modifierMatrix.TransformVector(
m_convexCollision->SupportVertex(dir1));
}
@@ -206,7 +206,7 @@ dgVector dgCollisionConvexModifier::SupportVertexSimd(const dgVector &dir) const
dgVector localDir;
dgVector dir1(m_modifierMatrix.UnrotateVectorSimd(dir));
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
// dir1 = dir1.Scale (dgRsqrt (dir1 % dir1));
tmp1 =
simd_mul_v((simd_type &)dir1, simd_and_v((simd_type &)dir1, (simd_type &)m_triplexMask));
@@ -219,7 +219,7 @@ dgVector dgCollisionConvexModifier::SupportVertexSimd(const dgVector &dir) const
(simd_type &)localDir =
simd_mul_v((simd_type &)dir1, simd_permut_v(tmp0, tmp0, PURMUT_MASK(3, 0, 0, 0)));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(localDir % localDir - dgFloat32(1.0f)) < dgFloat32(1.0e-2f));
return m_modifierMatrix.TransformVectorSimd(
m_convexCollision->SupportVertexSimd(localDir));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCylinder.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCylinder.cpp
index 2ff132aa86b..6e2bfd78110 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionCylinder.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionCylinder.cpp
@@ -98,7 +98,7 @@ void dgCollisionCylinder::Init(dgFloat32 radius, dgFloat32 height) {
polyhedra.AddFace(DG_CYLINDER_SEGMENTS, wireframe);
polyhedra.EndFace();
- _ASSERTE(SanityCheck(polyhedra));
+ NEWTON_ASSERT(SanityCheck(polyhedra));
dgUnsigned64 i = 0;
dgPolyhedra::Iterator iter(polyhedra);
@@ -127,7 +127,7 @@ void dgCollisionCylinder::Init(dgFloat32 radius, dgFloat32 height) {
dgCollisionCylinder::~dgCollisionCylinder() {
m_shapeRefCount--;
- _ASSERTE(m_shapeRefCount >= 0);
+ NEWTON_ASSERT(m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -146,7 +146,7 @@ dgInt32 dgCollisionCylinder::CalculateSignature() const {
void dgCollisionCylinder::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionCylinder::DebugCollision(const dgMatrix &matrixPtr,
@@ -212,7 +212,7 @@ dgVector dgCollisionCylinder::SupportVertex(const dgVector &dir) const {
dgFloat32 dist0;
dgFloat32 dist1;
- _ASSERTE (dgAbsf ((dir % dir - dgFloat32 (1.0f))) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT (dgAbsf ((dir % dir - dgFloat32 (1.0f))) < dgFloat32 (1.0e-3f));
// sign = dir.m_x > dgFloat32 (0.0f) ? dgFloat32 (1.0f) : -dgFloat32 (1.0f);
dgFloatSign *ptr = (dgFloatSign*) &dir;
@@ -240,7 +240,7 @@ dgVector dgCollisionCylinder::SupportVertex(const dgVector &dir) const {
dgFloat32 mag2;
dgFloatSign const *ptr = (const dgFloatSign *)&dir;
- _ASSERTE(dgAbsf((dir % dir - dgFloat32(1.0f))) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf((dir % dir - dgFloat32(1.0f))) < dgFloat32(1.0e-3f));
y0 = m_radius;
z0 = dgFloat32(0.0f);
@@ -261,7 +261,7 @@ dgVector dgCollisionCylinder::SupportVertex(const dgVector &dir) const {
dgFloat32 sign;
dgFloat32 invMag;
- _ASSERTE ((dir % dir - dgFloat32 (dgFloat32 (1.0f))) < dgFloat32 (1.0e-3f));
+ NEWTON_ASSERT ((dir % dir - dgFloat32 (dgFloat32 (1.0f))) < dgFloat32 (1.0e-3f));
sign = dir.m_x > dgFloat32 (0.0f) ? dgFloat32 (dgFloat32 (1.0f)) : -dgFloat32 (dgFloat32 (1.0f));
invMag = m_radius * dgRsqrt (dir.m_y * dir.m_y + dir.m_z * dir.m_z + 1.0e-12f) ;
@@ -313,7 +313,7 @@ dgInt32 dgCollisionCylinder::CalculatePlaneIntersection(const dgVector &normal,
dgFloat32 cosAng = normal.m_y * magInv;
dgFloat32 sinAng = normal.m_z * magInv;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
dgVector normal1(normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng,
dgFloat32(0.0f), dgFloat32(0.0f));
@@ -369,7 +369,7 @@ dgInt32 dgCollisionCylinder::CalculatePlaneIntersectionSimd(
// matrix[2][2] = cosAng;
// dgVector normal1 (matrix.UnrotateVector (normal));
// dgVector origin1 (matrix.UnrotateVector (origin));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(normal.m_z * cosAng - normal.m_y * sinAng) < dgFloat32(1.0e-4f));
// dgVector normal1 (normal.m_x, normal.m_y * cosAng + normal.m_z * sinAng,
// normal.m_z * cosAng - normal.m_y * sinAng, dgFloat32 (0.0f));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionEllipse.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionEllipse.cpp
index e20b62145df..82a5eab3802 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionEllipse.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionEllipse.cpp
@@ -66,7 +66,7 @@ dgInt32 dgCollisionEllipse::CalculateSignature() const {
void dgCollisionEllipse::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionEllipse::CalcAABB(const dgMatrix &matrix, dgVector &p0,
@@ -90,17 +90,17 @@ void dgCollisionEllipse::CalcAABBSimd(const dgMatrix &matrix, dgVector &p0,
dgVector xxx0;
dgVector xxx1;
CalcAABB(matrix, xxx0, xxx1);
- _ASSERTE(dgAbsf(xxx0.m_x - p0.m_x) < 1.0e-3f);
- _ASSERTE(dgAbsf(xxx0.m_y - p0.m_y) < 1.0e-3f);
- _ASSERTE(dgAbsf(xxx0.m_z - p0.m_z) < 1.0e-3f);
- _ASSERTE(dgAbsf(xxx1.m_x - p1.m_x) < 1.0e-3f);
- _ASSERTE(dgAbsf(xxx1.m_y - p1.m_y) < 1.0e-3f);
- _ASSERTE(dgAbsf(xxx1.m_z - p1.m_z) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx0.m_x - p0.m_x) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx0.m_y - p0.m_y) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx0.m_z - p0.m_z) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx1.m_x - p1.m_x) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx1.m_y - p1.m_y) < 1.0e-3f);
+ NEWTON_ASSERT(dgAbsf(xxx1.m_z - p1.m_z) < 1.0e-3f);
#endif
}
dgVector dgCollisionEllipse::SupportVertex(const dgVector &dir) const {
- _ASSERTE((dir % dir) > dgFloat32(0.999f));
+ NEWTON_ASSERT((dir % dir) > dgFloat32(0.999f));
dgVector dir1(dir.m_x * m_scale.m_x, dir.m_y * m_scale.m_y,
dir.m_z * m_scale.m_z, dgFloat32(0.0f));
@@ -113,9 +113,9 @@ dgVector dgCollisionEllipse::SupportVertex(const dgVector &dir) const {
dgVector dgCollisionEllipse::SupportVertexSimd(const dgVector &dir) const {
#ifdef DG_BUILD_SIMD_CODE
- _ASSERTE((dir % dir) > dgFloat32(0.999f));
- _ASSERTE((dgUnsigned64(&dir) & 0x0f) == 0);
- _ASSERTE((dgUnsigned64(&m_scale) & 0x0f) == 0);
+ NEWTON_ASSERT((dir % dir) > dgFloat32(0.999f));
+ NEWTON_ASSERT((dgUnsigned64(&dir) & 0x0f) == 0);
+ NEWTON_ASSERT((dgUnsigned64(&m_scale) & 0x0f) == 0);
dgVector dir1;
simd_type n;
@@ -146,7 +146,7 @@ dgVector dgCollisionEllipse::SupportVertexSimd(const dgVector &dir) const {
dgInt32 dgCollisionEllipse::CalculatePlaneIntersection(const dgVector &normal,
const dgVector &point, dgVector *const contactsOut) const {
- _ASSERTE((normal % normal) > dgFloat32(0.999f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.999f));
// contactsOut[0] = point;
dgVector n(normal.m_x * m_scale.m_x, normal.m_y * m_scale.m_y,
@@ -161,7 +161,7 @@ dgInt32 dgCollisionEllipse::CalculatePlaneIntersectionSimd(
const dgVector &normal, const dgVector &point,
dgVector *const contactsOut) const {
#ifdef DG_BUILD_SIMD_CODE
- _ASSERTE((normal % normal) > dgFloat32(0.999f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.999f));
dgVector n(normal.m_x * m_scale.m_x, normal.m_y * m_scale.m_y,
normal.m_z * m_scale.m_z, dgFloat32(0.0f));
n = n.Scale((normal % point) / (n % n));
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionHeightField.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionHeightField.cpp
index 11dc71fa73c..91b17a6dac3 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionHeightField.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionHeightField.cpp
@@ -227,9 +227,9 @@ void dgCollisionHeightField::CalculateMinExtend2d(const dgVector &p0,
void dgCollisionHeightField::CalculateMinExtend3d(const dgVector &p0,
const dgVector &p1, dgVector &boxP0, dgVector &boxP1) const {
- _ASSERTE(p0.m_x <= p1.m_x);
- _ASSERTE(p0.m_y <= p1.m_y);
- _ASSERTE(p0.m_z <= p1.m_z);
+ NEWTON_ASSERT(p0.m_x <= p1.m_x);
+ NEWTON_ASSERT(p0.m_y <= p1.m_y);
+ NEWTON_ASSERT(p0.m_z <= p1.m_z);
dgFloat32 x0 = m_horizontalScale * dgFloor((p0.m_x - dgFloat32(1.0e-3f)) * m_horizontalScaleInv);
dgFloat32 z0 = m_horizontalScale * dgFloor((p0.m_z - dgFloat32(1.0e-3f)) * m_horizontalScaleInv);
@@ -654,7 +654,7 @@ dgFloat32 dgCollisionHeightField::RayCast(const dgVector &q0,
void dgCollisionHeightField::GetVertexListIndexList(const dgVector &p0,
const dgVector &p1, dgGetVertexListIndexList &data) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
data.m_vertexCount = 0;
}
@@ -862,7 +862,7 @@ void dgCollisionHeightField::GetCollidingFaces(
m_verticalScale * dgFloat32(m_elevationMap[base + x]),
m_horizontalScale * z, dgFloat32(0.0f));
vertexIndex++;
- _ASSERTE(
+ NEWTON_ASSERT(
vertexIndex <= m_instanceData->m_vertexCount[data->m_threadNumber]);
}
base += m_width;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionMesh.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionMesh.cpp
index 835de2df435..99e06734e66 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionMesh.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionMesh.cpp
@@ -57,11 +57,11 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculateSignature() const {
}
void dgCollisionMesh::dgCollisionConvexPolygon::SetCollisionBBox(const dgVector &p0__, const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionMesh::dgCollisionConvexPolygon::Serialize(dgSerialize callback, void *const userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::RayCast(
@@ -71,27 +71,27 @@ dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::RayCast(
OnRayPrecastAction preFilter,
const dgBody *const body,
void *userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::GetVolume() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::GetBoxMinRadius() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::GetBoxMaxRadius() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
bool dgCollisionMesh::dgCollisionConvexPolygon::OOBBTest(const dgMatrix &matrix, const dgCollisionConvex *const shape, void *chache) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return true;
}
@@ -106,7 +106,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::CalculateInertia(dgVector &inert
}
dgVector dgCollisionMesh::dgCollisionConvexPolygon::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - 1.0f) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - 1.0f) < dgFloat32(1.0e-2f));
dgInt32 index = 0;
dgFloat32 val = m_localPoly[0] % dir;
for (dgInt32 i = 1; i < m_count; i++) {
@@ -121,7 +121,7 @@ dgVector dgCollisionMesh::dgCollisionConvexPolygon::SupportVertex(const dgVector
dgVector dgCollisionMesh::dgCollisionConvexPolygon::SupportVertexSimd(const dgVector &dir) const {
#ifdef DG_BUILD_SIMD_CODE
- _ASSERTE(dgAbsf(dir % dir - 1.0f) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - 1.0f) < dgFloat32(1.0e-3f));
simd_type dirX = simd_permut_v(*(simd_type *)&dir, *(simd_type *)&dir, PURMUT_MASK(0, 0, 0, 0));
simd_type dirY = simd_permut_v(*(simd_type *)&dir, *(simd_type *)&dir, PURMUT_MASK(1, 1, 1, 1));
@@ -177,7 +177,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::CalculateNormalSimd() {
normal = simd_mul_sub_v(simd_mul_v(simd_permut_v(e10, e10, PURMUT_MASK(3, 0, 2, 1)), simd_permut_v(e21, e21, PURMUT_MASK(3, 1, 0, 2))),
simd_permut_v(e10, e10, PURMUT_MASK(3, 1, 0, 2)), simd_permut_v(e21, e21, PURMUT_MASK(3, 0, 2, 1)));
- _ASSERTE(((dgFloat32 *)&normal)[3] == dgFloat32(0.0f));
+ NEWTON_ASSERT(((dgFloat32 *)&normal)[3] == dgFloat32(0.0f));
mag2 = simd_mul_v(normal, normal);
mag2 = simd_add_v(mag2, simd_move_hl_v(mag2, mag2));
mag2 = simd_sub_s(simd_add_s(mag2, simd_permut_v(mag2, mag2, PURMUT_MASK(3, 3, 3, 1))), *(simd_type *)&m_negativeTiny);
@@ -196,7 +196,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::CalculateNormal() {
dgVector e10(m_localPoly[1] - m_localPoly[0]);
dgVector e21(m_localPoly[2] - m_localPoly[1]);
dgVector normal(e10 * e21);
- _ASSERTE((normal % normal) > dgFloat32(0.0f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.0f));
m_normal = normal.Scale(dgRsqrt(normal % normal + dgFloat32(1.0e-24f)));
}
}
@@ -248,7 +248,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::QuickTestContinue(const dgCol
dgInt32 ret;
dgFloat32 val1;
- _ASSERTE(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
+ NEWTON_ASSERT(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
m_localPoly[0] = dgVector(&m_vertex[m_index[0] * m_stride]);
m_localPoly[1] = dgVector(&m_vertex[m_index[1] * m_stride]);
m_localPoly[2] = dgVector(&m_vertex[m_index[2] * m_stride]);
@@ -278,7 +278,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::QuickTestSimd(const dgCollisi
simd_type normal1;
dgVector rotatedNormal;
- _ASSERTE(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
+ NEWTON_ASSERT(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
m_localPoly[0] = dgVector(&m_vertex[m_index[0] * m_stride]);
m_localPoly[1] = dgVector(&m_vertex[m_index[1] * m_stride]);
@@ -328,7 +328,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::QuickTestSimd(const dgCollisi
}
dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::QuickTest(const dgCollisionConvex *const hull, const dgMatrix &matrix) {
- _ASSERTE(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
+ NEWTON_ASSERT(m_count < dgInt32(sizeof(m_localPoly) / sizeof(m_localPoly[0])));
m_localPoly[0] = dgVector(&m_vertex[m_index[0] * m_stride]);
m_localPoly[1] = dgVector(&m_vertex[m_index[1] * m_stride]);
@@ -394,14 +394,14 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::ClipContacts(dgInt32 count, d
}
j0 = j1;
}
- _ASSERTE(m_adjacentNormalIndex);
+ NEWTON_ASSERT(m_adjacentNormalIndex);
if (m_adjacentNormalIndex[closestEdgeIndex] == -1) {
contactOut[i].m_normal = normal;
} else {
dgVector aNormal(globalMatrix.RotateVector(dgVector(&m_vertex[m_adjacentNormalIndex[closestEdgeIndex] * m_stride])));
- _ASSERTE((normal % normal) > 0.9999f);
- _ASSERTE((aNormal % aNormal) > 0.9999f);
+ NEWTON_ASSERT((normal % normal) > 0.9999f);
+ NEWTON_ASSERT((aNormal % aNormal) > 0.9999f);
dgFloat32 dot = normal % aNormal;
if ((dot * dot) > dgFloat32(0.999f)) {
normal += aNormal;
@@ -464,7 +464,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::BeamClipping(const dgCollisionCo
dgVector origin(matrix.UnrotateVector(matrix.m_posit.Scale(dgFloat32(-1.0f))));
dgVector dir(m_localPoly[1] - m_localPoly[0]);
- _ASSERTE((dir % dir) > dgFloat32(1.0e-8f));
+ NEWTON_ASSERT((dir % dir) > dgFloat32(1.0e-8f));
dir = dir.Scale(dgRsqrt(dir % dir));
dgFloat32 test(dir % origin);
@@ -501,7 +501,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::BeamClipping(const dgCollisionCo
DG_CLIPPED_FACE_EDGE *first = &clippedFace[0];
for (dgInt32 i = 0; i < 4; i++) {
const dgPlane &plane = planes[i];
- _ASSERTE(plane.Evalue(origin) > dgFloat32(0.0f));
+ NEWTON_ASSERT(plane.Evalue(origin) > dgFloat32(0.0f));
dgInt32 conectCount = 0;
DG_CLIPPED_FACE_EDGE *connect[2];
@@ -580,7 +580,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::BeamClipping(const dgCollisionCo
if (conectCount) {
first = newFirst;
- _ASSERTE(conectCount == 2);
+ NEWTON_ASSERT(conectCount == 2);
DG_CLIPPED_FACE_EDGE *const newEdge = &clippedFace[edgeCount];
newEdge->m_twin = newEdge + 1;
@@ -606,7 +606,7 @@ void dgCollisionMesh::dgCollisionConvexPolygon::BeamClipping(const dgCollisionCo
if (m_adjacentNormalIndex) {
m_adjacentNormalIndex = &m_clippEdgeNormal[0];
do {
- _ASSERTE(ptr->m_incidentNormal == -1);
+ NEWTON_ASSERT(ptr->m_incidentNormal == -1);
m_clippEdgeNormal[count] = ptr->m_incidentNormal;
m_localPoly[count] = points[ptr->m_incidentVertex];
count++;
@@ -645,8 +645,8 @@ dgVector dgCollisionMesh::dgCollisionConvexPolygon::ClosestDistanceToTriangle(co
dgFloat32 vc = alpha1 * alpha4 - alpha3 * alpha2;
if ((vc <= dgFloat32(0.0f)) && (alpha1 >= dgFloat32(0.0f)) && (alpha3 <= dgFloat32(0.0f))) {
dgFloat32 t = alpha1 / (alpha1 - alpha3);
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p0 + p10.Scale(t);
}
@@ -660,16 +660,16 @@ dgVector dgCollisionMesh::dgCollisionConvexPolygon::ClosestDistanceToTriangle(co
dgFloat32 vb = alpha5 * alpha2 - alpha1 * alpha6;
if ((vb <= dgFloat32(0.0f)) && (alpha2 >= dgFloat32(0.0f)) && (alpha6 <= dgFloat32(0.0f))) {
dgFloat32 t = alpha2 / (alpha2 - alpha6);
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p0 + p20.Scale(t);
}
dgFloat32 va = alpha3 * alpha6 - alpha5 * alpha4;
if ((va <= dgFloat32(0.0f)) && ((alpha4 - alpha3) >= dgFloat32(0.0f)) && ((alpha5 - alpha6) >= dgFloat32(0.0f))) {
dgFloat32 t = (alpha4 - alpha3) / ((alpha4 - alpha3) + (alpha5 - alpha6));
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
return p1 + (p2 - p1).Scale(t);
}
@@ -677,10 +677,10 @@ dgVector dgCollisionMesh::dgCollisionConvexPolygon::ClosestDistanceToTriangle(co
dgFloat32 den = float(1.0f) / (va + vb + vc);
dgFloat32 t = vb * den;
dgFloat32 s = vc * den;
- _ASSERTE(t >= dgFloat32(0.0f));
- _ASSERTE(s >= dgFloat32(0.0f));
- _ASSERTE(t <= dgFloat32(1.0f));
- _ASSERTE(s <= dgFloat32(1.0f));
+ NEWTON_ASSERT(t >= dgFloat32(0.0f));
+ NEWTON_ASSERT(s >= dgFloat32(0.0f));
+ NEWTON_ASSERT(t <= dgFloat32(1.0f));
+ NEWTON_ASSERT(s <= dgFloat32(1.0f));
return p0 + p10.Scale(t) + p20.Scale(s);
}
@@ -747,7 +747,7 @@ bool dgCollisionMesh::dgCollisionConvexPolygon::DistanceToOrigen(const dgMatrix
dgVector e10(m_localPoly[1] - m_localPoly[0]);
dgVector e21(m_localPoly[2] - m_localPoly[1]);
dgVector normal(e10 * e21);
- _ASSERTE((normal % normal) > dgFloat32(0.0f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.0f));
m_normal = normal.Scale(dgRsqrt(normal % normal + dgFloat32(1.0e-24f)));
out = closestPoint;
@@ -853,7 +853,7 @@ dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::MovingPointToPolygonContact
dgVector dp(p - closestPoint);
dgFloat32 dist2 = dp % dp;
if (dist2 > dgFloat32(0.0f)) {
- _ASSERTE(dist2 > dgFloat32(0.0f));
+ NEWTON_ASSERT(dist2 > dgFloat32(0.0f));
dgFloat32 dist2Inv = dgRsqrt(dist2);
dgFloat32 side = dist2 * dist2Inv - radius;
if (side < (-DG_RESTING_CONTACT_PENETRATION)) {
@@ -880,7 +880,7 @@ dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::MovingPointToPolygonContact
dgFloat32 scale = dgFloat32(1.0f) / dgSqrt(veloc % veloc);
dgVector vdir = veloc.Scale(scale);
- _ASSERTE(dgAbsf(m_normal % vdir) > dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(m_normal % vdir) > dgFloat32(0.0f));
dgVector supportPoint(p - m_normal.Scale(radius));
dgFloat32 timeToImpact = -(m_normal % (supportPoint - m_localPoly[0])) / (m_normal % vdir);
dgVector point(supportPoint + vdir.Scale(timeToImpact));
@@ -900,7 +900,7 @@ dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::MovingPointToPolygonContact
}
if (!isEdgeFlag) {
- _ASSERTE(minDistance < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(minDistance < dgFloat32(1.0e-3f));
timestep = GetMax(timeToImpact, dgFloat32(0.0f));
contact.m_normal = m_normal;
contact.m_penetration = dgFloat32(0.0f);
@@ -910,7 +910,7 @@ dgFloat32 dgCollisionMesh::dgCollisionConvexPolygon::MovingPointToPolygonContact
} else {
/*
- _ASSERTE (isEdge);
+ NEWTON_ASSERT (isEdge);
dgVector dp (closestPointN - p);
// this does not really work ( goidnm back to my old method
@@ -1017,7 +1017,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersectionSim
if (side1 <= dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
dgFloat32 t = plane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
@@ -1034,7 +1034,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersectionSim
} else if (side1 > dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
dgFloat32 t = plane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
@@ -1095,7 +1095,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersectionSim
j = count - 1;
for (dgInt32 i = 0; i < count; i++) {
dgVector error(contactsOut[i] - contactsOut[j]);
- _ASSERTE((error % error) > dgFloat32(1.0e-20f));
+ NEWTON_ASSERT((error % error) > dgFloat32(1.0e-20f));
j = i;
}
@@ -1109,7 +1109,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersectionSim
}
n = n.Scale(dgFloat32(1.0f) / dgSqrt(n % n));
dgFloat32 val = n % normal;
- _ASSERTE(val > dgFloat32(0.9f));
+ NEWTON_ASSERT(val > dgFloat32(0.9f));
}
}
#endif
@@ -1138,7 +1138,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersection(co
dgInt32 j = count - 1;
for (dgInt32 i = 0; i < count; i++) {
dgVector error(contactsOut[i] - contactsOut[j]);
- _ASSERTE((error % error) > dgFloat32(1.0e-20f));
+ NEWTON_ASSERT((error % error) > dgFloat32(1.0e-20f));
j = i;
}
#endif
@@ -1169,7 +1169,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersection(co
if (side1 <= dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
dgFloat32 t = plane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
@@ -1186,7 +1186,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersection(co
} else if (side1 > dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
dgFloat32 t = plane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
@@ -1246,7 +1246,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersection(co
dgInt32 j = count - 1;
for (dgInt32 i = 0; i < count; i++) {
dgVector error(contactsOut[i] - contactsOut[j]);
- _ASSERTE((error % error) > dgFloat32(1.0e-20f));
+ NEWTON_ASSERT((error % error) > dgFloat32(1.0e-20f));
j = i;
}
@@ -1260,7 +1260,7 @@ dgInt32 dgCollisionMesh::dgCollisionConvexPolygon::CalculatePlaneIntersection(co
}
n = n.Scale(dgFloat32(1.0f) / dgSqrt(n % n));
dgFloat32 val = n % normal;
- _ASSERTE(val > dgFloat32(0.9f));
+ NEWTON_ASSERT(val > dgFloat32(0.9f));
}
}
#endif
@@ -1304,16 +1304,16 @@ dgCollisionMesh::~dgCollisionMesh() {
}
void dgCollisionMesh::SetCollisionBBox(const dgVector &p0, const dgVector &p1) {
- _ASSERTE(p0.m_x <= p1.m_x);
- _ASSERTE(p0.m_y <= p1.m_y);
- _ASSERTE(p0.m_z <= p1.m_z);
+ NEWTON_ASSERT(p0.m_x <= p1.m_x);
+ NEWTON_ASSERT(p0.m_y <= p1.m_y);
+ NEWTON_ASSERT(p0.m_z <= p1.m_z);
m_boxSize = (p1 - p0).Scale(dgFloat32(0.5f));
m_boxOrigin = (p1 + p0).Scale(dgFloat32(0.5f));
}
dgInt32 dgCollisionMesh::CalculateSignature() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
}
@@ -1370,8 +1370,8 @@ void dgCollisionMesh::CalcAABB(const dgMatrix &matrix, dgVector &p0, dgVector &p
dgVector err1(p1 - q1);
dgFloat32 err;
err = GetMax(size.m_x, size.m_y, size.m_z) * 0.5f;
- _ASSERTE((err0 % err0) < err);
- _ASSERTE((err1 % err1) < err);
+ NEWTON_ASSERT((err0 % err0) < err);
+ NEWTON_ASSERT((err1 % err1) < err);
#endif
}
@@ -1400,22 +1400,22 @@ dgInt32 dgCollisionMesh::CalculatePlaneIntersection(const dgFloat32 *vertex, con
if (side1 >= dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
t = localPlane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
contactsOut[count] = p0 - dp.Scale(side0 / t);
count++;
}
} else if (side1 <= dgFloat32(0.0f)) {
dgVector dp(p1 - p0);
t = localPlane % dp;
- _ASSERTE(dgAbsf(t) >= dgFloat32(0.0f));
+ NEWTON_ASSERT(dgAbsf(t) >= dgFloat32(0.0f));
if (dgAbsf(t) < dgFloat32(1.0e-8f)) {
t = GetSign(t) * dgFloat32(1.0e-8f);
}
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
contactsOut[count] = p0 - dp.Scale(side0 / t);
count++;
}
@@ -1433,11 +1433,11 @@ dgVector dgCollisionMesh::CalculateVolumeIntegral(const dgMatrix &globalMatrix__
// void dgCollisionMesh::DebugCollision (const dgBody& myBody, DebugCollisionMeshCallback callback) const
void dgCollisionMesh::DebugCollision(const dgMatrix &matrixPtr, OnDebugCollisionMeshCallback callback, void *const userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgFloat32 dgCollisionMesh::GetVolume() const {
- // _ASSERTE (0);
+ // NEWTON_ASSERT (0);
return dgFloat32(0.0f);
}
@@ -1460,22 +1460,22 @@ void dgCollisionMesh::CalculateInertia(dgVector &inertia, dgVector &origin) cons
}
void dgCollisionMesh::GetCollisionInfo(dgCollisionInfo *info) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// dgCollision::GetCollisionInfo(info);
// info->m_offsetMatrix = GetOffsetMatrix();
// info->m_collisionType = m_collsionId;
}
void dgCollisionMesh::Serialize(dgSerialize callback, void *const userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgVector dgCollisionMesh::SupportVertex(const dgVector &dir) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(0, 0, 0, 0);
}
bool dgCollisionMesh::OOBBTest(const dgMatrix &matrix, const dgCollisionConvex *const shape, void *const cacheOrder) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return true;
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionNull.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionNull.cpp
index 595f3fa3d4a..af9adf1ead9 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionNull.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionNull.cpp
@@ -50,7 +50,7 @@ dgCollisionNull::~dgCollisionNull() {
void dgCollisionNull::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
void dgCollisionNull::DebugCollision(const dgMatrix &matrixPtr,
@@ -82,13 +82,13 @@ void dgCollisionNull::CalcAABBSimd(const dgMatrix &matrix, dgVector &p0,
}
dgVector dgCollisionNull::SupportVertex(const dgVector &dir) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f),
dgFloat32(0.0f));
}
dgVector dgCollisionNull::SupportVertexSimd(const dgVector &dir) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f),
dgFloat32(0.0f));
}
@@ -113,7 +113,7 @@ dgFloat32 dgCollisionNull::RayCastSimd(const dgVector &localP0,
dgVector dgCollisionNull::CalculateVolumeIntegral(const dgMatrix &matrix__,
GetBuoyancyPlane buoyancuPlane__, void *context__) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(0.0f, 0.0f, 0.0f, 0.0f);
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionScene.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionScene.cpp
index 8d39058d849..673d658cf13 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionScene.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionScene.cpp
@@ -39,7 +39,7 @@ dgCollisionScene::dgNode::dgNode(dgNode *const sibling, dgNode *const myNode) :
if (m_parent->m_left == sibling) {
m_parent->m_left = this;
} else {
- _ASSERTE(m_parent->m_right == sibling);
+ NEWTON_ASSERT(m_parent->m_right == sibling);
m_parent->m_right = this;
}
}
@@ -240,7 +240,7 @@ void *dgCollisionScene::GetProxyUserData(void *const proxy) const {
void dgCollisionScene::SetCollisionCallback(
dgCollisionMeshCollisionCallback debugCallback) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
for (dgList<dgProxy>::dgListNode* node = m_list.GetFirst(); node; node = node->GetNext()) {
const dgCollisionScene::dgProxy& entry = node->GetInfo();
@@ -279,8 +279,8 @@ void dgCollisionScene::CalcAABB(const dgMatrix &matrix, dgVector &p0,
dgVector err1(p1 - q1);
dgFloat32 err;
err = GetMax(size.m_x, size.m_y, size.m_z) * 0.5f;
- _ASSERTE((err0 % err0) < err);
- _ASSERTE((err1 % err1) < err);
+ NEWTON_ASSERT((err0 % err0) < err);
+ NEWTON_ASSERT((err1 % err1) < err);
#endif
}
@@ -301,12 +301,12 @@ void dgCollisionScene::DebugCollision(const dgMatrix &matrix,
}
dgFloat32 dgCollisionScene::GetVolume() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
dgInt32 dgCollisionScene::CalculateSignature() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
}
@@ -319,9 +319,9 @@ dgFloat32 dgCollisionScene::GetBoxMaxRadius() const {
}
void dgCollisionScene::SetCollisionBBox(const dgVector &p0, const dgVector &p1) {
- _ASSERTE(p0.m_x <= p1.m_x);
- _ASSERTE(p0.m_y <= p1.m_y);
- _ASSERTE(p0.m_z <= p1.m_z);
+ NEWTON_ASSERT(p0.m_x <= p1.m_x);
+ NEWTON_ASSERT(p0.m_y <= p1.m_y);
+ NEWTON_ASSERT(p0.m_z <= p1.m_z);
m_boxSize = (p1 - p0).Scale(dgFloat32(0.5f));
m_boxOrigin = (p1 + p0).Scale(dgFloat32(0.5f));
@@ -340,7 +340,7 @@ void dgCollisionScene::CalculateInertia(dgVector &inertia,
dgVector dgCollisionScene::CalculateVolumeIntegral(const dgMatrix &globalMatrix,
GetBuoyancyPlane bouyancyPlane, void *const context) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f),
dgFloat32(0.0f));
}
@@ -353,12 +353,12 @@ void dgCollisionScene::GetCollisionInfo(dgCollisionInfo *info) const {
bool dgCollisionScene::OOBBTest(const dgMatrix &matrix,
const dgCollisionConvex *const shape, void *const cacheOrder) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return true;
}
dgVector dgCollisionScene::SupportVertex(const dgVector &dir) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(0, 0, 0, 0);
}
@@ -382,14 +382,14 @@ dgFloat32 dgCollisionScene::RayCastSimd(const dgVector &localP0,
if (ray.BoxTestSimd(me->m_minBox, me->m_maxBox)) {
if (!me->m_left) {
- _ASSERTE(!me->m_right);
+ NEWTON_ASSERT(!me->m_right);
dgContactPoint tmpContactOut;
const dgProxy *const proxy = (const dgProxy *)me;
dgVector l0(proxy->m_matrix.UntransformVector(localP0));
dgVector l1(proxy->m_matrix.UntransformVector(localP1));
dgFloat32 param = proxy->m_shape->RayCastSimd(l0, l1, tmpContactOut,
preFilter, body, userData);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
contactOut.m_normal = proxy->m_matrix.RotateVectorSimd(
tmpContactOut.m_normal);
@@ -397,13 +397,13 @@ dgFloat32 dgCollisionScene::RayCastSimd(const dgVector &localP0,
ray.Reset(maxParam);
}
} else {
- _ASSERTE(me->m_left);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_left);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(me->m_right);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_right);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_right;
stack++;
}
@@ -435,14 +435,14 @@ dgFloat32 dgCollisionScene::RayCast(const dgVector &localP0,
// xxx ++;
if (ray.BoxTest(me->m_minBox, me->m_maxBox)) {
if (!me->m_left) {
- _ASSERTE(!me->m_right);
+ NEWTON_ASSERT(!me->m_right);
dgContactPoint tmpContactOut;
const dgProxy *const proxy = (const dgProxy *)me;
dgVector l0(proxy->m_matrix.UntransformVector(localP0));
dgVector l1(proxy->m_matrix.UntransformVector(localP1));
dgFloat32 param = proxy->m_shape->RayCast(l0, l1, tmpContactOut,
preFilter, body, userData);
- _ASSERTE(param >= dgFloat32(0.0f));
+ NEWTON_ASSERT(param >= dgFloat32(0.0f));
if (param < maxParam) {
contactOut.m_normal = proxy->m_matrix.RotateVector(
tmpContactOut.m_normal);
@@ -450,13 +450,13 @@ dgFloat32 dgCollisionScene::RayCast(const dgVector &localP0,
ray.Reset(maxParam);
}
} else {
- _ASSERTE(me->m_left);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_left);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(me->m_right);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_right);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_right;
stack++;
}
@@ -470,13 +470,13 @@ void dgCollisionScene::CollidePairSimd(
dgCollisionParamProxy &proxy) const {
const dgNode *stackPool[DG_SCENE_MAX_STACK_DEPTH];
- _ASSERTE(pair->m_body1->GetCollision() == this);
- _ASSERTE(
+ NEWTON_ASSERT(pair->m_body1->GetCollision() == this);
+ NEWTON_ASSERT(
pair->m_body1->GetCollision()->IsType(dgCollision::dgCollisionScene_RTTI));
dgVector p0;
dgVector p1;
- _ASSERTE(m_world == pair->m_body1->GetWorld());
+ NEWTON_ASSERT(m_world == pair->m_body1->GetWorld());
dgMatrix matrix(pair->m_body0->m_matrix * pair->m_body1->m_matrix.Inverse());
pair->m_body0->GetCollision()->CalcAABBSimd(matrix, p0, p1);
@@ -489,17 +489,17 @@ void dgCollisionScene::CollidePairSimd(
if (dgOverlapTestSimd(me->m_minBox, me->m_maxBox, p0, p1)) {
if (!me->m_left) {
- _ASSERTE(!me->m_right);
+ NEWTON_ASSERT(!me->m_right);
const dgProxy *const sceneProxy = (const dgProxy *)me;
m_world->SceneContactsSimd(*sceneProxy, pair, proxy);
} else {
- _ASSERTE(me->m_left);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_left);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(me->m_right);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_right);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_right;
stack++;
}
@@ -511,13 +511,13 @@ void dgCollisionScene::CollidePair(dgCollidingPairCollector::dgPair *const pair,
dgCollisionParamProxy &proxy) const {
const dgNode *stackPool[DG_SCENE_MAX_STACK_DEPTH];
- _ASSERTE(pair->m_body1->GetCollision() == this);
- _ASSERTE(
+ NEWTON_ASSERT(pair->m_body1->GetCollision() == this);
+ NEWTON_ASSERT(
pair->m_body1->GetCollision()->IsType(dgCollision::dgCollisionScene_RTTI));
dgVector p0;
dgVector p1;
- _ASSERTE(m_world == pair->m_body1->GetWorld());
+ NEWTON_ASSERT(m_world == pair->m_body1->GetWorld());
dgMatrix matrix(pair->m_body0->m_matrix * pair->m_body1->m_matrix.Inverse());
pair->m_body0->GetCollision()->CalcAABB(matrix, p0, p1);
@@ -530,17 +530,17 @@ void dgCollisionScene::CollidePair(dgCollidingPairCollector::dgPair *const pair,
if (dgOverlapTest(me->m_minBox, me->m_maxBox, p0, p1)) {
if (!me->m_left) {
- _ASSERTE(!me->m_right);
+ NEWTON_ASSERT(!me->m_right);
const dgProxy *const sceneProxy = (const dgProxy *)me;
m_world->SceneContacts(*sceneProxy, pair, proxy);
} else {
- _ASSERTE(me->m_left);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_left);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_left;
stack++;
- _ASSERTE(me->m_right);
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
+ NEWTON_ASSERT(me->m_right);
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(dgNode *)));
stackPool[stack] = me->m_right;
stack++;
}
@@ -549,8 +549,8 @@ void dgCollisionScene::CollidePair(dgCollidingPairCollector::dgPair *const pair,
}
void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
- _ASSERTE(node->m_left);
- _ASSERTE(node->m_right);
+ NEWTON_ASSERT(node->m_left);
+ NEWTON_ASSERT(node->m_right);
if (node->m_parent) {
if (node->m_parent->m_left == node) {
@@ -575,7 +575,7 @@ void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
} else {
@@ -600,7 +600,7 @@ void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
} else {
@@ -639,7 +639,7 @@ void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
} else {
@@ -664,7 +664,7 @@ void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
if (parent->m_parent->m_left == parent) {
parent->m_parent->m_left = node;
} else {
- _ASSERTE(parent->m_parent->m_right == parent);
+ NEWTON_ASSERT(parent->m_parent->m_right == parent);
parent->m_parent->m_right = node;
}
} else {
@@ -683,7 +683,7 @@ void dgCollisionScene::ImproveNodeFitness(dgNode *const node) {
}
}
- _ASSERTE(!m_rootNode->m_parent);
+ NEWTON_ASSERT(!m_rootNode->m_parent);
}
void dgCollisionScene::ImproveTotalFitness() {
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionSphere.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionSphere.cpp
index 396dfebf670..74836fce239 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionSphere.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionSphere.cpp
@@ -50,7 +50,7 @@ dgCollisionSphere::dgCollisionSphere(dgWorld *const world,
dgCollisionSphere::~dgCollisionSphere() {
m_shapeRefCount--;
- _ASSERTE(m_shapeRefCount >= 0);
+ NEWTON_ASSERT(m_shapeRefCount >= 0);
dgCollisionConvex::m_simplex = NULL;
dgCollisionConvex::m_vertex = NULL;
@@ -93,11 +93,11 @@ void dgCollisionSphere::Init(dgFloat32 radius, dgMemoryAllocator *allocator) {
TesselateTriangle(i, p5, p3, p1, count, tmpVectex);
TesselateTriangle(i, p5, p0, p3, count, tmpVectex);
- //_ASSERTE (count == EDGE_COUNT);
+ //NEWTON_ASSERT (count == EDGE_COUNT);
dgInt32 vertexCount = dgVertexListToIndexList(&tmpVectex[0].m_x,
sizeof(dgVector), 3 * sizeof(dgFloat32), 0, count, indexList, 0.001f);
- _ASSERTE(vertexCount == DG_SPHERE_VERTEX_COUNT);
+ NEWTON_ASSERT(vertexCount == DG_SPHERE_VERTEX_COUNT);
for (dgInt32 j = 0; j < vertexCount; j++) {
m_unitSphere[j] = tmpVectex[j];
}
@@ -108,7 +108,7 @@ void dgCollisionSphere::Init(dgFloat32 radius, dgMemoryAllocator *allocator) {
#ifdef _DEBUG
dgEdge *const edge = polyhedra.AddFace(indexList[j], indexList[j + 1],
indexList[j + 2]);
- _ASSERTE(edge);
+ NEWTON_ASSERT(edge);
#else
polyhedra.AddFace(indexList[j], indexList[j + 1], indexList[j + 2]);
#endif
@@ -151,13 +151,13 @@ void dgCollisionSphere::Init(dgFloat32 radius, dgMemoryAllocator *allocator) {
}
dgVector dgCollisionSphere::SupportVertexSimd(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
// return SupportVertex (dir);
return dir.Scale(m_radius);
}
dgVector dgCollisionSphere::SupportVertex(const dgVector &dir) const {
- _ASSERTE(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
+ NEWTON_ASSERT(dgAbsf(dir % dir - dgFloat32(1.0f)) < dgFloat32(1.0e-3f));
return dir.Scale(m_radius);
}
@@ -165,9 +165,9 @@ void dgCollisionSphere::TesselateTriangle(dgInt32 level, const dgVector &p0,
const dgVector &p1, const dgVector &p2, dgInt32 &count,
dgVector *ouput) const {
if (level) {
- _ASSERTE(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p0 % p0 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p1 % p1 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p2 % p2 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
dgVector p01(p0 + p1);
dgVector p12(p1 + p2);
dgVector p20(p2 + p0);
@@ -176,9 +176,9 @@ void dgCollisionSphere::TesselateTriangle(dgInt32 level, const dgVector &p0,
p12 = p12.Scale(dgFloat32(1.0f) / dgSqrt(p12 % p12));
p20 = p20.Scale(dgFloat32(1.0f) / dgSqrt(p20 % p20));
- _ASSERTE(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
- _ASSERTE(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p01 % p01 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p12 % p12 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
+ NEWTON_ASSERT(dgAbsf(p20 % p20 - dgFloat32(1.0f)) < dgFloat32(1.0e-4f));
TesselateTriangle(level - 1, p0, p01, p20, count, ouput);
TesselateTriangle(level - 1, p1, p12, p01, count, ouput);
@@ -194,7 +194,7 @@ void dgCollisionSphere::TesselateTriangle(dgInt32 level, const dgVector &p0,
void dgCollisionSphere::SetCollisionBBox(const dgVector &p0__,
const dgVector &p1__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgInt32 dgCollisionSphere::CalculateSignature() const {
@@ -225,7 +225,7 @@ void dgCollisionSphere::CalcAABB(const dgMatrix &matrix, dgVector &p0,
dgInt32 dgCollisionSphere::CalculatePlaneIntersection(const dgVector &normal,
const dgVector &point, dgVector *const contactsOut) const {
- _ASSERTE((normal % normal) > dgFloat32(0.999f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.999f));
// contactsOut[0] = point;
contactsOut[0] = normal.Scale(normal % point);
return 1;
@@ -236,7 +236,7 @@ dgInt32 dgCollisionSphere::CalculatePlaneIntersectionSimd(
dgVector *const contactsOut) const {
#ifdef DG_BUILD_SIMD_CODE
- _ASSERTE((normal % normal) > dgFloat32(0.999f));
+ NEWTON_ASSERT((normal % normal) > dgFloat32(0.999f));
// contactsOut[0] = point;
contactsOut[0] = normal.Scale(normal % point);
return 1;
@@ -291,13 +291,13 @@ void dgCollisionSphere::DebugCollision(const dgMatrix &matrixPtr,
}
dgFloat32 dgCollisionPoint::GetVolume() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgFloat32(0.0f);
}
void dgCollisionPoint::CalculateInertia(dgVector &inertia,
dgVector &origin) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
// matrix = dgGetIdentityMatrix();
inertia.m_x = dgFloat32(0.0f);
inertia.m_y = dgFloat32(0.0f);
@@ -314,7 +314,7 @@ dgVector dgCollisionPoint::SupportVertex(const dgVector &dir) const {
}
dgVector dgCollisionPoint::SupportVertexSimd(const dgVector &dir) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return dgVector(dgFloat32(0.0f), dgFloat32(0.0f), dgFloat32(0.0f),
dgFloat32(0.0f));
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCollisionUserMesh.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCollisionUserMesh.cpp
index 2cfaea759f5..c17efa9c44d 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCollisionUserMesh.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCollisionUserMesh.cpp
@@ -42,7 +42,7 @@ dgCollisionUserMesh::dgCollisionUserMesh(dgMemoryAllocator *allocator,
dgCollisionUserMesh::dgCollisionUserMesh(dgWorld *const world,
dgDeserialize deserialization, void *const userData) : dgCollisionMesh(world, deserialization, userData) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
m_rtti |= dgCollisionUserMesh_RTTI;
/*
@@ -63,7 +63,7 @@ dgCollisionUserMesh::~dgCollisionUserMesh(void) {
void dgCollisionUserMesh::Serialize(dgSerialize callback,
void *const userData) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
SerializeLow(callback, userData);
dgAABBPolygonSoup::Serialize ((dgSerialize) callback, userData);
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgConnectorConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgConnectorConstraint.cpp
index 036007cc3bf..26ddb3196cb 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgConnectorConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgConnectorConstraint.cpp
@@ -67,13 +67,13 @@
void dgConnectorConstraint::Remove()
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
}
void dgConnectorConstraint::Setup ()
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
dgVector p0 (m_dynamic0->GetBody()->GetMatrix().posit);
dgVector p1 (p0);
@@ -90,7 +90,7 @@
dgUnsigned32 dgConnectorConstraint::JacobianDerivative (dgContraintDescritor& params)
{
- _ASSERTE (0);
+ NEWTON_ASSERT (0);
return 0;
// dgFloat32 k;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgConstraint.cpp
index c6618d1d48b..b70100652ba 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgConstraint.cpp
@@ -51,8 +51,8 @@ bool dgConstraint::IsBilateral() const {
void dgConstraint::InitPointParam(dgPointParam ¶m, dgFloat32 stiffness,
const dgVector &p0Global, const dgVector &p1Global) const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
param.m_stiffness = stiffness;
param.m_r0 = p0Global - m_body0->m_globalCentreOfMass;
@@ -71,7 +71,7 @@ void dgConstraint::InitPointParam(dgPointParam ¶m, dgFloat32 stiffness,
void dgConstraint::InitInfo(dgConstraintInfo *const info) const {
info->m_attachBody_0 = GetBody0();
- _ASSERTE(info->m_attachBody_0);
+ NEWTON_ASSERT(info->m_attachBody_0);
dgWorld *const world = info->m_attachBody_0->GetWorld();
if (info->m_attachBody_0 == world->GetSentinelBody()) {
info->m_attachBody_0 = NULL;
@@ -89,5 +89,5 @@ void dgConstraint::InitInfo(dgConstraintInfo *const info) const {
}
void dgConstraint::GetInfo(dgConstraintInfo *const info) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgConstraint.h b/engines/hpl1/engine/libraries/newton/physics/dgConstraint.h
index ef57b94046c..7f36d3ad05a 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgConstraint.h
+++ b/engines/hpl1/engine/libraries/newton/physics/dgConstraint.h
@@ -246,7 +246,7 @@ protected:
} DG_GCC_VECTOR_ALIGMENT;
inline dgConstraint::dgConstraint() {
- _ASSERTE((((dgUnsigned64) this) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64) this) & 15) == 0);
m_link0 = NULL;
m_link1 = NULL;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgContact.cpp b/engines/hpl1/engine/libraries/newton/physics/dgContact.cpp
index dca98a68e5d..d63101bdec8 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgContact.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgContact.cpp
@@ -33,8 +33,8 @@
//////////////////////////////////////////////////////////////////////
dgContactMaterial::dgContactMaterial() {
- // _ASSERTE ((sizeof (dgContactMaterial) & 15) == 0);
- _ASSERTE((((dgUnsigned64)this) & 15) == 0);
+ // NEWTON_ASSERT ((sizeof (dgContactMaterial) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)this) & 15) == 0);
m_point.m_x = dgFloat32(0.0f);
m_point.m_y = dgFloat32(0.0f);
m_point.m_z = dgFloat32(0.0f);
@@ -59,7 +59,7 @@ dgContactMaterial::dgContactMaterial() {
}
dgContact::dgContact(dgWorld *world) : dgConstraint(), dgList<dgContactMaterial>(world->GetAllocator()) {
- _ASSERTE((((dgUnsigned64)this) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)this) & 15) == 0);
dgActiveContacts &activeContacts = *world;
@@ -89,8 +89,8 @@ void dgContact::GetInfo(dgConstraintInfo *const info) const {
void dgContact::CalculatePointDerivative(dgInt32 index,
dgContraintDescritor &desc, const dgVector &dir,
const dgPointParam ¶m) const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
dgVector r0CrossDir(param.m_r0 * dir);
dgJacobian &jacobian0 = desc.m_jacobian[index].m_jacobian_IM0;
@@ -147,7 +147,7 @@ void dgContact::JacobianContactDerivative(dgContraintDescritor ¶ms,
dgFloat32 penetration = GetMin(contact.m_penetration, dgFloat32(0.5f));
dgFloat32 penetrationStiffness = dgFloat32(50.0f) * contact.m_softness;
dgFloat32 penetrationVeloc = penetration * penetrationStiffness;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(penetrationVeloc - dgFloat32(50.0f) * contact.m_softness * GetMin(contact.m_penetration, dgFloat32(0.5f))) < dgFloat32(1.0e-6f));
if (relVelocErr > REST_RELATIVE_VELOCITY) {
relVelocErr *= (restitution + dgFloat32(1.0f));
@@ -216,7 +216,7 @@ void dgContact::JacobianContactDerivative(dgContraintDescritor ¶ms,
params.m_penetrationStiffness[jacobIndex] = dgFloat32(0.0f);
// if (contact.m_override1Accel) {
if (contact.m_flags & dgContactMaterial::m_override1Accel__) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
params.m_jointAccel[jacobIndex] = contact.m_dir1_Force;
params.m_isMotor[jacobIndex] = 1;
} else {
@@ -306,7 +306,7 @@ void dgContact::JointAccelerationsSimd(
// penetrationVeloc = 0.0f;
// if (params.m_penetration[k] > dgFloat32 (1.0e-2f)) {
// if (vRel > dgFloat32 (0.0f)) {
- // _ASSERTE (penetrationCorrection >= dgFloat32 (0.0f));
+ // NEWTON_ASSERT (penetrationCorrection >= dgFloat32 (0.0f));
// params.m_penetration[k] = GetMax (dgFloat32 (0.0f), params.m_penetration[k] - vRel * params.m_timeStep);
// }
// penetrationVeloc = -(params.m_penetration[k] * params.m_penetrationStiffness[k]);
@@ -372,7 +372,7 @@ void dgContact::JointAccelerations(const dgJointAccelerationDecriptor ¶ms) {
dgFloat32 penetrationCorrection;
if (vRel > dgFloat32(0.0f)) {
penetrationCorrection = vRel * params.m_timeStep;
- _ASSERTE(penetrationCorrection >= dgFloat32(0.0f));
+ NEWTON_ASSERT(penetrationCorrection >= dgFloat32(0.0f));
params.m_penetration[k] = GetMax(dgFloat32(0.0f),
params.m_penetration[k] - penetrationCorrection);
}
@@ -389,7 +389,7 @@ void dgContact::JointAccelerations(const dgJointAccelerationDecriptor ¶ms) {
void dgContact::JointVelocityCorrection(
const dgJointAccelerationDecriptor ¶ms) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
}
dgCollidingPairCollector::dgCollidingPairCollector() {
@@ -458,7 +458,7 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
}
}
} else if (bodyPtr1->m_invMass.m_w != dgFloat32(0.0f)) {
- _ASSERTE(bodyPtr1->m_invMass.m_w != dgFloat32(0.0f));
+ NEWTON_ASSERT(bodyPtr1->m_invMass.m_w != dgFloat32(0.0f));
for (dgBodyMasterListRow::dgListNode *link = world->FindConstraintLink(
bodyPtr1, bodyPtr0);
link;
@@ -474,7 +474,7 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
}
if (contact) {
- _ASSERTE(contact->GetId() == dgContactConstraintId);
+ NEWTON_ASSERT(contact->GetId() == dgContactConstraintId);
contact->m_broadphaseLru = dgInt32(world->m_broadPhaseLru);
}
@@ -487,10 +487,10 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
dgBody *const body0(tmpbody0);
dgBody *const body1(tmpbody1);
- _ASSERTE(body0->GetWorld());
- _ASSERTE(body1->GetWorld());
- _ASSERTE(body0->GetWorld() == world);
- _ASSERTE(body1->GetWorld() == world);
+ NEWTON_ASSERT(body0->GetWorld());
+ NEWTON_ASSERT(body1->GetWorld());
+ NEWTON_ASSERT(body0->GetWorld() == world);
+ NEWTON_ASSERT(body1->GetWorld() == world);
dgContact *contact = NULL;
if (body0->m_invMass.m_w != dgFloat32(0.0f)) {
@@ -508,7 +508,7 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
}
}
} else if (body1->m_invMass.m_w != dgFloat32(0.0f)) {
- _ASSERTE(body1->m_invMass.m_w != dgFloat32(0.0f));
+ NEWTON_ASSERT(body1->m_invMass.m_w != dgFloat32(0.0f));
for (dgBodyMasterListRow::dgListNode *link = world->FindConstraintLink(
body1, body0);
link;
@@ -532,7 +532,7 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
}
}
- _ASSERTE(!contact || contact->GetId() == dgContactConstraintId);
+ NEWTON_ASSERT(!contact || contact->GetId() == dgContactConstraintId);
dgUnsigned32 group0_ID = dgUnsigned32(body0->m_bodyGroupId);
dgUnsigned32 group1_ID = dgUnsigned32(body1->m_bodyGroupId);
@@ -555,9 +555,9 @@ void dgCollidingPairCollector::AddPair(dgBody *const bodyPtr0,
threadIndex);
}
if (processContacts) {
- _ASSERTE(
+ NEWTON_ASSERT(
!body0->m_collision->IsType(dgCollision::dgCollisionNull_RTTI));
- _ASSERTE(
+ NEWTON_ASSERT(
!body1->m_collision->IsType(dgCollision::dgCollisionNull_RTTI));
dgThreadPairCache &pairChache = *m_chacheBuffers[threadIndex];
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgCorkscrewConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgCorkscrewConstraint.cpp
index c16b3263cd0..88f57f1710e 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgCorkscrewConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgCorkscrewConstraint.cpp
@@ -31,7 +31,7 @@
dgCorkscrewConstraint::dgCorkscrewConstraint() : dgBilateralConstraint() {
- _ASSERTE((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
m_maxDOF = 6;
m_constId = dgCorkscrewConstraintId;
@@ -52,7 +52,7 @@ dgCorkscrewConstraint::~dgCorkscrewConstraint() {
dgCorkscrewConstraintArray& array = * world;
constraint = array.GetElement();
- _ASSERTE ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
constraint->Init ();
constraint->m_maxDOF = 6;
constraint->m_constId = dgCorkscrewConstraintId;
@@ -87,8 +87,8 @@ dgFloat32 dgCorkscrewConstraint::GetJointPosit() const {
}
dgFloat32 dgCorkscrewConstraint::GetJointOmega() const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
dgVector dir(m_body0->GetMatrix().RotateVector(m_localMatrix0[0]));
const dgVector &omega0 = m_body0->GetOmega();
const dgVector &omega1 = m_body1->GetOmega();
@@ -101,8 +101,8 @@ dgFloat32 dgCorkscrewConstraint::GetJointOmega() const {
}
dgFloat32 dgCorkscrewConstraint::GetJointVeloc() const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
dgVector dir(m_body0->GetMatrix().RotateVector(m_localMatrix0[0]));
const dgVector &veloc0 = m_body0->GetVelocity();
const dgVector &veloc1 = m_body1->GetVelocity();
@@ -162,7 +162,7 @@ dgFloat32 dgCorkscrewConstraint::CalculateStopAccel(dgFloat32 distance,
speed = dgFloat32(0.0f);
}
penetrationErr = distance - m_posit;
- _ASSERTE(penetrationErr >= dgFloat32(0.0f));
+ NEWTON_ASSERT(penetrationErr >= dgFloat32(0.0f));
accel = dgFloat32(100.0f) * penetrationErr - speed * dgFloat32(1.01f) / param->m_timestep;
}
return accel;
@@ -189,11 +189,11 @@ dgUnsigned32 dgCorkscrewConstraint::JacobianDerivative(
m_posit = (matrix0.m_posit - matrix1.m_posit) % matrix0.m_front;
matrix1.m_posit += matrix1.m_front.Scale(m_posit);
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (matrix0.m_front % matrix0.m_front)) < dgFloat32(1.0e-5f));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (matrix0.m_up % matrix0.m_up)) < dgFloat32(1.0e-5f));
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(dgFloat32(1.0f) - (matrix0.m_right % matrix0.m_right)) < dgFloat32(1.0e-5f));
const dgVector &dir1 = matrix0.m_up;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgHingeConstraint.cpp b/engines/hpl1/engine/libraries/newton/physics/dgHingeConstraint.cpp
index a0d5602c8e5..4750f05f062 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgHingeConstraint.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgHingeConstraint.cpp
@@ -30,7 +30,7 @@
//////////////////////////////////////////////////////////////////////
dgHingeConstraint::dgHingeConstraint() : dgBilateralConstraint() {
- _ASSERTE((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT((((dgUnsigned64)&m_localMatrix0) & 15) == 0);
// constraint->Init ();
m_maxDOF = 6;
@@ -51,7 +51,7 @@ dgHingeConstraint::~dgHingeConstraint() {
dgHingeConstraintArray& array = *world;
constraint = array.GetElement();
- _ASSERTE ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
+ NEWTON_ASSERT ((((dgUnsigned64) &constraint->m_localMatrix0) & 15) == 0);
constraint->Init ();
constraint->m_maxDOF = 6;
constraint->m_constId = dgHingeConstraintId;
@@ -80,8 +80,8 @@ dgFloat32 dgHingeConstraint::GetJointAngle() const {
}
dgFloat32 dgHingeConstraint::GetJointOmega() const {
- _ASSERTE(m_body0);
- _ASSERTE(m_body1);
+ NEWTON_ASSERT(m_body0);
+ NEWTON_ASSERT(m_body1);
dgVector dir(m_body0->GetMatrix().RotateVector(m_localMatrix0[0]));
const dgVector &omega0 = m_body0->GetOmega();
const dgVector &omega1 = m_body1->GetOmega();
@@ -131,10 +131,10 @@ dgUnsigned32 dgHingeConstraint::JacobianDerivative(dgContraintDescritor ¶ms)
m_angle = -angle.m_x;
- _ASSERTE(
+ NEWTON_ASSERT(
dgAbsf(1.0f - (matrix0.m_front % matrix0.m_front)) < dgFloat32(1.0e-5f));
- _ASSERTE(dgAbsf(1.0f - (matrix0.m_up % matrix0.m_up)) < dgFloat32(1.0e-5f));
- _ASSERTE(
+ NEWTON_ASSERT(dgAbsf(1.0f - (matrix0.m_up % matrix0.m_up)) < dgFloat32(1.0e-5f));
+ NEWTON_ASSERT(
dgAbsf(1.0f - (matrix0.m_right % matrix0.m_right)) < dgFloat32(1.0e-5f));
const dgVector &dir0 = matrix0.m_front;
@@ -146,7 +146,7 @@ dgUnsigned32 dgHingeConstraint::JacobianDerivative(dgContraintDescritor ¶ms)
dgVector q0(p0 + matrix0.m_front.Scale(MIN_JOINT_PIN_LENGTH));
dgVector q1(p1 + matrix1.m_front.Scale(MIN_JOINT_PIN_LENGTH));
- // _ASSERTE (((p1 - p0) % (p1 - p0)) < 1.0e-2f);
+ // NEWTON_ASSERT (((p1 - p0) % (p1 - p0)) < 1.0e-2f);
dgPointParam pointDataP;
dgPointParam pointDataQ;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect.cpp
index 8ef5473777e..baab1af4856 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect.cpp
@@ -299,7 +299,7 @@ void dgMeshEffect::Triangulate() {
dgPolyhedra leftOversOut(GetAllocator());
polygon.Triangulate(&m_attib[0].m_vertex.m_x, sizeof(dgVertexAtribute),
&leftOversOut);
- _ASSERTE(leftOversOut.GetCount() == 0);
+ NEWTON_ASSERT(leftOversOut.GetCount() == 0);
RemoveAll();
SetLRU(0);
@@ -368,7 +368,7 @@ void dgMeshEffect::ConvertToPolygons() {
dgPolyhedra leftOversOut(GetAllocator());
polygon.ConvexPartition(&m_attib[0].m_vertex.m_x, sizeof(dgVertexAtribute),
&leftOversOut);
- _ASSERTE(leftOversOut.GetCount() == 0);
+ NEWTON_ASSERT(leftOversOut.GetCount() == 0);
RemoveAll();
SetLRU(0);
@@ -558,7 +558,7 @@ dgInt32 dgMeshEffect::EnumerateAttributeArray(dgVertexAtribute *const attib) {
dgPolyhedra::Iterator iter(*this);
for (iter.Begin(); iter; iter++) {
dgEdge *const edge = &(*iter);
- _ASSERTE(index < GetCount());
+ NEWTON_ASSERT(index < GetCount());
if (edge->m_incidentFace > 0) {
attib[index] = m_attib[dgInt32(edge->m_userData)];
edge->m_userData = dgUnsigned64(index);
@@ -586,8 +586,8 @@ void dgMeshEffect::ApplyAttributeArray(dgVertexAtribute *const attib, dgInt32 ma
dgEdge *const edge = &(*iter);
if (edge->m_incidentFace > 0) {
dgInt32 index = indexMap[dgInt32(edge->m_userData)];
- _ASSERTE(index >= 0);
- _ASSERTE(index < m_atribCount);
+ NEWTON_ASSERT(index >= 0);
+ NEWTON_ASSERT(index < m_atribCount);
edge->m_userData = dgUnsigned64(index);
}
}
@@ -1148,7 +1148,7 @@ void dgMeshEffect::AddPolygon(dgInt32 count, const dgFloat64 *const vertexList,
if (count > 3) {
dgPolyhedra polygon(GetAllocator());
dgInt32 indexList[256];
- _ASSERTE(count < dgInt32(sizeof(indexList) / sizeof(indexList[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(indexList) / sizeof(indexList[0])));
for (dgInt32 i = 0; i < count; i++) {
indexList[i] = i;
}
@@ -1178,7 +1178,7 @@ void dgMeshEffect::AddPolygon(dgInt32 count, const dgFloat64 *const vertexList,
// dgBigVector e2_ (p2_ - p0_);
// dgBigVector n_ (e1_ * e2_);
// dgFloat64 mag2_ = n_ % n_;
- // _ASSERTE (mag2_ > dgFloat32 (DG_MESH_EFFECT_PRECISION_SCALE_INV * DG_MESH_EFFECT_PRECISION_SCALE_INV));
+ // NEWTON_ASSERT (mag2_ > dgFloat32 (DG_MESH_EFFECT_PRECISION_SCALE_INV * DG_MESH_EFFECT_PRECISION_SCALE_INV));
// #endif
AddPoint(vertexList + i0 * stride, material);
@@ -1193,7 +1193,7 @@ void dgMeshEffect::AddPolygon(dgInt32 count, const dgFloat64 *const vertexList,
dgBigVector e2(p2 - p0);
dgBigVector n(e1 * e2);
dgFloat64 mag3 = n % n;
- _ASSERTE(mag3 > dgFloat64(DG_MESH_EFFECT_PRECISION_SCALE_INV * DG_MESH_EFFECT_PRECISION_SCALE_INV));
+ NEWTON_ASSERT(mag3 > dgFloat64(DG_MESH_EFFECT_PRECISION_SCALE_INV * DG_MESH_EFFECT_PRECISION_SCALE_INV));
#endif
}
}
@@ -1222,7 +1222,7 @@ void dgMeshEffect::AddPolygon(dgInt32 count, const dgFloat64 *const vertexList,
void dgMeshEffect::AddPolygon(dgInt32 count, const dgFloat32 *const vertexList,
dgInt32 strideIndBytes, dgInt32 material) {
dgVertexAtribute points[256];
- _ASSERTE(count < dgInt32(sizeof(points) / sizeof(points[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(points) / sizeof(points[0])));
dgInt32 stride = strideIndBytes / sizeof(dgFloat32);
for (dgInt32 i = 0; i < count; i++) {
@@ -1257,8 +1257,8 @@ void dgMeshEffect::EndPolygon(dgFloat64 tol) {
dgBigVector e2(p2 - p0);
dgBigVector n(e1 * e2);
dgFloat64 mag2 = n % n;
- // _ASSERTE (mag2 > DG_MESH_EFFECT_TRIANGLE_MIN_AREA);
- _ASSERTE(mag2 > dgFloat32(0.0f));
+ // NEWTON_ASSERT (mag2 > DG_MESH_EFFECT_TRIANGLE_MIN_AREA);
+ NEWTON_ASSERT(mag2 > dgFloat32(0.0f));
}
#endif
@@ -1288,7 +1288,7 @@ void dgMeshEffect::EndPolygon(dgFloat64 tol) {
userdata[2] = attrIndexMap[i * 3 + 2];
dgEdge *const edge = AddFace(3, index, userdata);
if (!edge) {
- _ASSERTE((m_pointCount + 3) <= m_maxPointCount);
+ NEWTON_ASSERT((m_pointCount + 3) <= m_maxPointCount);
m_points[m_pointCount + 0] = m_points[index[0]];
m_points[m_pointCount + 1] = m_points[index[1]];
@@ -1302,7 +1302,7 @@ void dgMeshEffect::EndPolygon(dgFloat64 tol) {
#ifdef _DEBUG
dgEdge *test = AddFace(3, index, userdata);
- _ASSERTE(test);
+ NEWTON_ASSERT(test);
#else
AddFace(3, index, userdata);
#endif
@@ -1324,9 +1324,9 @@ void dgMeshEffect::EndPolygon(dgFloat64 tol) {
dgBigVector e1(p1 - p0);
dgBigVector e2(p2 - p0);
dgBigVector n(e1 * e2);
- // _ASSERTE (mag2 > DG_MESH_EFFECT_TRIANGLE_MIN_AREA);
+ // NEWTON_ASSERT (mag2 > DG_MESH_EFFECT_TRIANGLE_MIN_AREA);
dgFloat64 mag2 = n % n;
- _ASSERTE(mag2 > dgFloat32(0.0f));
+ NEWTON_ASSERT(mag2 > dgFloat32(0.0f));
}
}
#endif
@@ -1405,7 +1405,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
dgInt32 index[256];
dgInt64 userdata[256];
dgInt32 count = faceIndexCount[j];
- _ASSERTE(count < dgInt32(sizeof(index) / sizeof(index[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(index) / sizeof(index[0])));
for (dgInt32 i = 0; i < count; i++) {
index[i] = vertexIndex[totalIndexCount + i];
// dgTrace (("%d ", index[i]));
@@ -1466,7 +1466,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
dgPolyhedra::dgPairKey keyV(parentVertex, 0);
dgTreeNode *const parentNode = FindGreaterEqual(keyV.GetVal());
- _ASSERTE(parentNode);
+ NEWTON_ASSERT(parentNode);
dgEdge *const alliasEdge = &aliasNode->GetInfo();
dgEdge *const parentEdge = &parentNode->GetInfo();
@@ -1511,7 +1511,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
//conflictEdgeList[confliEdgeCount] = conflictEdge.m_edge;
dgVector n (cleanFacesFilter.FaceNormal(conflictEdge.m_edge, &m_points[0].m_x, sizeof (dgBigVector)));
n = matrix.RotateVector(n);
- _ASSERTE (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
+ NEWTON_ASSERT (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
angle[confliEdgeCount] = dgAtan2 (n.m_y, n.m_z);
if (angle[confliEdgeCount] < dgFloat32 (0.0f)) {
angle[confliEdgeCount] += dgFloat32 (2.0f * 3.141593f);
@@ -1523,7 +1523,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
//confliEdgeList[confliEdgeCount] = conflictEdge.m_edge->m_twin;
dgVector n (cleanFacesFilter.FaceNormal(conflictEdge.m_edge->m_twin, &m_points[0].m_x, sizeof (dgBigVector)));
n = matrix.RotateVector(n);
- _ASSERTE (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
+ NEWTON_ASSERT (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
angle[confliEdgeCount] = dgAtan2 (n.m_y, n.m_z);
if (angle[confliEdgeCount] < dgFloat32 (0.0f)) {
angle[confliEdgeCount] += dgFloat32 (2.0f * 3.141593f);
@@ -1534,7 +1534,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
if (twin) {
dgVector n (cleanFacesFilter.FaceNormal(twin, &m_points[0].m_x, sizeof (dgBigVector)));
n = matrix.RotateVector(n);
- _ASSERTE (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
+ NEWTON_ASSERT (dgAbsf (n.m_x) < dgFloat32 (1.0e-5f));
angle[confliEdgeCount] = dgAtan2 (n.m_y, n.m_z);
if (angle[confliEdgeCount] < dgFloat32 (0.0f)) {
angle[confliEdgeCount] += dgFloat32 (2.0f * 3.141593f);
@@ -1580,7 +1580,7 @@ void dgMeshEffect::BuildFromVertexListIndexList(
dgInt64 userdata[256];
int indexCount = faceIndexCount[j];
- _ASSERTE(indexCount < dgInt32 (sizeof (index) / sizeof (index[0])));
+ NEWTON_ASSERT(indexCount < dgInt32 (sizeof (index) / sizeof (index[0])));
if (faceMark[j])
{
@@ -1700,7 +1700,7 @@ void dgMeshEffect::GetFaces(dgInt32 *const facesIndex, dgInt32 *const materials,
}
void *dgMeshEffect::GetFirstVertex() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
/*
@@ -1788,7 +1788,7 @@ dgInt32 dgMeshEffect::GetVertexIndexFromPoint(void *point) const {
dgEdge *dgMeshEffect::ConectVertex(dgEdge *const e0, dgEdge *const e1) {
dgEdge *const edge = AddHalfEdge(e1->m_incidentVertex, e0->m_incidentVertex);
dgEdge *const twin = AddHalfEdge(e0->m_incidentVertex, e1->m_incidentVertex);
- _ASSERTE((edge && twin) || !(edge || twin));
+ NEWTON_ASSERT((edge && twin) || !(edge || twin));
if (edge) {
edge->m_twin = twin;
twin->m_twin = edge;
@@ -2348,17 +2348,17 @@ dgCollision *dgMeshEffect::CreateConvexCollision(dgFloat64 tolerance,
alpha5 = p10 % p_p2;
alpha6 = p20 % p_p2;
- _ASSERTE (!((alpha1 <= dgFloat32 (0.0f)) && (alpha2 <= dgFloat32 (0.0f))));
- _ASSERTE (!((alpha6 >= dgFloat32 (0.0f)) && (alpha5 <= alpha6)));
- _ASSERTE (!((alpha3 >= dgFloat32 (0.0f)) && (alpha4 <= alpha3)));
+ NEWTON_ASSERT (!((alpha1 <= dgFloat32 (0.0f)) && (alpha2 <= dgFloat32 (0.0f))));
+ NEWTON_ASSERT (!((alpha6 >= dgFloat32 (0.0f)) && (alpha5 <= alpha6)));
+ NEWTON_ASSERT (!((alpha3 >= dgFloat32 (0.0f)) && (alpha4 <= alpha3)));
vc = alpha1 * alpha4 - alpha3 * alpha2;
vb = alpha5 * alpha2 - alpha1 * alpha6;
va = alpha3 * alpha6 - alpha5 * alpha4;
- _ASSERTE (!((vc <= dgFloat32 (0.0f)) && (alpha1 >= dgFloat32 (0.0f)) && (alpha3 <= dgFloat32 (0.0f))));
- _ASSERTE (!((vb <= dgFloat32 (0.0f)) && (alpha2 >= dgFloat32 (0.0f)) && (alpha6 <= dgFloat32 (0.0f))));
- _ASSERTE (!((va <= dgFloat32 (0.0f)) && ((alpha4 - alpha3) >= dgFloat32 (0.0f)) && ((alpha5 - alpha6) >= dgFloat32 (0.0f))));
+ NEWTON_ASSERT (!((vc <= dgFloat32 (0.0f)) && (alpha1 >= dgFloat32 (0.0f)) && (alpha3 <= dgFloat32 (0.0f))));
+ NEWTON_ASSERT (!((vb <= dgFloat32 (0.0f)) && (alpha2 >= dgFloat32 (0.0f)) && (alpha6 <= dgFloat32 (0.0f))));
+ NEWTON_ASSERT (!((va <= dgFloat32 (0.0f)) && ((alpha4 - alpha3) >= dgFloat32 (0.0f)) && ((alpha5 - alpha6) >= dgFloat32 (0.0f))));
den = float(dgFloat32 (1.0f)) / (va + vb + vc);
@@ -2389,8 +2389,8 @@ dgCollision *dgMeshEffect::CreateConvexCollision(dgFloat64 tolerance,
attribute.m_normal.m_z = normal.m_z;
attribute.m_u = attr0.m_u * alpha0 + attr1.m_u * alpha1 + attr2.m_u * alpha2;
attribute.m_v = attr0.m_v * alpha0 + attr1.m_v * alpha1 + attr2.m_v * alpha2;
- _ASSERTE (attr0.m_material == attr1.m_material);
- _ASSERTE (attr0.m_material == attr2.m_material);
+ NEWTON_ASSERT (attr0.m_material == attr1.m_material);
+ NEWTON_ASSERT (attr0.m_material == attr2.m_material);
AddVertex (&attribute.m_vertex.m_x, attr0.m_material);
vertexIndex = m_pointCount - 1;
@@ -2560,8 +2560,8 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateEdge(dgEdge *const edge,
dgVertexAtribute attrEdge;
dgFloat64 t1 = param;
dgFloat64 t0 = dgFloat64(1.0f) - t1;
- _ASSERTE(t1 >= dgFloat64(0.0f));
- _ASSERTE(t1 <= dgFloat64(1.0f));
+ NEWTON_ASSERT(t1 >= dgFloat64(0.0f));
+ NEWTON_ASSERT(t1 <= dgFloat64(1.0f));
const dgVertexAtribute &attrEdge0 = m_attib[edge->m_userData];
const dgVertexAtribute &attrEdge1 = m_attib[edge->m_next->m_userData];
@@ -2582,7 +2582,7 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateEdge(dgEdge *const edge,
}
bool dgMeshEffect::Sanity() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
/*
Iterator iter (*this);
@@ -2672,7 +2672,7 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateVertex(
dgFloat64 mag1 = p10 % p10;
dgFloat64 mag2 = p20 % p20;
dgFloat64 collinear = dot * dot - mag2 * mag1;
- _ASSERTE(fabs(collinear) > dgFloat64(1.0e-8f));
+ NEWTON_ASSERT(fabs(collinear) > dgFloat64(1.0e-8f));
#endif
dgBigVector p_p0(point - q0);
@@ -2715,9 +2715,9 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateVertex(
attr0.m_vertex.m_x * alpha0 + attr1.m_vertex.m_x * alpha1 + attr2.m_vertex.m_x * alpha2,
attr0.m_vertex.m_y * alpha0 + attr1.m_vertex.m_y * alpha1 + attr2.m_vertex.m_y * alpha2,
attr0.m_vertex.m_z * alpha0 + attr1.m_vertex.m_z * alpha1 + attr2.m_vertex.m_z * alpha2, dgFloat32(0.0f));
- _ASSERTE(fabs(testPoint.m_x - point.m_x) < dgFloat32(1.0e-2f));
- _ASSERTE(fabs(testPoint.m_y - point.m_y) < dgFloat32(1.0e-2f));
- _ASSERTE(fabs(testPoint.m_z - point.m_z) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(fabs(testPoint.m_x - point.m_x) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(fabs(testPoint.m_y - point.m_y) < dgFloat32(1.0e-2f));
+ NEWTON_ASSERT(fabs(testPoint.m_z - point.m_z) < dgFloat32(1.0e-2f));
#endif
attribute.m_vertex.m_x = point.m_x;
@@ -2733,8 +2733,8 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateVertex(
attribute.m_v1 = attr0.m_v1 * alpha0 + attr1.m_v1 * alpha1 + attr2.m_v1 * alpha2;
attribute.m_material = attr0.m_material;
- _ASSERTE(attr0.m_material == attr1.m_material);
- _ASSERTE(attr0.m_material == attr2.m_material);
+ NEWTON_ASSERT(attr0.m_material == attr1.m_material);
+ NEWTON_ASSERT(attr0.m_material == attr2.m_material);
return attribute;
}
@@ -2746,7 +2746,7 @@ dgMeshEffect::dgVertexAtribute dgMeshEffect::InterpolateVertex(
tol *= dgFloat64(2.0f);
}
// this should never happens
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return attribute;
}
@@ -2764,7 +2764,7 @@ void dgMeshEffect::MergeFaces(const dgMeshEffect *const source) {
ptr->m_mark = mark;
face[count] = source->m_attib[ptr->m_userData];
count++;
- _ASSERTE(count < dgInt32(sizeof(face) / sizeof(face[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(face) / sizeof(face[0])));
ptr = ptr->m_next;
} while (ptr != edge);
AddPolygon(count, &face[0].m_vertex.m_x, sizeof(dgVertexAtribute),
@@ -2790,7 +2790,7 @@ void dgMeshEffect::ReverseMergeFaces(dgMeshEffect *const source) {
face[count].m_normal_y *= dgFloat32(-1.0f);
face[count].m_normal_z *= dgFloat32(-1.0f);
count++;
- _ASSERTE(count < dgInt32(sizeof(face) / sizeof(face[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(face) / sizeof(face[0])));
ptr = ptr->m_prev;
} while (ptr != edge);
AddPolygon(count, &face[0].m_vertex.m_x, sizeof(dgVertexAtribute),
@@ -2952,7 +2952,7 @@ dgMeshEffect *dgMeshEffect::Difference(const dgMatrix &matrix,
result->ReverseMergeFaces(leftMeshClipper);
}
if (clipperCoplanar && sourceCoplanar) {
- _ASSERTE(sourceCoplanar);
+ NEWTON_ASSERT(sourceCoplanar);
clipperCoplanar->FilterCoplanarFaces(sourceCoplanar, dgFloat32(1.0f));
result->ReverseMergeFaces(clipperCoplanar);
}
@@ -2972,7 +2972,7 @@ dgMeshEffect *dgMeshEffect::Difference(const dgMatrix &matrix,
void dgMeshEffect::ClipMesh(const dgMatrix &matrix,
const dgMeshEffect *const clipMesh, dgMeshEffect **const back,
dgMeshEffect **const front) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
dgMeshEffect clipper (*clipMesh);
clipper.TransformMesh (matrix);
@@ -3096,7 +3096,7 @@ dgMeshEffectSolidTree *dgMeshEffect::CreateSolidTree() const {
}
}
}
- _ASSERTE(tree);
+ NEWTON_ASSERT(tree);
return tree;
}
@@ -3108,14 +3108,14 @@ void dgMeshEffect::ClipMesh(const dgMeshEffect *const clipMesh,
dgMeshEffect **const left, dgMeshEffect **const right,
dgMeshEffect **const coplanar) const {
const dgMeshEffectSolidTree *const clipper = clipMesh->CreateSolidTree();
- _ASSERTE(clipper);
+ NEWTON_ASSERT(clipper);
ClipMesh(clipper, left, right, coplanar);
delete clipper;
}
bool dgMeshEffect::CheckIntersection(
const dgMeshEffectSolidTree *const solidTree, dgFloat64 scale) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
/*
@@ -3199,13 +3199,13 @@ bool dgMeshEffect::CheckIntersection(
rootFace->Release();
if (frontFace) {
- _ASSERTE (frontFace->CheckConvex(this, face, points));
+ NEWTON_ASSERT (frontFace->CheckConvex(this, face, points));
if (root->m_front) {
stackPool[stack] = root->m_front;
faceOnStack[stack] = frontFace;
stack ++;
- _ASSERTE (stack < sizeof (stackPool) / sizeof (stackPool[0]));
+ NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
} else {
frontFace->Release();
frontCount ++;
@@ -3213,12 +3213,12 @@ bool dgMeshEffect::CheckIntersection(
}
if (backFace) {
- _ASSERTE (backFace->CheckConvex(this, face, points));
+ NEWTON_ASSERT (backFace->CheckConvex(this, face, points));
if (root->m_back) {
stackPool[stack] = root->m_back;
faceOnStack[stack] = backFace;
stack ++;
- _ASSERTE (stack < sizeof (stackPool) / sizeof (stackPool[0]));
+ NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
} else {
backFace->Release();
backCount ++;
@@ -3240,19 +3240,19 @@ bool dgMeshEffect::CheckIntersection(
void dgMeshEffect::PlaneClipMesh(const dgMeshEffect *planeMesh,
dgMeshEffect **back, dgMeshEffect **front) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
dgEdge* face;
dgMeshEffect* backMesh;
dgMeshEffect* frontMesh;
- _ASSERTE (planeMesh->m_isFlagFace);
+ NEWTON_ASSERT (planeMesh->m_isFlagFace);
face = &planeMesh->GetRoot()->GetInfo();
if (face->m_incidentFace < 0) {
face = face->m_twin;
}
- _ASSERTE (face->m_incidentFace > 0);
+ NEWTON_ASSERT (face->m_incidentFace > 0);
dgVector normal (planeMesh->FaceNormal (face, &planeMesh->m_points[0][0], sizeof (dgVector)));
normal = normal.Scale (dgRsqrt (normal % normal));
const dgVector& point = planeMesh->m_points[face->m_incidentVertex];
@@ -3261,14 +3261,14 @@ void dgMeshEffect::PlaneClipMesh(const dgMeshEffect *planeMesh,
dgMeshEffect tmp (*this);
tmp.PlaneClipMesh (plane, left, right);
- // _ASSERTE (tmp.CheckSingleMesh());
+ // NEWTON_ASSERT (tmp.CheckSingleMesh());
backMesh = *left;
frontMesh = *right;
if (backMesh && frontMesh) {
- _ASSERTE (backMesh->GetCount());
- _ASSERTE (frontMesh->GetCount());
+ NEWTON_ASSERT (backMesh->GetCount());
+ NEWTON_ASSERT (frontMesh->GetCount());
if (!(backMesh->PlaneApplyCap (planeMesh, plane) && frontMesh->PlaneApplyCap (planeMesh, plane.Scale (dgFloat32 (-1.0f))))) {
backMesh->Release();
frontMesh->Release();
@@ -3277,8 +3277,8 @@ void dgMeshEffect::PlaneClipMesh(const dgMeshEffect *planeMesh,
} else {
backMesh->Triangulate ();
frontMesh->Triangulate ();
- // _ASSERTE (frontMesh->CheckSingleMesh());
- // _ASSERTE (backMesh->CheckSingleMesh());
+ // NEWTON_ASSERT (frontMesh->CheckSingleMesh());
+ // NEWTON_ASSERT (backMesh->CheckSingleMesh());
}
}
*/
@@ -3380,16 +3380,16 @@ void dgMeshEffect::PlaneClipMesh(const dgMatrix &planeMatrix,
do {
side |= vertexSide[ptr->m_incidentVertex];
if (vertexSide[ptr->m_incidentVertex] == 0) {
- _ASSERTE(side != -1);
- _ASSERTE(side <= 0);
+ NEWTON_ASSERT(side != -1);
+ NEWTON_ASSERT(side <= 0);
if (side < 0) {
if (ptr->m_next != face) {
dgEdge *const back = mesh.AddHalfEdge(ptr->m_incidentVertex,
face->m_incidentVertex);
dgEdge *const front = mesh.AddHalfEdge(face->m_incidentVertex,
ptr->m_incidentVertex);
- _ASSERTE(back);
- _ASSERTE(front);
+ NEWTON_ASSERT(back);
+ NEWTON_ASSERT(front);
back->m_mark = mark;
front->m_mark = mark;
@@ -3416,9 +3416,9 @@ void dgMeshEffect::PlaneClipMesh(const dgMatrix &planeMatrix,
face->m_prev = back;
} else {
// dgEdge* const back = ptr;
- _ASSERTE(ptr);
+ NEWTON_ASSERT(ptr);
dgEdge *const front = ptr->m_twin;
- _ASSERTE(front);
+ NEWTON_ASSERT(front);
dgEdge *ptr1 = front;
do {
ptr1->m_mark = mark;
@@ -3477,8 +3477,8 @@ void dgMeshEffect::PlaneClipMesh(const dgMatrix &planeMatrix,
}
if (backMesh && frontMesh) {
- _ASSERTE(backMesh->GetCount());
- _ASSERTE(frontMesh->GetCount());
+ NEWTON_ASSERT(backMesh->GetCount());
+ NEWTON_ASSERT(frontMesh->GetCount());
dgBigVector min;
dgBigVector max;
@@ -3504,7 +3504,7 @@ void dgMeshEffect::PlaneClipMesh(const dgMatrix &planeMatrix,
}
bool dgMeshEffect::CheckSingleMesh() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return false;
/*
@@ -3521,7 +3521,7 @@ bool dgMeshEffect::CheckSingleMesh() const {
dgVector p (m_attib[vertex->m_userData].m_vertex.m_x, m_attib[vertex->m_userData].m_vertex.m_y, m_attib[vertex->m_userData].m_vertex.m_z, dgFloat32 (0.0f));
dgVector err (m_points[vertex->m_incidentVertex] - p);
err2 = err % err;
- _ASSERTE (err2 < dgFloat32 (1.0e-10f));
+ NEWTON_ASSERT (err2 < dgFloat32 (1.0e-10f));
}
}
@@ -3540,7 +3540,7 @@ dgInt32 dgMeshEffect::PlaneApplyCap(const dgMeshEffect *planeMesh,
if (plane->m_incidentFace < 0) {
plane = plane->m_twin;
}
- _ASSERTE(plane->m_incidentFace > 0);
+ NEWTON_ASSERT(plane->m_incidentFace > 0);
dgInt32 ret = 0;
dgInt32 mark = IncLRU();
@@ -3579,7 +3579,7 @@ dgInt32 dgMeshEffect::PlaneApplyCap(const dgMeshEffect *planeMesh,
dgFloat64 epsilon = dgFloat64(1.0e-6f) * mag00 * mag11;
dgFloat64 err = mag01 * mag01 - mag00 * mag11;
if (fabs(err) < epsilon) {
- _ASSERTE(ptr->m_twin->m_incidentFace >= 0);
+ NEWTON_ASSERT(ptr->m_twin->m_incidentFace >= 0);
dgBigVector normal0(
FaceNormal(ptr->m_twin, &m_points[0].m_x,
@@ -3699,7 +3699,7 @@ bool dgMeshEffect::HasOpenEdges() const {
}
dgFloat64 dgMeshEffect::CalculateVolume() const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return 0;
/*
@@ -3796,7 +3796,7 @@ dgMeshEffect *dgMeshEffect::GetNextLayer(dgInt32 mark) const {
faceIndex[count] = ptr->m_incidentVertex;
faceDataIndex[count] = ptr->m_userData;
count++;
- _ASSERTE(count < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
+ NEWTON_ASSERT(count < dgInt32(sizeof(faceIndex) / sizeof(faceIndex[0])));
ptr = ptr->m_next;
} while (ptr != edgeI);
polyhedra.AddFace(count, &faceIndex[0], &faceDataIndex[0]);
@@ -3868,7 +3868,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
dgMeshTreeCSGFace *const treeFace = faceOnStack[stack];
const dgMeshEffectSolidTree *const root = stackPool[stack];
- _ASSERTE(root->m_planeType == dgMeshEffectSolidTree::m_divider);
+ NEWTON_ASSERT(root->m_planeType == dgMeshEffectSolidTree::m_divider);
dgMeshTreeCSGFace *backFace;
dgMeshTreeCSGFace *frontFace;
@@ -3876,26 +3876,26 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
treeFace->Release();
if (!(frontFace || backFace)) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
hasCoplanar = true;
if (!((root->m_front->m_planeType == dgMeshEffectSolidTree::m_divider) || (root->m_back->m_planeType == dgMeshEffectSolidTree::m_divider))) {
- _ASSERTE (face->DetermineSide(clipper) != 0);
+ NEWTON_ASSERT (face->DetermineSide(clipper) != 0);
faceList.Append(face);
} else {
- //_ASSERTE (!(root->m_front && root->m_back));
+ //NEWTON_ASSERT (!(root->m_front && root->m_back));
if (root->m_front->m_planeType == dgMeshEffectSolidTree::m_divider) {
stackPool[stack] = root->m_front;
faceOnStack[stack] = face;
stack ++;
- _ASSERTE (stack < sizeof (stackPool) / sizeof (stackPool[0]));
+ NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
} else {
//if (root->m_back) {
- _ASSERTE (root->m_back->m_planeType == dgMeshEffectSolidTree::m_divider);
+ NEWTON_ASSERT (root->m_back->m_planeType == dgMeshEffectSolidTree::m_divider);
stackPool[stack] = root->m_back;
faceOnStack[stack] = face;
stack ++;
- _ASSERTE (stack < sizeof (stackPool) / sizeof (stackPool[0]));
+ NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
}
}
*/
@@ -3905,7 +3905,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
stackPool[stack] = root->m_front;
faceOnStack[stack] = frontFace;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(stackPool[0])));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(stackPool[0])));
} else {
// if (xxx == 485){
@@ -3914,7 +3914,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
frontCount++;
frontFace->m_side = dgMeshEffectSolidTree::m_empty;
- _ASSERTE(
+ NEWTON_ASSERT(
clipper->GetFaceSide(frontFace) == dgMeshEffectSolidTree::m_empty);
faceList.Append(frontFace);
}
@@ -3925,7 +3925,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
stackPool[stack] = root->m_back;
faceOnStack[stack] = backFace;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(stackPool) / sizeof(stackPool[0])));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(stackPool) / sizeof(stackPool[0])));
} else {
// if (xxx == 485){
@@ -3934,7 +3934,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
backCount++;
backFace->m_side = dgMeshEffectSolidTree::m_solid;
- _ASSERTE(
+ NEWTON_ASSERT(
clipper->GetFaceSide(backFace) == dgMeshEffectSolidTree::m_solid);
faceList.Append(backFace);
}
@@ -3942,7 +3942,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
}
}
- _ASSERTE(faceList.GetCount());
+ NEWTON_ASSERT(faceList.GetCount());
if (!hasCoplanar && ((backCount == 0) || (frontCount == 0))) {
dgInt32 count = 0;
dgMeshEffect::dgVertexAtribute facePoints[256];
@@ -3963,7 +3963,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
faceList.GetFirst();
node1; node1 = node1->GetNext()) {
dgMeshTreeCSGFace *const face = node1->GetInfo();
- _ASSERTE(
+ NEWTON_ASSERT(
clipper->GetFaceSide(face) == dgMeshEffectSolidTree::m_empty);
}
#endif
@@ -3975,7 +3975,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
faceList.GetFirst();
node1; node1 = node1->GetNext()) {
dgMeshTreeCSGFace *const face = node1->GetInfo();
- _ASSERTE(
+ NEWTON_ASSERT(
clipper->GetFaceSide(face) == dgMeshEffectSolidTree::m_solid);
}
#endif
@@ -4018,7 +4018,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
switch (treFace->m_side) {
case dgMeshEffectSolidTree::m_divider: {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
meshCoplanar->AddPolygon(count, &facePoints[0].m_vertex.m_x,
sizeof(dgVertexAtribute), dgFastInt(facePoints[0].m_material));
break;
@@ -4063,7 +4063,7 @@ void dgMeshEffect::ClipMesh(const dgMeshEffectSolidTree *const clipper,
*left = backMesh;
frontMesh->Release();
} else {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
*right = NULL;
*left = NULL;
backMesh->Release();
@@ -4093,7 +4093,7 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
dgBigVector dp(p1 - p0);
dgFloat64 err2(dp % dp);
if (err2 < dgFloat64(1.0e-16f)) {
- // _ASSERTE (0);
+ // NEWTON_ASSERT (0);
}
}
}
@@ -4128,7 +4128,7 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
ptr = ptr->m_next;
} while (ptr != face);
- _ASSERTE(lengh2 > dgFloat32(0.0f));
+ NEWTON_ASSERT(lengh2 > dgFloat32(0.0f));
dgEdge *lastEdge = NULL;
dgEdge *firstEdge = NULL;
@@ -4152,8 +4152,8 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
ptr = ptr->m_next;
} while (ptr != face);
- _ASSERTE(firstEdge);
- _ASSERTE(lastEdge);
+ NEWTON_ASSERT(firstEdge);
+ NEWTON_ASSERT(lastEdge);
bool isTJoint = true;
dgBigVector point0(m_points[firstEdge->m_incidentVertex]);
@@ -4188,19 +4188,19 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
dgEdge *last = NULL;
if (dist20 > dist10) {
dgFloat64 t = (p1p0 % p2p0) / dist20;
- _ASSERTE(t > dgFloat32(0.0f));
- _ASSERTE(t < dgFloat32(1.0f));
+ NEWTON_ASSERT(t > dgFloat32(0.0f));
+ NEWTON_ASSERT(t < dgFloat32(1.0f));
if (firstEdge->m_next->m_next->m_next != firstEdge) {
ConectVertex(firstEdge->m_prev, firstEdge->m_next);
next = firstEdge->m_next->m_twin->m_next;
}
- _ASSERTE(firstEdge->m_next->m_next->m_next == firstEdge);
+ NEWTON_ASSERT(firstEdge->m_next->m_next->m_next == firstEdge);
#ifdef _DEBUG
dgEdge *tmp = firstEdge->m_twin;
do {
- _ASSERTE(tmp->m_incidentFace > 0);
+ NEWTON_ASSERT(tmp->m_incidentFace > 0);
tmp = tmp->m_next;
} while (tmp != firstEdge->m_twin);
#endif
@@ -4229,22 +4229,22 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
} else {
- _ASSERTE(dist20 < dist10);
+ NEWTON_ASSERT(dist20 < dist10);
dgFloat64 t = (p1p0 % p2p0) / dist10;
- _ASSERTE(t > dgFloat32(0.0f));
- _ASSERTE(t < dgFloat32(1.0f));
+ NEWTON_ASSERT(t > dgFloat32(0.0f));
+ NEWTON_ASSERT(t < dgFloat32(1.0f));
if (firstEdge->m_next->m_next->m_next != firstEdge) {
ConectVertex(firstEdge->m_next, firstEdge->m_prev);
next = firstEdge->m_next->m_twin;
}
- _ASSERTE(firstEdge->m_next->m_next->m_next == firstEdge);
+ NEWTON_ASSERT(firstEdge->m_next->m_next->m_next == firstEdge);
#ifdef _DEBUG
dgEdge *tmp = firstEdge->m_twin;
do {
- _ASSERTE(tmp->m_incidentFace > 0);
+ NEWTON_ASSERT(tmp->m_incidentFace > 0);
tmp = tmp->m_next;
} while (tmp != firstEdge->m_twin);
#endif
@@ -4273,8 +4273,8 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
}
if (triangulate) {
- _ASSERTE(begin);
- _ASSERTE(last);
+ NEWTON_ASSERT(begin);
+ NEWTON_ASSERT(last);
for (dgEdge *ptrI = begin->m_next->m_next; ptrI != last;
ptrI = ptrI->m_next) {
dgEdge *const e = AddHalfEdge(begin->m_incidentVertex,
@@ -4282,8 +4282,8 @@ void dgMeshEffect::RepairTJoints(bool triangulate) {
dgEdge *const t = AddHalfEdge(ptrI->m_incidentVertex,
begin->m_incidentVertex);
if (e && t) {
- _ASSERTE(e);
- _ASSERTE(t);
+ NEWTON_ASSERT(e);
+ NEWTON_ASSERT(t);
e->m_twin = t;
t->m_twin = e;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
index 57e173475a0..8d2cc817d40 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect2.cpp
@@ -255,7 +255,7 @@ public:
#ifdef _DEBUG
for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- _ASSERTE(ptr->GetInfo() != node);
+ NEWTON_ASSERT(ptr->GetInfo() != node);
}
#endif
@@ -299,7 +299,7 @@ public:
#ifdef _DEBUG
for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- _ASSERTE(ptr->GetInfo() != node);
+ NEWTON_ASSERT(ptr->GetInfo() != node);
}
#endif
@@ -308,7 +308,7 @@ public:
void RemoveNewVertexNode(dgInt32 index, dgListNode *const node) {
dgVertexMap::dgTreeNode *vertexNode = m_vertexMap.Find(index);
- _ASSERTE(vertexNode);
+ NEWTON_ASSERT(vertexNode);
dgEdgeSharedTetras &header = vertexNode->GetInfo();
for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
@@ -317,7 +317,7 @@ public:
break;
}
}
- _ASSERTE(header.GetCount());
+ NEWTON_ASSERT(header.GetCount());
}
@@ -432,7 +432,7 @@ public:
dgInt32 ReplaceFaceNodes(dgListNode *const faceNode, dgInt32 faceIndex, const dgBigVector &vertex) {
dgConvexHull4dTetraherum *const tetra = &faceNode->GetInfo();
dgListNode *const neighborghNode = tetra->m_faces[faceIndex].m_twin;
- _ASSERTE(neighborghNode);
+ NEWTON_ASSERT(neighborghNode);
dgConvexHull4dTetraherum *const neighborghTetra = &neighborghNode->GetInfo();
@@ -441,8 +441,8 @@ public:
m_points[vertexIndex].m_index = vertexIndex;
m_count ++;
- _ASSERTE(SanityPointInTetra(tetra, vertex));
- _ASSERTE(SanityPointInTetra(neighborghTetra, vertex));
+ NEWTON_ASSERT(SanityPointInTetra(tetra, vertex));
+ NEWTON_ASSERT(SanityPointInTetra(neighborghTetra, vertex));
dgInt32 mark = IncMark();
tetra->SetMark(mark);
@@ -459,12 +459,12 @@ public:
dgListNode *const deleteTetraNode = deletedNodes[i];
dgConvexHull4dTetraherum *const deletedTetra = &deleteTetraNode->GetInfo();
- _ASSERTE(deletedTetra->GetMark() == mark);
+ NEWTON_ASSERT(deletedTetra->GetMark() == mark);
for (dgInt32 i = 0; i < 4; i ++) {
dgListNode *const twinNode = deletedTetra->m_faces[i].m_twin;
dgConvexHull4dTetraherum *const twinTetra = &twinNode->GetInfo();
- _ASSERTE(twinTetra);
+ NEWTON_ASSERT(twinTetra);
if (twinTetra->GetMark() != mark) {
dgInt32 index = 0;
@@ -563,7 +563,7 @@ public:
dgUnsigned64 key = GetKey(i0, i1);
if (!m_edgeMap.Find(key)) {
dgVertexMap::dgTreeNode *const vertexNode = m_vertexMap.Find(i0);
- _ASSERTE(vertexNode);
+ NEWTON_ASSERT(vertexNode);
const dgEdgeSharedTetras &tetraMap = vertexNode->GetInfo();
const dgBigVector &p0 = GetVertex(i0);
@@ -578,14 +578,14 @@ public:
faceIndex = i;
}
}
- _ASSERTE(faceIndex != -1);
+ NEWTON_ASSERT(faceIndex != -1);
const dgBigVector &A = GetVertex(tetra->m_faces[faceIndex].m_index[0]);
const dgBigVector &B = GetVertex(tetra->m_faces[faceIndex].m_index[1]);
const dgBigVector &C = GetVertex(tetra->m_faces[faceIndex].m_index[2]);
dgBigVector baricentric(LineTriangleIntersection(p0, p1, A, B, C));
if (baricentric.m_w == dgFloat64(0.0f)) {
- _ASSERTE((baricentric.m_x > dgFloat64(0.0f)) && (baricentric.m_y > dgFloat64(0.0f)) && (baricentric.m_z > dgFloat64(0.0f)));
+ NEWTON_ASSERT((baricentric.m_x > dgFloat64(0.0f)) && (baricentric.m_y > dgFloat64(0.0f)) && (baricentric.m_z > dgFloat64(0.0f)));
dgBigVector point(A.Scale4(baricentric.m_x) + B.Scale4(baricentric.m_y) + C.Scale4(baricentric.m_z));
dgInt32 index = ReplaceFaceNodes(tetraNode, faceIndex, point);
@@ -603,7 +603,7 @@ public:
dgInt32 index0 = GetVertexIndex(i0);
dgInt32 index1 = GetVertexIndex(i1);
dgPolyhedra::dgTreeNode *const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- _ASSERTE(edgeNode);
+ NEWTON_ASSERT(edgeNode);
m_missinEdges.Addtop(edgeNode);
}
@@ -611,7 +611,7 @@ public:
break;
}
}
- _ASSERTE(edgeFound);
+ NEWTON_ASSERT(edgeFound);
}
}
}
@@ -678,7 +678,7 @@ public:
dgUnsigned64 key = GetKey(k0, k1);
dgEdgeMap::dgTreeNode *const edgeNode = m_edgeMap.Find(key);
- _ASSERTE(edgeNode);
+ NEWTON_ASSERT(edgeNode);
dgEdgeSharedTetras &header = edgeNode->GetInfo();
for (dgEdgeSharedTetras::dgListNode *ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
dgListNode *const tetraNode = ptr->GetInfo();
@@ -701,8 +701,8 @@ public:
index[1] = index[2];
index[2] = tmp;
}
- _ASSERTE(index[0] == faceEdge->m_incidentVertex);
- _ASSERTE(index[1] == faceEdge->m_next->m_incidentVertex);
+ NEWTON_ASSERT(index[0] == faceEdge->m_incidentVertex);
+ NEWTON_ASSERT(index[1] == faceEdge->m_next->m_incidentVertex);
dgEdge *nextEdge = faceEdge->m_next->m_next;
do {
@@ -715,22 +715,22 @@ public:
if (nextEdge != faceEdge) {
if (nextEdge->m_prev != faceEdge->m_next) {
dgEdge *const edge = mesh.ConectVertex(faceEdge->m_next, nextEdge);
- _ASSERTE(edge);
- _ASSERTE(edge->m_next);
- _ASSERTE(edge->m_prev);
- _ASSERTE(edge->m_twin->m_next);
- _ASSERTE(edge->m_twin->m_prev);
- _ASSERTE(faceEdge->m_next == edge->m_twin);
+ NEWTON_ASSERT(edge);
+ NEWTON_ASSERT(edge->m_next);
+ NEWTON_ASSERT(edge->m_prev);
+ NEWTON_ASSERT(edge->m_twin->m_next);
+ NEWTON_ASSERT(edge->m_twin->m_prev);
+ NEWTON_ASSERT(faceEdge->m_next == edge->m_twin);
}
if (nextEdge->m_next != faceEdge) {
#ifdef _DEBUG
dgEdge *const edge = mesh.ConectVertex(faceEdge, nextEdge);
- _ASSERTE(edge);
- _ASSERTE(edge->m_next);
- _ASSERTE(edge->m_prev);
- _ASSERTE(edge->m_twin->m_next);
- _ASSERTE(edge->m_twin->m_prev);
- _ASSERTE(faceEdge->m_prev == edge);
+ NEWTON_ASSERT(edge);
+ NEWTON_ASSERT(edge->m_next);
+ NEWTON_ASSERT(edge->m_prev);
+ NEWTON_ASSERT(edge->m_twin->m_next);
+ NEWTON_ASSERT(edge->m_twin->m_prev);
+ NEWTON_ASSERT(faceEdge->m_prev == edge);
#else
mesh.ConectVertex(faceEdge, nextEdge);
#endif
@@ -760,7 +760,7 @@ public:
edgeArray[count] = ptr;
perimterEdges[count] = ptr;
count ++;
- _ASSERTE(count < sizeof(edgeArray) / sizeof(edgeArray[0]));
+ NEWTON_ASSERT(count < sizeof(edgeArray) / sizeof(edgeArray[0]));
ptr = ptr->m_next;
} while (ptr != face);
perimeterCount = count;
@@ -771,7 +771,7 @@ public:
dgEdge *const triangleFace = edgeArray[count];
bool state = MatchFace(mesh, triangleFace, tetraMark);
if (state) {
- _ASSERTE(triangleFace == triangleFace->m_next->m_next->m_next);
+ NEWTON_ASSERT(triangleFace == triangleFace->m_next->m_next->m_next);
triangleFace->m_mark = faceMark;
dgEdge *ptr = triangleFace->m_next;
do {
@@ -789,7 +789,7 @@ public:
}
}
- _ASSERTE(count == 0);
+ NEWTON_ASSERT(count == 0);
for (dgInt32 i = 1; i <= perimeterCount; i ++) {
dgEdge *const last = perimterEdges[i - 1];
for (dgEdge *edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
@@ -814,7 +814,7 @@ public:
dgEdge *const triangleFace = edgeArray[count];
bool state = MatchFace(mesh, triangleFace, tetraMark);
if (state) {
- _ASSERTE(triangleFace == triangleFace->m_next->m_next->m_next);
+ NEWTON_ASSERT(triangleFace == triangleFace->m_next->m_next->m_next);
triangleFace->m_mark = faceMark;
dgEdge *ptr = triangleFace->m_next;
do {
@@ -832,12 +832,12 @@ public:
}
}
- _ASSERTE(count == 0);
+ NEWTON_ASSERT(count == 0);
for (dgInt32 i = 0; i < perimeterCount; i ++) {
dgEdge *const edge = perimterEdges[i];
if (edge->m_mark != faceMark) {
dgEdge *const borderEdge = m_mesh->FindEdge(edge->m_incidentVertex, edge->m_twin->m_incidentVertex);
- _ASSERTE(borderEdge);
+ NEWTON_ASSERT(borderEdge);
if (!(edgeInconflict.Find(borderEdge) || edgeInconflict.Find(borderEdge->m_twin))) {
edgeInconflict.Insert(borderEdge, borderEdge);
}
@@ -856,15 +856,15 @@ public:
for (dgEdge *ptr = edge; !begin; ptr = ptr->m_next->m_twin) {
begin = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
}
- _ASSERTE(begin);
+ NEWTON_ASSERT(begin);
dgEdge *end = NULL;
for (dgEdge *ptr = edge->m_twin; !end; ptr = ptr->m_next->m_twin) {
end = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
}
- _ASSERTE(end);
+ NEWTON_ASSERT(end);
dgEdge *const newEdge = m_mesh->ConectVertex(end, begin);
- _ASSERTE(!edgeInconflict.Find(newEdge));
+ NEWTON_ASSERT(!edgeInconflict.Find(newEdge));
edgeInconflict.Insert(newEdge, newEdge);
}
}
@@ -893,7 +893,7 @@ public:
// if there are missing sub faces then we must recover those by insertion point on the sub edges of the missing faces
allFaceFound = true;
if (edgeInconflict.GetCount()) {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
/*
allFaceFound = false;
@@ -913,7 +913,7 @@ public:
dgEdge* const newEdge = m_mesh->InsertEdgeVertex (missingEdge, spliteParam);
dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
dgInt32 index = AddVertex(p);
- _ASSERTE (index != -1);
+ NEWTON_ASSERT (index != -1);
indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
}
RecoverEdges ();
@@ -921,7 +921,7 @@ public:
}
#ifdef _DEBUG
if (allFaceFound) {
-// _ASSERTE (0);
+// NEWTON_ASSERT (0);
/*
dgFaceKeyMap faceMap (GetAllocator());
for (dgListNode* node = GetFirst(); node; node = node->GetNext()) {
@@ -929,7 +929,7 @@ public:
for (dgInt32 i = 0; i < 4; i ++) {
dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
dgEdgeFaceKey key (face.m_index[0], face.m_index[1], face.m_index[2]);
- _ASSERTE (!faceMap.Find(key));
+ NEWTON_ASSERT (!faceMap.Find(key));
faceMap.Insert (node, key);
}
}
@@ -944,7 +944,7 @@ public:
ptr = ptr->m_next;
} while (ptr != face);
dgEdgeFaceKey key (face->m_incidentVertex, face->m_next->m_incidentVertex, face->m_next->m_next->m_incidentVertex);
- _ASSERTE (faceMap.Find(key));
+ NEWTON_ASSERT (faceMap.Find(key));
}
}
*/
@@ -1004,7 +1004,7 @@ public:
if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
stackPool[stack] = &face.m_twin->GetInfo();
stack ++;
- _ASSERTE(stack < sizeof(stackPool) / sizeof(stackPool[0]));
+ NEWTON_ASSERT(stack < sizeof(stackPool) / sizeof(stackPool[0]));
}
}
}
@@ -1235,7 +1235,7 @@ public:
dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
dgInt32 index = AddVertex(p);
- _ASSERTE (index != -1);
+ NEWTON_ASSERT (index != -1);
indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
i0 = indexMap[newEdge->m_incidentVertex].m_convexIndex;
@@ -1245,7 +1245,7 @@ public:
dgInt32 index0 = GetVertexIndex(i0);
dgInt32 index1 = GetVertexIndex(i1);
dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- _ASSERTE (edgeNode);
+ NEWTON_ASSERT (edgeNode);
m_missinEdges.Append(edgeNode);
}
@@ -1256,7 +1256,7 @@ public:
dgInt32 index0 = GetVertexIndex(i0);
dgInt32 index1 = GetVertexIndex(i1);
dgPolyhedra::dgTreeNode* const edgeNode = m_mesh->FindEdgeNode(index0, index1);
- _ASSERTE (edgeNode);
+ NEWTON_ASSERT (edgeNode);
m_missinEdges.Append(edgeNode);
}
}
@@ -1325,7 +1325,7 @@ public:
dgUnsigned64 key = GetKey (k0, k1);
dgEdgeMap::dgTreeNode* const edgeNode = m_edgeMap.Find(key);
- _ASSERTE (edgeNode);
+ NEWTON_ASSERT (edgeNode);
dgEdgeSharedTetras& header = edgeNode->GetInfo();
for (dgEdgeSharedTetras::dgListNode* ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
dgListNode* const tetraNode = ptr->GetInfo();
@@ -1348,8 +1348,8 @@ public:
index[1] = index[2];
index[2] = tmp;
}
- _ASSERTE (index[0] == faceEdge->m_incidentVertex);
- _ASSERTE (index[1] == faceEdge->m_next->m_incidentVertex);
+ NEWTON_ASSERT (index[0] == faceEdge->m_incidentVertex);
+ NEWTON_ASSERT (index[1] == faceEdge->m_next->m_incidentVertex);
dgEdge* nextEdge = faceEdge->m_next->m_next;
do {
@@ -1364,24 +1364,24 @@ public:
#ifdef _DEBUG
if (nextEdge->m_prev != faceEdge->m_next) {
dgEdge* const edge = mesh.ConectVertex(faceEdge->m_next, nextEdge);
- _ASSERTE (edge);
- _ASSERTE (edge->m_next);
- _ASSERTE (edge->m_prev);
- _ASSERTE (edge->m_twin->m_next);
- _ASSERTE (edge->m_twin->m_prev);
- _ASSERTE (faceEdge->m_next == edge->m_twin);
+ NEWTON_ASSERT (edge);
+ NEWTON_ASSERT (edge->m_next);
+ NEWTON_ASSERT (edge->m_prev);
+ NEWTON_ASSERT (edge->m_twin->m_next);
+ NEWTON_ASSERT (edge->m_twin->m_prev);
+ NEWTON_ASSERT (faceEdge->m_next == edge->m_twin);
}
#endif
#endif
if (nextEdge->m_next != faceEdge) {
#ifdef _DEBUG
dgEdge* const edge = mesh.ConectVertex(faceEdge, nextEdge);
- _ASSERTE (edge);
- _ASSERTE (edge->m_next);
- _ASSERTE (edge->m_prev);
- _ASSERTE (edge->m_twin->m_next);
- _ASSERTE (edge->m_twin->m_prev);
- _ASSERTE (faceEdge->m_prev == edge);
+ NEWTON_ASSERT (edge);
+ NEWTON_ASSERT (edge->m_next);
+ NEWTON_ASSERT (edge->m_prev);
+ NEWTON_ASSERT (edge->m_twin->m_next);
+ NEWTON_ASSERT (edge->m_twin->m_prev);
+ NEWTON_ASSERT (faceEdge->m_prev == edge);
#else
mesh.ConectVertex(faceEdge, nextEdge);
#endif
@@ -1412,7 +1412,7 @@ public:
edgeArray[count] = ptr;
perimterEdges[count] = ptr;
count ++;
- _ASSERTE (count < sizeof (edgeArray) / sizeof (edgeArray[0]));
+ NEWTON_ASSERT (count < sizeof (edgeArray) / sizeof (edgeArray[0]));
ptr = ptr->m_next;
} while (ptr != face);
perimeterCount = count;
@@ -1424,7 +1424,7 @@ public:
dgEdge* const triangleFace = edgeArray[count];
bool state = MatchFace (mesh, triangleFace, tetraMark);
if (state) {
- _ASSERTE (triangleFace == triangleFace->m_next->m_next->m_next);
+ NEWTON_ASSERT (triangleFace == triangleFace->m_next->m_next->m_next);
triangleFace->m_mark = faceMark;
dgEdge* ptr = triangleFace->m_next;
do {
@@ -1442,7 +1442,7 @@ public:
}
}
- _ASSERTE (count == 0);
+ NEWTON_ASSERT (count == 0);
for (dgInt32 i = 1; i <= perimeterCount; i ++) {
dgEdge* const last = perimterEdges[i - 1];
for (dgEdge* edge = perimterEdges[i]->m_prev; edge != last; edge = edge->m_twin->m_prev) {
@@ -1467,7 +1467,7 @@ public:
dgEdge* const triangleFace = edgeArray[count];
bool state = MatchFace (mesh, triangleFace, tetraMark);
if (state) {
- _ASSERTE (triangleFace == triangleFace->m_next->m_next->m_next);
+ NEWTON_ASSERT (triangleFace == triangleFace->m_next->m_next->m_next);
triangleFace->m_mark = faceMark;
dgEdge* ptr = triangleFace->m_next;
do {
@@ -1485,12 +1485,12 @@ public:
}
}
- _ASSERTE (count == 0);
+ NEWTON_ASSERT (count == 0);
for (dgInt32 i = 0; i < perimeterCount; i ++) {
dgEdge* const edge = perimterEdges[i];
if (edge->m_mark != faceMark) {
dgEdge* const borderEdge = m_mesh->FindEdge(edge->m_incidentVertex, edge->m_twin->m_incidentVertex);
- _ASSERTE (borderEdge);
+ NEWTON_ASSERT (borderEdge);
if (!(edgeInconflict.Find(borderEdge) || edgeInconflict.Find(borderEdge->m_twin))) {
edgeInconflict.Insert(borderEdge, borderEdge);
}
@@ -1509,15 +1509,15 @@ public:
for (dgEdge* ptr = edge; !begin; ptr = ptr->m_next->m_twin) {
begin = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
}
- _ASSERTE (begin);
+ NEWTON_ASSERT (begin);
dgEdge* end = NULL;
for (dgEdge* ptr = edge->m_twin; !end; ptr = ptr->m_next->m_twin) {
end = m_mesh->FindEdge(ptr->m_next->m_incidentVertex, ptr->m_next->m_twin->m_incidentVertex);
}
- _ASSERTE (end);
+ NEWTON_ASSERT (end);
dgEdge* const newEdge = m_mesh->ConectVertex(end, begin);
- _ASSERTE (!edgeInconflict.Find(newEdge));
+ NEWTON_ASSERT (!edgeInconflict.Find(newEdge));
edgeInconflict.Insert(newEdge, newEdge);
}
}
@@ -1566,7 +1566,7 @@ public:
#ifdef _DEBUG
for (dgEdgeSharedTetras::dgListNode* ptr = header.GetFirst(); ptr; ptr = ptr->GetNext()) {
- _ASSERTE (ptr->GetInfo() != node);
+ NEWTON_ASSERT (ptr->GetInfo() != node);
}
#endif
header.Append(node);
@@ -1709,7 +1709,7 @@ public:
dgEdge* const newEdge = m_mesh->InsertEdgeVertex (missingEdge, spliteParam);
dgBigVector p (p1.Add4(p0).Scale4 (spliteParam));
dgInt32 index = AddVertex(p);
- _ASSERTE (index != -1);
+ NEWTON_ASSERT (index != -1);
indexMap[newEdge->m_twin->m_incidentVertex].m_convexIndex = index;
}
RecoverEdges ();
@@ -1723,7 +1723,7 @@ public:
for (dgInt32 i = 0; i < 4; i ++) {
dgConvexHull4dTetraherum::dgTetrahedrumFace& face = tetra->m_faces[i];
dgEdgeFaceKey key (face.m_index[0], face.m_index[1], face.m_index[2]);
- _ASSERTE (!faceMap.Find(key));
+ NEWTON_ASSERT (!faceMap.Find(key));
faceMap.Insert (node, key);
}
}
@@ -1738,7 +1738,7 @@ public:
ptr = ptr->m_next;
} while (ptr != face);
dgEdgeFaceKey key (face->m_incidentVertex, face->m_next->m_incidentVertex, face->m_next->m_next->m_incidentVertex);
- _ASSERTE (faceMap.Find(key));
+ NEWTON_ASSERT (faceMap.Find(key));
}
}
}
@@ -1800,7 +1800,7 @@ public:
if (face.m_twin && (face.m_twin->GetInfo().GetMark() != tetraMark)) {
stackPool[stack] = &face.m_twin->GetInfo();
stack ++;
- _ASSERTE (stack < sizeof (stackPool) / sizeof (stackPool[0]));
+ NEWTON_ASSERT (stack < sizeof (stackPool) / sizeof (stackPool[0]));
}
}
}
@@ -1830,7 +1830,7 @@ public:
dgMeshEffect *dgMeshEffect::CreateDelanayTretrahedralization(
dgInt32 interionMaterial, dgMatrix &matrix) const {
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return NULL;
}
@@ -1845,7 +1845,7 @@ dgMeshEffect *dgMeshEffect::CreateVoronoiPartition(dgInt32 pointsCount,
#endif
dgMeshEffectSolidTree *const tree = CreateSolidTree();
- _ASSERTE(tree);
+ NEWTON_ASSERT(tree);
dgStack<dgBigVector> buffer(pointsCount);
dgBigVector *const pool = &buffer[0];
@@ -1869,11 +1869,11 @@ dgMeshEffect *dgMeshEffect::CreateVoronoiPartition(dgInt32 pointsCount,
}
}
- _ASSERTE(count >= 4);
+ NEWTON_ASSERT(count >= 4);
dgStack<dgInt32> indexList(count);
count = dgVertexListToIndexList(&pool[0].m_x, sizeof(dgBigVector), 3, count,
&indexList[0], dgFloat64(1.0e-5f));
- _ASSERTE(count >= 4);
+ NEWTON_ASSERT(count >= 4);
dgDelaunayTetrahedralization delaunayTetrahedras(GetAllocator(), &pool[0].m_x,
count, sizeof(dgBigVector), 0.0f);
@@ -1964,14 +1964,14 @@ dgMeshEffect *dgMeshEffect::CreateVoronoiPartition(dgInt32 pointsCount,
pointArray[countI] = voronoiPoints[i] + normal.Scale(perimeterConvexBound);
countI++;
- _ASSERTE(countI < dgInt32(sizeof(pointArray) / sizeof(pointArray[0])));
+ NEWTON_ASSERT(countI < dgInt32(sizeof(pointArray) / sizeof(pointArray[0])));
}
}
}
pointArray[countI] = voronoiPoints[i];
countI++;
- _ASSERTE(countI < dgInt32(sizeof(pointArray) / sizeof(pointArray[0])));
+ NEWTON_ASSERT(countI < dgInt32(sizeof(pointArray) / sizeof(pointArray[0])));
}
dgMeshEffect *const convexMesh = MakeDelanayIntersection(tree,
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect3.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect3.cpp
index bdb74a8fdb2..ab19c58d7ec 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect3.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffect3.cpp
@@ -219,7 +219,7 @@ public:
dgEdge *ptr = edge0->m_twin->m_next;
do {
if (ptr->m_twin->m_incidentFace == edge->m_twin->m_incidentFace) {
- _ASSERTE(edge0->m_incidentVertex == ptr->m_incidentVertex);
+ NEWTON_ASSERT(edge0->m_incidentVertex == ptr->m_incidentVertex);
dgBigVector e0(points[edge0->m_twin->m_incidentVertex] - points[edge0->m_incidentVertex]);
dgBigVector e1(points[ptr->m_twin->m_incidentVertex] - points[edge0->m_incidentVertex]);
dgBigVector normal(e0 * e1);
@@ -228,7 +228,7 @@ public:
ptr = ptr->m_twin->m_next;
} while (ptr != edge->m_twin);
- _ASSERTE(0);
+ NEWTON_ASSERT(0);
return true;
}
@@ -385,7 +385,7 @@ dgMeshEffect::dgMeshEffect(const dgMeshEffect &source, dgFloat32 absoluteconcavi
}
}
- _ASSERTE(faceCount == clusterIndex);
+ NEWTON_ASSERT(faceCount == clusterIndex);
// recalculate all edge cost
dgStack<dgInt32> vertexMarksArray(mesh.GetVertexCount());
@@ -408,7 +408,7 @@ dgMeshEffect::dgMeshEffect(const dgMeshEffect &source, dgFloat32 absoluteconcavi
for (dgInt32 faceIndex = 1; faceIndex < faceCount; faceIndex++) {
vertexMark++;
dgClusterList &clusterList = clusters[faceIndex];
- _ASSERTE(clusterList.GetFirst()->GetInfo().m_edge->m_incidentFace == faceIndex);
+ NEWTON_ASSERT(clusterList.GetFirst()->GetInfo().m_edge->m_incidentFace == faceIndex);
clusterList.CalculateNodeCost(mesh, meshMask, &vertexPool[0], &vertexMarks[0], vertexMark, &clusters[0], diagonalInv, aspectRatioCoeficent, proxyList, heap);
}
@@ -421,10 +421,10 @@ dgMeshEffect::dgMeshEffect(const dgMeshEffect &source, dgFloat32 absoluteconcavi
heap.Pop();
dgPairProxi &pair = pairNode->GetInfo();
- _ASSERTE((pair.m_edgeA && pair.m_edgeA) || (!pair.m_edgeA && !pair.m_edgeA));
+ NEWTON_ASSERT((pair.m_edgeA && pair.m_edgeA) || (!pair.m_edgeA && !pair.m_edgeA));
if (pair.m_edgeA && pair.m_edgeB) {
- _ASSERTE(pair.m_edgeA->m_incidentFace != pair.m_edgeB->m_incidentFace);
+ NEWTON_ASSERT(pair.m_edgeA->m_incidentFace != pair.m_edgeB->m_incidentFace);
// merge two clusters
dgInt32 faceIndexA = pair.m_edgeA->m_incidentFace;
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffectSolidTree.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffectSolidTree.cpp
index 535ec178eee..4d59177881a 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMeshEffectSolidTree.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMeshEffectSolidTree.cpp
@@ -55,8 +55,8 @@ bool dgMeshTreeCSGFace::IsPointOnEdge(const dgHugeVector &p0,
if (numf > (DG_CLIPPER_TOL * dgFloat64(1.0e3))) {
if (numf < den.GetAproximateValue() * dgFloat64(1.0 - (DG_CLIPPER_TOL * dgFloat64(1.0e3)))) {
dgGoogol t = num / den;
- _ASSERTE(t.GetAproximateValue() > dgFloat64(0.0f));
- _ASSERTE(t.GetAproximateValue() < dgFloat64(1.0f));
+ NEWTON_ASSERT(t.GetAproximateValue() > dgFloat64(0.0f));
+ NEWTON_ASSERT(t.GetAproximateValue() < dgFloat64(1.0f));
dgHugeVector q1(p0 + p1p0.Scale(t));
dgHugeVector dist(q1 - q0);
dgGoogol dist2 = dist % dist;
@@ -302,17 +302,17 @@ void dgMeshTreeCSGFace::Clip(const dgHugeVector &plane,
*rightOut = NULL;
if ((leftPCount && !rightPCount) || (!leftPCount && rightPCount)) {
if (leftPCount) {
- _ASSERTE(!rightPCount);
+ NEWTON_ASSERT(!rightPCount);
AddRef();
*leftOut = this;
} else {
- _ASSERTE(!leftPCount);
+ NEWTON_ASSERT(!leftPCount);
*rightOut = this;
AddRef();
}
} else if (!(leftPCount || rightPCount)) {
- _ASSERTE(!leftPCount);
- _ASSERTE(!rightPCount);
+ NEWTON_ASSERT(!leftPCount);
+ NEWTON_ASSERT(!rightPCount);
AddRef();
// AddRef();
} else {
@@ -334,7 +334,7 @@ void dgMeshTreeCSGFace::Clip(const dgHugeVector &plane,
dgHugeVector dp(p1 - p0);
dgGoogol den(plane % dp);
dgGoogol num = plane.EvaluePlane(p0);
- _ASSERTE(fabs(num.GetAproximateValue()) > dgFloat64(0.0f));
+ NEWTON_ASSERT(fabs(num.GetAproximateValue()) > dgFloat64(0.0f));
dgGoogol ti(num / den);
inter = p0 - dp.Scale(num / den);
}
@@ -366,8 +366,8 @@ void dgMeshTreeCSGFace::Clip(const dgHugeVector &plane,
leftFace[leftCount] = p1;
leftCount++;
}
- _ASSERTE(leftCount < dgInt32((sizeof(leftFace) / sizeof(leftFace[0])) - 1));
- _ASSERTE(rightCount < dgInt32((sizeof(rightFace) / sizeof(rightFace[0])) - 1));
+ NEWTON_ASSERT(leftCount < dgInt32((sizeof(leftFace) / sizeof(leftFace[0])) - 1));
+ NEWTON_ASSERT(rightCount < dgInt32((sizeof(rightFace) / sizeof(rightFace[0])) - 1));
i0 = i1;
i1++;
@@ -385,7 +385,7 @@ void dgMeshTreeCSGFace::Clip(const dgHugeVector &plane,
*rightOut = new (GetAllocator()) dgMeshTreeCSGFace(GetAllocator(),
rightCount, rightFace);
}
- _ASSERTE(*leftOut || *rightOut);
+ NEWTON_ASSERT(*leftOut || *rightOut);
}
}
@@ -453,10 +453,10 @@ void dgMeshEffectSolidTree::AddFace(const dgMeshEffect &mesh,
stack--;
dgMeshEffectSolidTree *const root = pool[stack];
- _ASSERTE(root->m_planeType == m_divider);
+ NEWTON_ASSERT(root->m_planeType == m_divider);
dgMeshTreeCSGFace *const curve = faces[stack];
- _ASSERTE(curve->CheckConvex(plane));
+ NEWTON_ASSERT(curve->CheckConvex(plane));
dgMeshTreeCSGFace *backOut;
dgMeshTreeCSGFace *frontOut;
@@ -494,7 +494,7 @@ void dgMeshEffectSolidTree::AddFace(const dgMeshEffect &mesh,
faces[stack] = backOut;
pool[stack] = root->m_back;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(pool) / sizeof(pool[0])));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(pool) / sizeof(pool[0])));
}
}
@@ -508,7 +508,7 @@ void dgMeshEffectSolidTree::AddFace(const dgMeshEffect &mesh,
faces[stack] = frontOut;
pool[stack] = root->m_front;
stack++;
- _ASSERTE(stack < dgInt32(sizeof(pool) / sizeof(pool[0])));
+ NEWTON_ASSERT(stack < dgInt32(sizeof(pool) / sizeof(pool[0])));
}
}
}
@@ -522,7 +522,7 @@ dgMeshEffectSolidTree::dgPlaneType dgMeshEffectSolidTree::GetPointSide(
const dgHugeVector &point) const {
const dgMeshEffectSolidTree *root = this;
- _ASSERTE(root);
+ NEWTON_ASSERT(root);
while (root->m_planeType == dgMeshEffectSolidTree::m_divider) {
dgGoogol test = root->m_plane.EvaluePlane(point);
dgFloat64 dist = test.GetAproximateValue();
@@ -535,7 +535,7 @@ dgMeshEffectSolidTree::dgPlaneType dgMeshEffectSolidTree::GetPointSide(
} else if (dist > dgFloat64(0.0f)) {
root = root->m_front;
} else {
- _ASSERTE(dist < dgFloat64(0.0f));
+ NEWTON_ASSERT(dist < dgFloat64(0.0f));
root = root->m_back;
}
}
diff --git a/engines/hpl1/engine/libraries/newton/physics/dgMinkowskiConv.cpp b/engines/hpl1/engine/libraries/newton/physics/dgMinkowskiConv.cpp
index 3a293fa3999..b35bfbdfa9a 100644
--- a/engines/hpl1/engine/libraries/newton/physics/dgMinkowskiConv.cpp
+++ b/engines/hpl1/engine/libraries/newton/physics/dgMinkowskiConv.cpp
@@ -120,7 +120,7 @@ class dgContactSolver {
More information about the Scummvm-git-logs
mailing list