summaryrefslogtreecommitdiff
path: root/indra/llmath
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llmath')
-rwxr-xr-xindra/llmath/llline.cpp1
-rwxr-xr-xindra/llmath/llmath.h36
-rwxr-xr-xindra/llmath/lloctree.h16
-rwxr-xr-xindra/llmath/llquantize.h4
-rwxr-xr-xindra/llmath/llvolume.cpp14
-rwxr-xr-xindra/llmath/tests/llquaternion_test.cpp4
-rwxr-xr-xindra/llmath/tests/mathmisc_test.cpp24
-rwxr-xr-xindra/llmath/tests/v4coloru_test.cpp8
-rwxr-xr-xindra/llmath/v4color.cpp8
-rwxr-xr-xindra/llmath/v4coloru.h22
10 files changed, 53 insertions, 84 deletions
diff --git a/indra/llmath/llline.cpp b/indra/llmath/llline.cpp
index f26231840b..cfee315b55 100755
--- a/indra/llmath/llline.cpp
+++ b/indra/llmath/llline.cpp
@@ -30,7 +30,6 @@
#include "llline.h"
#include "llrand.h"
-const F32 SOME_SMALL_NUMBER = 1.0e-5f;
const F32 SOME_VERY_SMALL_NUMBER = 1.0e-8f;
LLLine::LLLine()
diff --git a/indra/llmath/llmath.h b/indra/llmath/llmath.h
index a8b27ad189..93b9f22b25 100755
--- a/indra/llmath/llmath.h
+++ b/indra/llmath/llmath.h
@@ -206,16 +206,16 @@ inline S32 llceil( F32 f )
#ifndef BOGUS_ROUND
// Use this round. Does an arithmetic round (0.5 always rounds up)
-inline S32 llround(const F32 val)
+inline S32 ll_round(const F32 val)
{
return llfloor(val + 0.5f);
}
#else // BOGUS_ROUND
-// Old llround implementation - does banker's round (toward nearest even in the case of a 0.5.
+// Old ll_round implementation - does banker's round (toward nearest even in the case of a 0.5.
// Not using this because we don't have a consistent implementation on both platforms, use
// llfloor(val + 0.5f), which is consistent on all platforms.
-inline S32 llround(const F32 val)
+inline S32 ll_round(const F32 val)
{
#if LL_WINDOWS
// Note: assumes that the floating point control word is set to rounding mode (the default)
@@ -254,12 +254,12 @@ inline int round_int(double x)
}
#endif // BOGUS_ROUND
-inline F32 llround( F32 val, F32 nearest )
+inline F32 ll_round( F32 val, F32 nearest )
{
return F32(floor(val * (1.0f / nearest) + 0.5f)) * nearest;
}
-inline F64 llround( F64 val, F64 nearest )
+inline F64 ll_round( F64 val, F64 nearest )
{
return F64(floor(val * (1.0 / nearest) + 0.5)) * nearest;
}
@@ -309,25 +309,6 @@ const S32 LL_SHIFT_AMOUNT = 16; //16.16 fixed point represe
#define LL_MAN_INDEX 1
#endif
-/* Deprecated: use llround(), lltrunc(), or llfloor() instead
-// ================================================================================================
-// Real2Int
-// ================================================================================================
-inline S32 F64toS32(F64 val)
-{
- val = val + LL_DOUBLE_TO_FIX_MAGIC;
- return ((S32*)&val)[LL_MAN_INDEX] >> LL_SHIFT_AMOUNT;
-}
-
-// ================================================================================================
-// Real2Int
-// ================================================================================================
-inline S32 F32toS32(F32 val)
-{
- return F64toS32 ((F64)val);
-}
-*/
-
////////////////////////////////////////////////
//
// Fast exp and log
@@ -351,9 +332,7 @@ static union
#define LL_EXP_A (1048576 * OO_LN2) // use 1512775 for integer
#define LL_EXP_C (60801) // this value of C good for -4 < y < 4
-#define LL_FAST_EXP(y) (LLECO.n.i = llround(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
-
-
+#define LL_FAST_EXP(y) (LLECO.n.i = ll_round(F32(LL_EXP_A*(y))) + (1072693248 - LL_EXP_C), LLECO.d)
inline F32 llfastpow(const F32 x, const F32 y)
{
@@ -370,9 +349,6 @@ inline F32 snap_to_sig_figs(F32 foo, S32 sig_figs)
bar *= 10.f;
}
- //F32 new_foo = (F32)llround(foo * bar);
- // the llround() implementation sucks. Don't us it.
-
F32 sign = (foo > 0.f) ? 1.f : -1.f;
F32 new_foo = F32( S64(foo * bar + sign * 0.5f));
new_foo /= bar;
diff --git a/indra/llmath/lloctree.h b/indra/llmath/lloctree.h
index 7b5240c651..280d2653d3 100755
--- a/indra/llmath/lloctree.h
+++ b/indra/llmath/lloctree.h
@@ -322,7 +322,7 @@ public:
//is it here?
if (isInside(data->getPositionGroup()))
{
- if (((getElementCount() < gOctreeMaxCapacity || getSize()[0] <= gOctreeMinSize) && contains(data->getBinRadius()) ||
+ if ((((getElementCount() < gOctreeMaxCapacity || getSize()[0] <= gOctreeMinSize) && contains(data->getBinRadius())) ||
(data->getBinRadius() > getSize()[0] && parent && parent->getElementCount() >= gOctreeMaxCapacity)))
{ //it belongs here
mData.push_back(NULL);
@@ -445,7 +445,7 @@ public:
mDataEnd = &mData[0];
}
- notifyRemoval(data);
+ this->notifyRemoval(data);
checkAlive();
}
@@ -711,7 +711,7 @@ public:
//(don't notify listeners of addition)
for (U32 i = 0; i < child->getChildCount(); i++)
{
- addChild(child->getChild(i), TRUE);
+ this->addChild(child->getChild(i), TRUE);
}
//destroy child
@@ -755,10 +755,10 @@ public:
return false;
}
- if (this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup()))
+ if (this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup()))
{
//we got it, just act like a branch
- oct_node* node = getNodeAt(data);
+ oct_node* node = this->getNodeAt(data);
if (node == this)
{
LLOctreeNode<T>::insert(data);
@@ -771,7 +771,7 @@ public:
else if (this->getChildCount() == 0)
{
//first object being added, just wrap it up
- while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+ while (!(this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup())))
{
LLVector4a center, size;
center = this->getCenter();
@@ -786,7 +786,7 @@ public:
}
else
{
- while (!(this->getSize()[0] > data->getBinRadius() && isInside(data->getPositionGroup())))
+ while (!(this->getSize()[0] > data->getBinRadius() && this->isInside(data->getPositionGroup())))
{
//the data is outside the root node, we need to grow
LLVector4a center(this->getCenter());
@@ -814,7 +814,7 @@ public:
//clear our children and add the root copy
this->clearChildren();
- addChild(newnode);
+ this->addChild(newnode);
}
//insert the data
diff --git a/indra/llmath/llquantize.h b/indra/llmath/llquantize.h
index 1595dbecf8..10c950abbb 100755
--- a/indra/llmath/llquantize.h
+++ b/indra/llmath/llquantize.h
@@ -52,7 +52,7 @@ inline U16 F32_to_U16_ROUND(F32 val, F32 lower, F32 upper)
val /= (upper - lower);
// round the value. Sreturn the U16
- return (U16)(llround(val*U16MAX));
+ return (U16)(ll_round(val*U16MAX));
}
@@ -92,7 +92,7 @@ inline U8 F32_to_U8_ROUND(F32 val, F32 lower, F32 upper)
val /= (upper - lower);
// return the rounded U8
- return (U8)(llround(val*U8MAX));
+ return (U8)(ll_round(val*U8MAX));
}
diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index adf6e790d3..c2198b91a7 100755
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -56,8 +56,6 @@
#define DEBUG_SILHOUETTE_NORMALS 0 // TomY: Use this to display normals using the silhouette
#define DEBUG_SILHOUETTE_EDGE_MAP 0 // DaveP: Use this to display edge map using the silhouette
-const F32 CUT_MIN = 0.f;
-const F32 CUT_MAX = 1.f;
const F32 MIN_CUT_DELTA = 0.02f;
const F32 HOLLOW_MIN = 0.f;
@@ -560,7 +558,7 @@ void LLProfile::genNGon(const LLProfileParams& params, S32 sides, F32 offset, F3
// Scale to have size "match" scale. Compensates to get object to generally fill bounding box.
- S32 total_sides = llround(sides / ang_scale); // Total number of sides all around
+ S32 total_sides = ll_round(sides / ang_scale); // Total number of sides all around
if (total_sides < 8)
{
@@ -2076,7 +2074,7 @@ LLVolume::LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL ge
generate();
- if (mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE || mParams.getSculptType() == LL_SCULPT_TYPE_MESH)
+ if ((mParams.getSculptID().isNull() && mParams.getSculptType() == LL_SCULPT_TYPE_NONE) || mParams.getSculptType() == LL_SCULPT_TYPE_MESH)
{
createVolumeFaces();
}
@@ -4038,7 +4036,6 @@ LLVertexIndexPair::LLVertexIndexPair(const LLVector3 &vertex, const S32 index)
}
const F32 VERTEX_SLOP = 0.00001f;
-const F32 VERTEX_SLOP_SQRD = VERTEX_SLOP * VERTEX_SLOP;
struct lessVertex
{
@@ -4925,9 +4922,7 @@ F64 find_vertex_score(LLVCacheVertexData& data)
{
F64 score = -1.0;
- if (data.mActiveTriangles >= 0)
- {
- score = 0.0;
+ score = 0.0;
S32 cache_idx = data.mCacheTag;
@@ -4949,9 +4944,8 @@ F64 find_vertex_score(LLVCacheVertexData& data)
}
//bonus points for having low valence
- F64 valence_boost = pow((F64)data.mActiveTriangles, -FindVertexScore_ValenceBoostPower);
+ F64 valence_boost = pow((F64)data.mActiveTriangles, -FindVertexScore_ValenceBoostPower);
score += FindVertexScore_ValenceBoostScale * valence_boost;
- }
return score;
}
diff --git a/indra/llmath/tests/llquaternion_test.cpp b/indra/llmath/tests/llquaternion_test.cpp
index e69010b2d6..3490829743 100755
--- a/indra/llmath/tests/llquaternion_test.cpp
+++ b/indra/llmath/tests/llquaternion_test.cpp
@@ -175,10 +175,10 @@ namespace tut
void llquat_test_object_t::test<6>()
{
LLQuaternion quat1(3.0f, 2.0f, 6.0f, 0.0f), quat2(1.0f, 1.0f, 1.0f, 1.0f);
- ensure("1. The two values are different", llround(12.000000f, 2) == llround(dot(quat1, quat2), 2));
+ ensure("1. The two values are different", ll_round(12.000000f, 2) == ll_round(dot(quat1, quat2), 2));
LLQuaternion quat0(3.0f, 9.334f, 34.5f, 23.0f), quat(34.5f, 23.23f, 2.0f, 45.5f);
- ensure("2. The two values are different", llround(1435.828807f, 2) == llround(dot(quat0, quat), 2));
+ ensure("2. The two values are different", ll_round(1435.828807f, 2) == ll_round(dot(quat0, quat), 2));
}
//test case for LLQuaternion &LLQuaternion::constrain(F32 radians) fn.
diff --git a/indra/llmath/tests/mathmisc_test.cpp b/indra/llmath/tests/mathmisc_test.cpp
index 91a2e6c009..f12140cf8f 100755
--- a/indra/llmath/tests/mathmisc_test.cpp
+++ b/indra/llmath/tests/mathmisc_test.cpp
@@ -128,33 +128,33 @@ namespace tut
void math_object::test<8>()
{
F32 val = 430903.2f;
- S32 val1 = llround(val);
- ensure("float llround value 1", (430903 == val1));
+ S32 val1 = ll_round(val);
+ ensure("float ll_round value 1", (430903 == val1));
val = -430903.9f;
- val1 = llround(val);
- ensure("float llround value 2", (-430904 == val1));
+ val1 = ll_round(val);
+ ensure("float ll_round value 2", (-430904 == val1));
}
template<> template<>
void math_object::test<9>()
{
F32 val = 430905.2654f, nearest = 100.f;
- val = llround(val, nearest);
- ensure("float llround value 1", (430900 == val));
+ val = ll_round(val, nearest);
+ ensure("float ll_round value 1", (430900 == val));
val = -430905.2654f, nearest = 10.f;
- val = llround(val, nearest);
- ensure("float llround value 1", (-430910 == val));
+ val = ll_round(val, nearest);
+ ensure("float ll_round value 1", (-430910 == val));
}
template<> template<>
void math_object::test<10>()
{
F64 val = 430905.2654, nearest = 100.0;
- val = llround(val, nearest);
- ensure("double llround value 1", (430900 == val));
+ val = ll_round(val, nearest);
+ ensure("double ll_round value 1", (430900 == val));
val = -430905.2654, nearest = 10.0;
- val = llround(val, nearest);
- ensure("double llround value 1", (-430910.00000 == val));
+ val = ll_round(val, nearest);
+ ensure("double ll_round value 1", (-430910.00000 == val));
}
template<> template<>
diff --git a/indra/llmath/tests/v4coloru_test.cpp b/indra/llmath/tests/v4coloru_test.cpp
index 128f6f3564..12e607a820 100755
--- a/indra/llmath/tests/v4coloru_test.cpp
+++ b/indra/llmath/tests/v4coloru_test.cpp
@@ -300,8 +300,8 @@ namespace tut
LLColor4U llcolor4u(r,g,b,a),llcolor4u1;
const F32 fVal = 3.f;
llcolor4u1 = llcolor4u.multAll(fVal);
- ensure("multAll:Fail to multiply ", (((U8)llround(r * fVal) == llcolor4u1.mV[VX]) && (U8)llround(g * fVal) == llcolor4u1.mV[VY]
- && ((U8)llround(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)llround(a * fVal) == llcolor4u1.mV[VW])));
+ ensure("multAll:Fail to multiply ", (((U8)ll_round(r * fVal) == llcolor4u1.mV[VX]) && (U8)ll_round(g * fVal) == llcolor4u1.mV[VY]
+ && ((U8)ll_round(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)ll_round(a * fVal) == llcolor4u1.mV[VW])));
}
template<> template<>
@@ -329,8 +329,8 @@ namespace tut
llcolor4u.setVecScaleClamp(color3);
const S32 MAX_COLOR = 255;
F32 color_scale_factor = MAX_COLOR/r;
- S32 r2 = llround(r * color_scale_factor);
- S32 g2 = llround(g * color_scale_factor);
+ S32 r2 = ll_round(r * color_scale_factor);
+ S32 g2 = ll_round(g * color_scale_factor);
ensure("setVecScaleClamp():Fail to add the value ", ((r2 == llcolor4u.mV[VX]) && (g2 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
}
}
diff --git a/indra/llmath/v4color.cpp b/indra/llmath/v4color.cpp
index cd2be7c8fd..79a64b24f2 100755
--- a/indra/llmath/v4color.cpp
+++ b/indra/llmath/v4color.cpp
@@ -125,10 +125,10 @@ LLColor4 LLColor4::cyan6(0.2f, 0.6f, 0.6f, 1.0f);
LLColor4::operator const LLColor4U() const
{
return LLColor4U(
- (U8)llclampb(llround(mV[VRED]*255.f)),
- (U8)llclampb(llround(mV[VGREEN]*255.f)),
- (U8)llclampb(llround(mV[VBLUE]*255.f)),
- (U8)llclampb(llround(mV[VALPHA]*255.f)));
+ (U8)llclampb(ll_round(mV[VRED]*255.f)),
+ (U8)llclampb(ll_round(mV[VGREEN]*255.f)),
+ (U8)llclampb(ll_round(mV[VBLUE]*255.f)),
+ (U8)llclampb(ll_round(mV[VALPHA]*255.f)));
}
LLColor4::LLColor4(const LLColor3 &vec, F32 a)
diff --git a/indra/llmath/v4coloru.h b/indra/llmath/v4coloru.h
index 12da7e2dd7..fddad34978 100755
--- a/indra/llmath/v4coloru.h
+++ b/indra/llmath/v4coloru.h
@@ -353,10 +353,10 @@ inline LLColor4U LLColor4U::multAll(const F32 k)
{
// Round to nearest
return LLColor4U(
- (U8)llround(mV[VX] * k),
- (U8)llround(mV[VY] * k),
- (U8)llround(mV[VZ] * k),
- (U8)llround(mV[VW] * k));
+ (U8)ll_round(mV[VX] * k),
+ (U8)ll_round(mV[VY] * k),
+ (U8)ll_round(mV[VZ] * k),
+ (U8)ll_round(mV[VW] * k));
}
/*
inline LLColor4U operator*(const LLColor4U &a, U8 k)
@@ -471,7 +471,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
color_scale_factor /= max_color;
}
const S32 MAX_COLOR = 255;
- S32 r = llround(color.mV[0] * color_scale_factor);
+ S32 r = ll_round(color.mV[0] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
@@ -482,7 +482,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
}
mV[0] = r;
- S32 g = llround(color.mV[1] * color_scale_factor);
+ S32 g = ll_round(color.mV[1] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
@@ -493,7 +493,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
}
mV[1] = g;
- S32 b = llround(color.mV[2] * color_scale_factor);
+ S32 b = ll_round(color.mV[2] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;
@@ -505,7 +505,7 @@ void LLColor4U::setVecScaleClamp(const LLColor4& color)
mV[2] = b;
// Alpha shouldn't be scaled, just clamped...
- S32 a = llround(color.mV[3] * MAX_COLOR);
+ S32 a = ll_round(color.mV[3] * MAX_COLOR);
if (a > MAX_COLOR)
{
a = MAX_COLOR;
@@ -527,7 +527,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
const S32 MAX_COLOR = 255;
- S32 r = llround(color.mV[0] * color_scale_factor);
+ S32 r = ll_round(color.mV[0] * color_scale_factor);
if (r > MAX_COLOR)
{
r = MAX_COLOR;
@@ -539,7 +539,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
mV[0] = r;
- S32 g = llround(color.mV[1] * color_scale_factor);
+ S32 g = ll_round(color.mV[1] * color_scale_factor);
if (g > MAX_COLOR)
{
g = MAX_COLOR;
@@ -551,7 +551,7 @@ void LLColor4U::setVecScaleClamp(const LLColor3& color)
}
mV[1] = g;
- S32 b = llround(color.mV[2] * color_scale_factor);
+ S32 b = ll_round(color.mV[2] * color_scale_factor);
if (b > MAX_COLOR)
{
b = MAX_COLOR;
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-31 15:13:28 +0000