TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-12 19:31:41 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'smally/platform_type_consistency' into platform-type-consistency

Browse source 
Conflicts:
	Engine/source/platform/platformCPUCount.cpp
This commit is contained in:
Daniel Buckmaster 2014-04-04 13:43:25 +11:00
commit 87d9e245b7
210 changed files with 896 additions and 896 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Engine/source/math/mBox.cpp
View file

@ -61,7 +61,7 @@ bool Box3F::collideLine(const Point3F& start, const Point3F& end, F32* t, Point3
static const Point3F na[3] = { Point3F(1.0f, 0.0f, 0.0f), Point3F(0.0f, 1.0f, 0.0f), Point3F(0.0f, 0.0f, 1.0f) };
Point3F finalNormal(0.0f, 0.0f, 0.0f);
for (int i = 0; i < 3; i++) {
for (S32 i = 0; i < 3; i++) {
bool n_neg = false;
if (si[i] < ei[i]) {
if (si[i] > bmax[i] || ei[i] < bmin[i])

6
Engine/source/math/mMathAltivec.cpp
View file

@ -38,9 +38,9 @@
/// because we get a much better speed gain if we can assume the data is aligned.
void vec_MatrixF_x_MatrixF(const F32 *matA, const F32 *matB, F32 *result)
{
vector float A[4][1];
vector float B[4][1];
vector float C[4][1];
vector F32 A[4][1];
vector F32 B[4][1];
vector F32 C[4][1];
/// If the incoming pointers are not 16-byte aligned, we have to load & store the slow way.
if((int)matA & 0xF || (int)matB & 0xF || (int)result & 0xF)

2
Engine/source/math/mMathFn.h
View file

@ -442,7 +442,7 @@ inline bool mIsNaN_F( const F32 x )
inline bool mIsInf_F( const F32 x )
{
return ( x == std::numeric_limits< float >::infinity() );
return ( x == std::numeric_limits< F32 >::infinity() );
}
inline F32 mSign( const F32 n )

4
Engine/source/math/mPolyhedron.h
View file

@ -229,7 +229,7 @@ struct PolyhedronUnmanagedVectorData : public PolyhedronData
};
/// Polyhedron data stored in fixed size arrays.
template< int NUM_PLANES, int NUM_POINTS, int NUM_EDGES >
template< S32 NUM_PLANES, S32 NUM_POINTS, S32 NUM_EDGES >
struct PolyhedronFixedVectorData : public PolyhedronData
{
typedef FixedSizeVector< PlaneF, NUM_PLANES > PlaneListType;
@ -479,7 +479,7 @@ inline PolyhedronVectorData::operator AnyPolyhedron() const
//-----------------------------------------------------------------------------
template< int NUM_PLANES, int NUM_POINTS, int NUM_EDGES >
template< S32 NUM_PLANES, S32 NUM_POINTS, S32 NUM_EDGES >
inline PolyhedronFixedVectorData< NUM_PLANES, NUM_POINTS, NUM_EDGES >::operator AnyPolyhedron() const
{
return AnyPolyhedron(

2
Engine/source/math/mQuadPatch.cpp
View file

@ -52,7 +52,7 @@ void QuadPatch::submitControlPoints( SplCtrlPts &points )
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void QuadPatch::setControlPoint( Point3F &point, int index )
void QuadPatch::setControlPoint( Point3F &point, S32 index )
{
( (SplCtrlPts*) getControlPoints() )->setPoint( point, index );
calcABC( getControlPoint(0) );

2
Engine/source/math/mQuadPatch.h
View file

@ -51,7 +51,7 @@ public:
virtual void calc( F32 t, Point3F &result );
virtual void calc( Point3F *points, F32 t, Point3F &result );
virtual void setControlPoint( Point3F &point, int index );
virtual void setControlPoint( Point3F &point, S32 index );
virtual void submitControlPoints( SplCtrlPts &points );

6
Engine/source/math/mQuat.cpp
View file

@ -262,12 +262,12 @@ QuatF & QuatF::interpolate( const QuatF & q1, const QuatF & q2, F32 t )
//-----------------------------------
// calculate interpolating coeffs:
double scale1, scale2;
F64 scale1, scale2;
if ( (1.0 - cosOmega) > 0.00001 )
{
// standard case
double omega = mAcos(cosOmega);
double sinOmega = mSin(omega);
F64 omega = mAcos(cosOmega);
F64 sinOmega = mSin(omega);
scale1 = mSin((1.0 - t) * omega) / sinOmega;
scale2 = sign2 * mSin(t * omega) / sinOmega;
}

6
Engine/source/math/mQuat.h
View file

@ -55,8 +55,8 @@ public:
QuatF& set( const AngAxisF & a );
QuatF& set( const EulerF & e );
int operator ==( const QuatF & c ) const;
int operator !=( const QuatF & c ) const;
S32 operator ==( const QuatF & c ) const;
S32 operator !=( const QuatF & c ) const;
QuatF& operator *=( const QuatF & c );
QuatF& operator /=( const QuatF & c );
QuatF& operator +=( const QuatF & c );
@ -75,7 +75,7 @@ public:
QuatF& normalize();
QuatF& inverse();
QuatF& identity();
int isIdentity() const;
S32 isIdentity() const;
QuatF& slerp( const QuatF & q, F32 t );
QuatF& extrapolate( const QuatF & q1, const QuatF & q2, F32 t );
QuatF& interpolate( const QuatF & q1, const QuatF & q2, F32 t );

4
Engine/source/math/mSplinePatch.cpp
View file

@ -68,7 +68,7 @@ void SplCtrlPts::submitPoints( Point3F *pts, U32 num )
{
mPoints.clear();
for( int i=0; i<num; i++ )
for( S32 i=0; i<num; i++ )
{
mPoints.push_back( pts[i] );
}
@ -89,7 +89,7 @@ SplinePatch::SplinePatch()
// to re-calc any pre-calculated data it may be using from the submitted control
// points.
//------------------------------------------------------------------------------
void SplinePatch::setControlPoint( Point3F &point, int index )
void SplinePatch::setControlPoint( Point3F &point, S32 index )
{
mControlPoints.setPoint( point, index );
}

2
Engine/source/math/mSplinePatch.h
View file

@ -110,7 +110,7 @@ public:
const Point3F * getControlPoint( U32 index ){ return mControlPoints.getPoint( index ); }
// virtuals
virtual void setControlPoint( Point3F &point, int index );
virtual void setControlPoint( Point3F &point, S32 index );
/// If you have a preconstructed "SplCtrlPts" class, submit it with this function.
/// @see SplCtrlPts
virtual void submitControlPoints( SplCtrlPts &points ){ mControlPoints = points; }

8
Engine/source/math/mathUtils.cpp
View file

@ -819,7 +819,7 @@ U32 greatestCommonDivisor( U32 u, U32 v )
{
// http://en.wikipedia.org/wiki/Binary_GCD_algorithm
int shift;
S32 shift;
/* GCD(0,x) := x */
if (u == 0 || v == 0)
@ -845,7 +845,7 @@ U32 greatestCommonDivisor( U32 u, U32 v )
if (u < v) {
v -= u;
} else {
unsigned int diff = u - v;
U32 diff = u - v;
u = v;
v = diff;
}
@ -1086,7 +1086,7 @@ struct QuadSortPoint
};
// Used by sortQuadWindingOrder.
int QSORT_CALLBACK cmpAngleAscending( const void *a, const void *b )
S32 QSORT_CALLBACK cmpAngleAscending( const void *a, const void *b )
{
const QuadSortPoint *p0 = (const QuadSortPoint*)a;
const QuadSortPoint *p1 = (const QuadSortPoint*)b;
@ -1102,7 +1102,7 @@ int QSORT_CALLBACK cmpAngleAscending( const void *a, const void *b )
}
// Used by sortQuadWindingOrder.
int QSORT_CALLBACK cmpAngleDescending( const void *a, const void *b )
S32 QSORT_CALLBACK cmpAngleDescending( const void *a, const void *b )
{
const QuadSortPoint *p0 = (const QuadSortPoint*)a;
const QuadSortPoint *p1 = (const QuadSortPoint*)b;