summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--indra/llcommon/lldate.cpp4
-rw-r--r--indra/llcommon/lldate.h4
-rw-r--r--indra/llcommon/lldefs.h3
-rw-r--r--indra/llcommon/llerrorlegacy.h7
-rw-r--r--indra/llcommon/lltimer.cpp15
-rw-r--r--indra/llcommon/lltimer.h16
-rw-r--r--indra/llcommon/lltrace.h54
-rw-r--r--indra/llcommon/lltracerecording.h2
-rw-r--r--indra/llcommon/llunit.h404
-rw-r--r--indra/llmath/v4color.h6
-rwxr-xr-xindra/llrender/llimagegl.cpp6
-rwxr-xr-xindra/llrender/llimagegl.h6
-rw-r--r--indra/newview/llappviewer.cpp2
-rw-r--r--indra/newview/llappviewer.h2
-rw-r--r--indra/newview/lldrawpoolwater.cpp2
-rwxr-xr-xindra/newview/lltextureview.cpp18
-rwxr-xr-xindra/newview/llviewerassetstats.cpp4
-rwxr-xr-xindra/newview/llviewermessage.cpp20
-rwxr-xr-xindra/newview/llviewerstats.cpp6
-rwxr-xr-xindra/newview/llviewerstats.h6
-rw-r--r--indra/newview/llviewertexture.cpp18
-rwxr-xr-xindra/newview/llviewertexture.h14
-rwxr-xr-xindra/newview/llviewerwindow.cpp2
23 files changed, 295 insertions, 326 deletions
diff --git a/indra/llcommon/lldate.cpp b/indra/llcommon/lldate.cpp
index d8b3dfe6c6..5569b4102d 100644
--- a/indra/llcommon/lldate.cpp
+++ b/indra/llcommon/lldate.cpp
@@ -54,8 +54,8 @@ LLDate::LLDate(const LLDate& date) :
mSecondsSinceEpoch(date.mSecondsSinceEpoch)
{}
-LLDate::LLDate(LLUnit::Seconds<F64> seconds_since_epoch) :
- mSecondsSinceEpoch(seconds_since_epoch)
+LLDate::LLDate(LLUnit<LLUnits::Seconds, F64> seconds_since_epoch) :
+ mSecondsSinceEpoch(seconds_since_epoch.value())
{}
LLDate::LLDate(const std::string& iso8601_date)
diff --git a/indra/llcommon/lldate.h b/indra/llcommon/lldate.h
index 0500b1dcd8..b62a846147 100644
--- a/indra/llcommon/lldate.h
+++ b/indra/llcommon/lldate.h
@@ -57,9 +57,9 @@ public:
/**
* @brief Construct a date from a seconds since epoch value.
*
- * @pararm seconds_since_epoch The number of seconds since UTC epoch.
+ * @param seconds_since_epoch The number of seconds since UTC epoch.
*/
- LLDate(LLUnit::Seconds<F64> seconds_since_epoch);
+ LLDate(LLUnit<LLUnits::Seconds, F64> seconds_since_epoch);
/**
* @brief Construct a date from a string representation
diff --git a/indra/llcommon/lldefs.h b/indra/llcommon/lldefs.h
index 5a4b8325f4..d57b9dccff 100644
--- a/indra/llcommon/lldefs.h
+++ b/indra/llcommon/lldefs.h
@@ -244,5 +244,8 @@ inline void llswap(LLDATATYPE& lhs, LLDATATYPE& rhs)
rhs = tmp;
}
+#define LL_GLUE_IMPL(x, y) x##y
+#define LL_GLUE_TOKENS(x, y) LL_GLUE_IMPL(x, y)
+
#endif // LL_LLDEFS_H
diff --git a/indra/llcommon/llerrorlegacy.h b/indra/llcommon/llerrorlegacy.h
index 37cee579cd..58cc2899af 100644
--- a/indra/llcommon/llerrorlegacy.h
+++ b/indra/llcommon/llerrorlegacy.h
@@ -29,6 +29,7 @@
#define LL_LLERRORLEGACY_H
#include "llpreprocessor.h"
+#include <boost/static_assert.hpp>
/*
LEGACY -- DO NOT USE THIS STUFF ANYMORE
@@ -111,6 +112,12 @@ const int LL_ERR_PRICE_MISMATCH = -23018;
#define llverify(func) do {if (func) {}} while(0)
#endif
+#ifdef LL_WINDOWS
+#define llstatic_assert(func, msg) static_assert(func, msg)
+#else
+#define llstatic_assert(func, msg) BOOST_STATIC_ASSERT(func)
+#endif
+
// handy compile-time assert - enforce those template parameters!
#define cassert(expn) typedef char __C_ASSERT__[(expn)?1:-1] /* Flawfinder: ignore */
//XXX: used in two places in llcommon/llskipmap.h
diff --git a/indra/llcommon/lltimer.cpp b/indra/llcommon/lltimer.cpp
index 05f6b789e4..23cebf4336 100644
--- a/indra/llcommon/lltimer.cpp
+++ b/indra/llcommon/lltimer.cpp
@@ -287,15 +287,14 @@ LLTimer::~LLTimer()
}
// static
-LLUnit::Microseconds<U64> LLTimer::getTotalTime()
+LLUnit<LLUnits::Microseconds, U64> LLTimer::getTotalTime()
{
- LLUnit::Seconds<F64> sec = LLUnit::Milliseconds<U32>(2000) + LLUnit::Hours<F32>(1.f / 360.f);
// simply call into the implementation function.
return totalTime();
}
// static
-LLUnit::Seconds<F64> LLTimer::getTotalSeconds()
+LLUnit<LLUnits::Seconds, F64> LLTimer::getTotalSeconds()
{
return U64_to_F64(getTotalTime()) * USEC_TO_SEC_F64;
}
@@ -344,23 +343,23 @@ U64 getElapsedTimeAndUpdate(U64& lastClockCount)
}
-LLUnit::Seconds<F64> LLTimer::getElapsedTimeF64() const
+LLUnit<LLUnits::Seconds, F64> LLTimer::getElapsedTimeF64() const
{
U64 last = mLastClockCount;
return (F64)getElapsedTimeAndUpdate(last) * gClockFrequencyInv;
}
-LLUnit::Seconds<F32> LLTimer::getElapsedTimeF32() const
+LLUnit<LLUnits::Seconds, F32> LLTimer::getElapsedTimeF32() const
{
return (F32)getElapsedTimeF64();
}
-LLUnit::Seconds<F64> LLTimer::getElapsedTimeAndResetF64()
+LLUnit<LLUnits::Seconds, F64> LLTimer::getElapsedTimeAndResetF64()
{
return (F64)getElapsedTimeAndUpdate(mLastClockCount) * gClockFrequencyInv;
}
-LLUnit::Seconds<F32> LLTimer::getElapsedTimeAndResetF32()
+LLUnit<LLUnits::Seconds, F32> LLTimer::getElapsedTimeAndResetF32()
{
return (F32)getElapsedTimeAndResetF64();
}
@@ -373,7 +372,7 @@ void LLTimer::setTimerExpirySec(F32 expiration)
+ (U64)((F32)(expiration * gClockFrequency));
}
-LLUnit::Seconds<F32> LLTimer::getRemainingTimeF32() const
+LLUnit<LLUnits::Seconds, F32> LLTimer::getRemainingTimeF32() const
{
U64 cur_ticks = get_clock_count();
if (cur_ticks > mExpirationTicks)
diff --git a/indra/llcommon/lltimer.h b/indra/llcommon/lltimer.h
index e0a880a346..5cb2b18111 100644
--- a/indra/llcommon/lltimer.h
+++ b/indra/llcommon/lltimer.h
@@ -67,16 +67,16 @@ public:
// Return a high precision number of seconds since the start of
// this application instance.
- static LLUnit::Seconds<F64> getElapsedSeconds()
+ static LLUnit<LLUnits::Seconds, F64> getElapsedSeconds()
{
return sTimer->getElapsedTimeF64();
}
// Return a high precision usec since epoch
- static LLUnit::Microseconds<U64> getTotalTime();
+ static LLUnit<LLUnits::Microseconds, U64> getTotalTime();
// Return a high precision seconds since epoch
- static LLUnit::Seconds<F64> getTotalSeconds();
+ static LLUnit<LLUnits::Seconds, F64> getTotalSeconds();
// MANIPULATORS
@@ -87,16 +87,16 @@ public:
void setTimerExpirySec(F32 expiration);
BOOL checkExpirationAndReset(F32 expiration);
BOOL hasExpired() const;
- LLUnit::Seconds<F32> getElapsedTimeAndResetF32(); // Returns elapsed time in seconds with reset
- LLUnit::Seconds<F64> getElapsedTimeAndResetF64();
+ LLUnit<LLUnits::Seconds, F32> getElapsedTimeAndResetF32(); // Returns elapsed time in seconds with reset
+ LLUnit<LLUnits::Seconds, F64> getElapsedTimeAndResetF64();
- LLUnit::Seconds<F32> getRemainingTimeF32() const;
+ LLUnit<LLUnits::Seconds, F32> getRemainingTimeF32() const;
static BOOL knownBadTimer();
// ACCESSORS
- LLUnit::Seconds<F32> getElapsedTimeF32() const; // Returns elapsed time in seconds
- LLUnit::Seconds<F64> getElapsedTimeF64() const; // Returns elapsed time in seconds
+ LLUnit<LLUnits::Seconds, F32> getElapsedTimeF32() const; // Returns elapsed time in seconds
+ LLUnit<LLUnits::Seconds, F64> getElapsedTimeF64() const; // Returns elapsed time in seconds
bool getStarted() const { return mStarted; }
diff --git a/indra/llcommon/lltrace.h b/indra/llcommon/lltrace.h
index e2530a8a24..d289ea9a88 100644
--- a/indra/llcommon/lltrace.h
+++ b/indra/llcommon/lltrace.h
@@ -38,37 +38,35 @@
#include <list>
-#define LL_TOKEN_PASTE_ACTUAL(x, y) x##y
-#define LL_TOKEN_PASTE(x, y) LL_TOKEN_PASTE_ACTUAL(x, y)
-#define LL_RECORD_BLOCK_TIME(block_timer) LLTrace::BlockTimer::Recorder LL_TOKEN_PASTE(block_time_recorder, __COUNTER__)(block_timer);
+#define LL_RECORD_BLOCK_TIME(block_timer) LLTrace::BlockTimer::Recorder LL_GLUE_TOKENS(block_time_recorder, __COUNTER__)(block_timer);
namespace LLTrace
{
class Recording;
- typedef LLUnit::Bytes<F64> Bytes;
- typedef LLUnit::Kilobytes<F64> Kilobytes;
- typedef LLUnit::Megabytes<F64> Megabytes;
- typedef LLUnit::Gigabytes<F64> Gigabytes;
- typedef LLUnit::Bits<F64> Bits;
- typedef LLUnit::Kilobits<F64> Kilobits;
- typedef LLUnit::Megabits<F64> Megabits;
- typedef LLUnit::Gigabits<F64> Gigabits;
-
- typedef LLUnit::Seconds<F64> Seconds;
- typedef LLUnit::Milliseconds<F64> Milliseconds;
- typedef LLUnit::Minutes<F64> Minutes;
- typedef LLUnit::Hours<F64> Hours;
- typedef LLUnit::Days<F64> Days;
- typedef LLUnit::Weeks<F64> Weeks;
- typedef LLUnit::Milliseconds<F64> Milliseconds;
- typedef LLUnit::Microseconds<F64> Microseconds;
- typedef LLUnit::Nanoseconds<F64> Nanoseconds;
-
- typedef LLUnit::Meters<F64> Meters;
- typedef LLUnit::Kilometers<F64> Kilometers;
- typedef LLUnit::Centimeters<F64> Centimeters;
- typedef LLUnit::Millimeters<F64> Millimeters;
+ typedef LLUnit<LLUnits::Bytes, F64> Bytes;
+ typedef LLUnit<LLUnits::Kilobytes, F64> Kilobytes;
+ typedef LLUnit<LLUnits::Megabytes, F64> Megabytes;
+ typedef LLUnit<LLUnits::Gigabytes, F64> Gigabytes;
+ typedef LLUnit<LLUnits::Bits, F64> Bits;
+ typedef LLUnit<LLUnits::Kilobits, F64> Kilobits;
+ typedef LLUnit<LLUnits::Megabits, F64> Megabits;
+ typedef LLUnit<LLUnits::Gigabits, F64> Gigabits;
+
+ typedef LLUnit<LLUnits::Seconds, F64> Seconds;
+ typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
+ typedef LLUnit<LLUnits::Minutes, F64> Minutes;
+ typedef LLUnit<LLUnits::Hours, F64> Hours;
+ typedef LLUnit<LLUnits::Days, F64> Days;
+ typedef LLUnit<LLUnits::Weeks, F64> Weeks;
+ typedef LLUnit<LLUnits::Milliseconds, F64> Milliseconds;
+ typedef LLUnit<LLUnits::Microseconds, F64> Microseconds;
+ typedef LLUnit<LLUnits::Nanoseconds, F64> Nanoseconds;
+
+ typedef LLUnit<LLUnits::Meters, F64> Meters;
+ typedef LLUnit<LLUnits::Kilometers, F64> Kilometers;
+ typedef LLUnit<LLUnits::Centimeters, F64> Centimeters;
+ typedef LLUnit<LLUnits::Millimeters, F64> Millimeters;
void init();
void cleanup();
@@ -438,7 +436,7 @@ namespace LLTrace
void sample(UNIT_T value)
{
T converted_value;
- converted_value.assignFrom(value);
+ converted_value = value;
getPrimaryAccumulator().sample((storage_t)converted_value.value());
}
};
@@ -478,7 +476,7 @@ namespace LLTrace
void add(UNIT_T value)
{
T converted_value;
- converted_value.assignFrom(value);
+ converted_value = value;
getPrimaryAccumulator().add((storage_t)converted_value.value());
}
};
diff --git a/indra/llcommon/lltracerecording.h b/indra/llcommon/lltracerecording.h
index fc96631ce0..ca9950b78d 100644
--- a/indra/llcommon/lltracerecording.h
+++ b/indra/llcommon/lltracerecording.h
@@ -197,7 +197,7 @@ namespace LLTrace
U32 getSampleCount(const TraceType<MeasurementAccumulator<F64> >& stat) const;
U32 getSampleCount(const TraceType<MeasurementAccumulator<S64> >& stat) const;
- LLUnit::Seconds<F64> getDuration() const { return mElapsedSeconds; }
+ LLUnit<LLUnits::Seconds, F64> getDuration() const { return mElapsedSeconds; }
private:
friend class ThreadRecorder;
diff --git a/indra/llcommon/llunit.h b/indra/llcommon/llunit.h
index 4519905707..0dcafbe26e 100644
--- a/indra/llcommon/llunit.h
+++ b/indra/llcommon/llunit.h
@@ -30,326 +30,288 @@
#include "stdtypes.h"
#include "llpreprocessor.h"
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT = BASE_UNIT>
-struct LLUnitType : public BASE_UNIT
+namespace LLUnits
{
- typedef DERIVED_UNIT unit_t;
-
- typedef typename STORAGE_TYPE storage_t;
- typedef void is_unit_tag_t;
-
- LLUnitType()
- {}
-
- LLUnitType(storage_t value)
- : BASE_UNIT(convertToBase(value))
- {}
-
- // implicit downcast
- operator unit_t& ()
- {
- return static_cast<unit_t&>(*this);
- }
-
- operator storage_t () const
- {
- return value();
- }
-
- storage_t value() const
- {
- return convertToDerived(mBaseValue);
- }
-
- template<typename CONVERTED_TYPE>
- storage_t as() const
- {
- return CONVERTED_TYPE(*this).value();
- }
-
-protected:
- static storage_t convertToBase(storage_t derived_value)
- {
- return (storage_t)((F32)derived_value * unit_t::conversionToBaseFactor());
- }
-
- static storage_t convertToDerived(storage_t base_value)
+template<typename DERIVED_UNITS_TAG, typename BASE_UNITS_TAG>
+struct ConversionFactor
+{
+ static F64 get()
{
- return (storage_t)((F32)base_value / unit_t::conversionToBaseFactor());
+ llstatic_assert(sizeof(DERIVED_UNITS_TAG) == 0, "Cannot convert between types.");
}
+};
+template<typename BASE_UNITS_TAG>
+struct ConversionFactor<BASE_UNITS_TAG, BASE_UNITS_TAG>
+{
+ static F64 get() { return 1.0; }
};
+}
-template<typename STORAGE_TYPE, typename T>
-struct LLUnitType<STORAGE_TYPE, T, T>
+template<typename UNIT_TYPE, typename STORAGE_TYPE>
+struct LLUnit
{
- typedef T unit_t;
- typedef STORAGE_TYPE storage_t;
+ typedef LLUnit<UNIT_TYPE, STORAGE_TYPE> self_t;
+ typedef typename STORAGE_TYPE storage_t;
typedef void is_unit_tag_t;
- LLUnitType()
- : mBaseValue()
+ LLUnit(storage_t value = storage_t())
+ : mValue(value)
{}
- LLUnitType(storage_t value)
- : mBaseValue(value)
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ LLUnit(LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
+ : mValue(convert(other))
{}
- unit_t& operator=(storage_t value)
+ LLUnit(self_t& other)
+ : mValue(other.mValue)
+ {}
+
+ self_t& operator = (storage_t value)
{
- setBaseValue(value);
+ mValue = value;
return *this;
}
- //implicit downcast
- operator unit_t& ()
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ self_t& operator = (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
- return static_cast<unit_t&>(*this);
+ mValue = convert(other);
+ return *this;
}
- operator storage_t () const
+ operator storage_t() const
{
return value();
}
- storage_t value() const { return mBaseValue; }
-
- template<typename CONVERTED_TYPE>
- storage_t as() const
+ storage_t value() const
{
- return CONVERTED_TYPE(*this).value();
+ return mValue;
}
- static storage_t convertToBase(storage_t derived_value)
+ void operator += (storage_t value)
{
- return (storage_t)derived_value;
+ mValue += value;
}
- static storage_t convertToDerived(storage_t base_value)
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ void operator += (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
- return (storage_t)base_value;
+ mValue += convert(other);
}
- void operator += (const unit_t other)
+ void operator -= (storage_t value)
{
- mBaseValue += other.mBaseValue;
+ mValue -= value;
}
- void operator -= (const unit_t other)
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ void operator -= (LLUnit<OTHER_UNIT, OTHER_STORAGE> other)
{
- mBaseValue -= other.mBaseValue;
+ mValue -= convert(other);
}
void operator *= (storage_t multiplicand)
{
- mBaseValue *= multiplicand;
+ mValue *= multiplicand;
+ }
+
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ void operator *= (LLUnit<OTHER_UNIT, OTHER_STORAGE> multiplicand)
+ {
+ llstatic_assert(sizeof(OTHER_UNIT) == false, "Multiplication of unit types not supported.");
}
void operator /= (storage_t divisor)
{
- mBaseValue /= divisor;
+ mValue /= divisor;
}
-protected:
- void setBaseValue(storage_t value)
+ template<typename OTHER_UNIT, typename OTHER_STORAGE>
+ void operator /= (LLUnit<OTHER_UNIT, OTHER_STORAGE> divisor)
{
- mBaseValue = value;
+ llstatic_assert(sizeof(OTHER_UNIT) == false, "Division of unit types not supported.");
}
- storage_t mBaseValue;
-};
+ template<typename SOURCE_UNITS, typename SOURCE_VALUE>
+ static storage_t convert(LLUnit<SOURCE_UNITS, SOURCE_VALUE> v)
+ {
+ return (storage_t)(v.value()
+ * LLUnits::ConversionFactor<SOURCE_UNITS, typename UNIT_TYPE::base_unit_t>::get()
+ * LLUnits::ConversionFactor<typename UNIT_TYPE::base_unit_t, UNIT_TYPE>::get());
+ }
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-struct LLUnitTypeWrapper
-: public LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>
-{
- typedef LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> unit_t;
- LLUnitTypeWrapper(const unit_t& other)
- : unit_t(other)
- {}
-};
+protected:
+ storage_t mValue;
+};
//
// operator +
//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
-DERIVED_UNIT operator + (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE2, BASE_UNIT2, DERIVED_UNIT2> second)
+template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
+LLUnit<STORAGE_TYPE1, UNIT_TYPE1> operator + (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second)
{
- return DERIVED_UNIT(first + LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>(second).value());
+ LLUnit<STORAGE_TYPE1, UNIT_TYPE1> result(first);
+ result += second;
+ return result;
}
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator + (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
+{
+ LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
+ result += second;
+ return result;
+}
-//
-// operator -
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
-DERIVED_UNIT operator - (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator + (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
- return DERIVED_UNIT(first - LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>(second).value());
+ LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
+ result += second;
+ return result;
}
//
-// operator *
+// operator -
//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-DERIVED_UNIT operator * (STORAGE_TYPE first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
+LLUnit<STORAGE_TYPE1, UNIT_TYPE1> operator - (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second)
{
- return DERIVED_UNIT(first * second.value());
+ LLUnit<STORAGE_TYPE1, UNIT_TYPE1> result(first);
+ result -= second;
+ return result;
}
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-DERIVED_UNIT operator * (LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> first, STORAGE_TYPE second)
+
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator - (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
- return DERIVED_UNIT(first.value() * second);
+ LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
+ result -= second;
+ return result;
}
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator - (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
+{
+ LLUnit<STORAGE_TYPE, UNIT_TYPE> result(first);
+ result -= second;
+ return result;
+}
//
-// operator /
+// operator *
//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-DERIVED_UNIT operator / (STORAGE_TYPE first, LLUnitTypeWrapper<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator * (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
- return DERIVED_UNIT(first / second.value());
+ return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first * second.value());
}
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-DERIVED_UNIT operator / (LLUnitTypeWrapper<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> first, STORAGE_TYPE second)
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator * (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
- return DERIVED_UNIT(first.value() / second);
+ return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first.value() * second);
}
-//
-// operator <
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT, typename STORAGE_TYPE2, typename BASE_UNIT2, typename DERIVED_UNIT2>
-
-bool operator < (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
+void operator * (LLUnit<STORAGE_TYPE1, UNIT_TYPE1>, LLUnit<STORAGE_TYPE2, UNIT_TYPE2>)
{
- return first < second.value();
+ llstatic_assert(sizeof(STORAGE_TYPE1) == false, "Multiplication of unit types results in new unit type - not supported.");
}
//
-// operator <=
+// operator /
//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-bool operator <= (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+SCALAR_TYPE operator / (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second)
{
- return first <= second.value();
+ return SCALAR_TYPE(first / second.value());
}
-
-//
-// operator >
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-bool operator > (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE>
+LLUnit<STORAGE_TYPE, UNIT_TYPE> operator / (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second)
{
- return first > second.value();
+ return LLUnit<STORAGE_TYPE, UNIT_TYPE>(first.value() / second);
}
-//
-// operator >=
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-bool operator >= (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2>
+void operator / (LLUnit<STORAGE_TYPE1, UNIT_TYPE1>, LLUnit<STORAGE_TYPE2, UNIT_TYPE2>)
{
- return first >= second.value();
+ llstatic_assert(sizeof(STORAGE_TYPE1) == false, "Multiplication of unit types results in new unit type - not supported.");
}
-//
-// operator ==
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-bool operator == (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
-{
- return first == second.value();
+#define COMPARISON_OPERATORS(op) \
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE> \
+bool operator op (SCALAR_TYPE first, LLUnit<STORAGE_TYPE, UNIT_TYPE> second) \
+{ \
+ return first op second.value(); \
+} \
+ \
+template<typename STORAGE_TYPE, typename UNIT_TYPE, typename SCALAR_TYPE> \
+bool operator op (LLUnit<STORAGE_TYPE, UNIT_TYPE> first, SCALAR_TYPE second) \
+{ \
+ return first.value() op second; \
+} \
+ \
+template<typename STORAGE_TYPE1, typename UNIT_TYPE1, typename STORAGE_TYPE2, typename UNIT_TYPE2> \
+bool operator op (LLUnit<STORAGE_TYPE1, UNIT_TYPE1> first, LLUnit<STORAGE_TYPE2, UNIT_TYPE2> second) \
+{ \
+ return first.value() op first.convert(second); \
}
-//
-// operator !=
-//
-template<typename STORAGE_TYPE, typename BASE_UNIT, typename DERIVED_UNIT>
-bool operator != (typename LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT>::storage_t first, LLUnitType<STORAGE_TYPE, BASE_UNIT, DERIVED_UNIT> second)
+COMPARISON_OPERATORS(<)
+COMPARISON_OPERATORS(<=)
+COMPARISON_OPERATORS(>)
+COMPARISON_OPERATORS(>=)
+COMPARISON_OPERATORS(==)
+COMPARISON_OPERATORS(!=)
+
+namespace LLUnits
{
- return first != second.value();
+#define LL_DECLARE_DERIVED_UNIT(base_unit_name, unit_name, conversion_factor)\
+struct unit_name \
+{ \
+ typedef base_unit_name base_unit_t; \
+}; \
+template<> \
+struct ConversionFactor<unit_name, base_unit_name> \
+{ \
+ static F64 get() { return (conversion_factor); } \
+}; \
+ \
+template<> \
+struct ConversionFactor<base_unit_name, unit_name> \
+{ \
+ static F64 get() { return 1.0 / (conversion_factor); } \
}
-#define LL_DECLARE_BASE_UNIT(unit_name) \
- template<typename STORAGE> \
- struct unit_name : public LLUnitType<STORAGE, unit_name<STORAGE>, unit_name<STORAGE> > \
- { \
- typedef LLUnitType<STORAGE, unit_name> unit_t; \
- \
- unit_name(storage_t value = 0) \
- : LLUnitType(value) \
- {} \
- \
- template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
- unit_name(LLUnitType<SOURCE_STORAGE_TYPE, unit_name<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
- { \
- assignFrom(source); \
- } \
- \
- template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
- void assignFrom(LLUnitType<SOURCE_STORAGE_TYPE, unit_name<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
- { \
- setBaseValue((storage_t)source.unit_name<SOURCE_STORAGE_TYPE>::unit_t::value()); \
- } \
- \
- }; \
-
-#define LL_DECLARE_DERIVED_UNIT(base_unit, derived_unit, conversion_factor) \
- template<typename STORAGE> \
- struct derived_unit : public LLUnitType<STORAGE, base_unit<STORAGE>, derived_unit<STORAGE> > \
- { \
- typedef LLUnitType<STORAGE, base_unit<STORAGE>, derived_unit<STORAGE> > unit_t; \
- \
- derived_unit(storage_t value = 0) \
- : LLUnitType(value) \
- {} \
- \
- template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
- derived_unit(LLUnitType<SOURCE_STORAGE_TYPE, base_unit<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
- { \
- assignFrom(source); \
- } \
- \
- template <typename SOURCE_STORAGE_TYPE, typename SOURCE_TYPE> \
- void assignFrom(LLUnitType<SOURCE_STORAGE_TYPE, base_unit<SOURCE_STORAGE_TYPE>, SOURCE_TYPE> source) \
- { \
- setBaseValue((storage_t)source.base_unit<SOURCE_STORAGE_TYPE>::unit_t::value()); \
- } \
- \
- static F32 conversionToBaseFactor() { return (F32)(conversion_factor); } \
- \
- }; \
-
-namespace LLUnit
-{
- LL_DECLARE_BASE_UNIT(Bytes);
- LL_DECLARE_DERIVED_UNIT(Bytes, Kilobytes, 1024);
- LL_DECLARE_DERIVED_UNIT(Bytes, Megabytes, 1024 * 1024);
- LL_DECLARE_DERIVED_UNIT(Bytes, Gigabytes, 1024 * 1024 * 1024);
- LL_DECLARE_DERIVED_UNIT(Bytes, Bits, (1.f / 8.f));
- LL_DECLARE_DERIVED_UNIT(Bytes, Kilobits, (1024 / 8));
- LL_DECLARE_DERIVED_UNIT(Bytes, Megabits, (1024 / 8));
- LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits, (1024 * 1024 * 1024 / 8));
-
- LL_DECLARE_BASE_UNIT(Seconds);
- LL_DECLARE_DERIVED_UNIT(Seconds, Minutes, 60);
- LL_DECLARE_DERIVED_UNIT(Seconds, Hours, 60 * 60);
- LL_DECLARE_DERIVED_UNIT(Seconds, Days, 60 * 60 * 24);
- LL_DECLARE_DERIVED_UNIT(Seconds, Weeks, 60 * 60 * 24 * 7);
- LL_DECLARE_DERIVED_UNIT(Seconds, Milliseconds, (1.f / 1000.f));
- LL_DECLARE_DERIVED_UNIT(Seconds, Microseconds, (1.f / (1000000.f)));
- LL_DECLARE_DERIVED_UNIT(Seconds, Nanoseconds, (1.f / (1000000000.f)));
-
- LL_DECLARE_BASE_UNIT(Meters);
- LL_DECLARE_DERIVED_UNIT(Meters, Kilometers, 1000);
- LL_DECLARE_DERIVED_UNIT(Meters, Centimeters, 1 / 100);
- LL_DECLARE_DERIVED_UNIT(Meters, Millimeters, 1 / 1000);
+struct Bytes { typedef Bytes base_unit_t; };
+LL_DECLARE_DERIVED_UNIT(Bytes, Kilobytes, 1024);
+LL_DECLARE_DERIVED_UNIT(Bytes, Megabytes, 1024 * 1024);
+LL_DECLARE_DERIVED_UNIT(Bytes, Gigabytes, 1024 * 1024 * 1024);
+LL_DECLARE_DERIVED_UNIT(Bytes, Bits, (1.0 / 8.0));
+LL_DECLARE_DERIVED_UNIT(Bytes, Kilobits, (1024 / 8));
+LL_DECLARE_DERIVED_UNIT(Bytes, Megabits, (1024 / 8));
+LL_DECLARE_DERIVED_UNIT(Bytes, Gigabits, (1024 * 1024 * 1024 / 8));
+
+struct Seconds { typedef Seconds base_unit_t; };
+LL_DECLARE_DERIVED_UNIT(Seconds, Minutes, 60);
+LL_DECLARE_DERIVED_UNIT(Seconds, Hours, 60 * 60);
+LL_DECLARE_DERIVED_UNIT(Seconds, Days, 60 * 60 * 24);
+LL_DECLARE_DERIVED_UNIT(Seconds, Weeks, 60 * 60 * 24 * 7);
+LL_DECLARE_DERIVED_UNIT(Seconds, Milliseconds, (1.0 / 1000.0));
+LL_DECLARE_DERIVED_UNIT(Seconds, Microseconds, (1.0 / (1000000.0)));
+LL_DECLARE_DERIVED_UNIT(Seconds, Nanoseconds, (1.0 / (1000000000.0)));
+
+struct Meters { typedef Meters base_unit_t; };
+LL_DECLARE_DERIVED_UNIT(Meters, Kilometers, 1000);
+LL_DECLARE_DERIVED_UNIT(Meters, Centimeters, (1.0 / 100));
+LL_DECLARE_DERIVED_UNIT(Meters, Millimeters, (1.0 / 1000));
}
#endif // LL_LLUNIT_H
diff --git a/indra/llmath/v4color.h b/indra/llmath/v4color.h
index 78223e1e65..0d632f59be 100644
--- a/indra/llmath/v4color.h
+++ b/indra/llmath/v4color.h
@@ -49,10 +49,10 @@ class LLColor4
LLColor4(); // Initializes LLColor4 to (0, 0, 0, 1)
LLColor4(F32 r, F32 g, F32 b); // Initializes LLColor4 to (r, g, b, 1)
LLColor4(F32 r, F32 g, F32 b, F32 a); // Initializes LLColor4 to (r. g, b, a)
- explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
- explicit LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
- explicit LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
+ LLColor4(const LLColor3 &vec, F32 a = 1.f); // Initializes LLColor4 to (vec, a)
explicit LLColor4(const LLSD& sd);
+ explicit LLColor4(const F32 *vec); // Initializes LLColor4 to (vec[0]. vec[1], vec[2], 1)
+ explicit LLColor4(U32 clr); // Initializes LLColor4 to (r=clr>>24, etc))
explicit LLColor4(const LLColor4U& color4u); // "explicit" to avoid automatic conversion
explicit LLColor4(const LLVector4& vector4); // "explicit" to avoid automatic conversion
diff --git a/indra/llrender/llimagegl.cpp b/indra/llrender/llimagegl.cpp
index fc1edbe664..5361d8e7be 100755
--- a/indra/llrender/llimagegl.cpp
+++ b/indra/llrender/llimagegl.cpp
@@ -50,9 +50,9 @@ U32 wpo2(U32 i);
U32 LLImageGL::sUniqueCount = 0;
U32 LLImageGL::sBindCount = 0;
-LLUnit::Bytes<S32> LLImageGL::sGlobalTextureMemory = 0;
-LLUnit::Bytes<S32> LLImageGL::sBoundTextureMemory = 0;
-LLUnit::Bytes<S32> LLImageGL::sCurBoundTextureMemory = 0;
+LLUnit<LLUnits::Bytes, S32> LLImageGL::sGlobalTextureMemory = 0;
+LLUnit<LLUnits::Bytes, S32> LLImageGL::sBoundTextureMemory = 0;
+LLUnit<LLUnits::Bytes, S32> LLImageGL::sCurBoundTextureMemory = 0;
S32 LLImageGL::sCount = 0;
LLImageGL::dead_texturelist_t LLImageGL::sDeadTextureList[LLTexUnit::TT_NONE];
U32 LLImageGL::sCurTexName = 1;
diff --git a/indra/llrender/llimagegl.h b/indra/llrender/llimagegl.h
index dfa59f2a34..11555e20c4 100755
--- a/indra/llrender/llimagegl.h
+++ b/indra/llrender/llimagegl.h
@@ -246,9 +246,9 @@ public:
static F32 sLastFrameTime;
// Global memory statistics
- static LLUnit::Bytes<S32> sGlobalTextureMemory; // Tracks main memory texmem
- static LLUnit::Bytes<S32> sBoundTextureMemory; // Tracks bound texmem for last completed frame
- static LLUnit::Bytes<S32> sCurBoundTextureMemory; // Tracks bound texmem for current frame
+ static LLUnit<LLUnits::Bytes, S32> sGlobalTextureMemory; // Tracks main memory texmem
+ static LLUnit<LLUnits::Bytes, S32> sBoundTextureMemory; // Tracks bound texmem for last completed frame
+ static LLUnit<LLUnits::Bytes, S32> sCurBoundTextureMemory; // Tracks bound texmem for current frame
static U32 sBindCount; // Tracks number of texture binds for current frame
static U32 sUniqueCount; // Tracks number of unique texture binds for current frame
static BOOL sGlobalUseAnisotropic;
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index 838a982cb4..ac659c409b 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -277,7 +277,7 @@ LLPumpIO* gServicePump = NULL;
U64 gFrameTime = 0;
F32 gFrameTimeSeconds = 0.f;
-LLUnit::Seconds<F32> gFrameIntervalSeconds = 0.f;
+LLUnit<LLUnits::Seconds, F32> gFrameIntervalSeconds = 0.f;
F32 gFPSClamped = 10.f; // Pretend we start at target rate.
F32 gFrameDTClamped = 0.f; // Time between adjacent checks to network for packets
U64 gStartTime = 0; // gStartTime is "private", used only to calculate gFrameTimeSeconds
diff --git a/indra/newview/llappviewer.h b/indra/newview/llappviewer.h
index d9d888c626..f2bea7cdb2 100644
--- a/indra/newview/llappviewer.h
+++ b/indra/newview/llappviewer.h
@@ -322,7 +322,7 @@ extern LLPumpIO* gServicePump;
extern U64 gFrameTime; // The timestamp of the most-recently-processed frame
extern F32 gFrameTimeSeconds; // Loses msec precision after ~4.5 hours...
-extern LLUnit::Seconds<F32> gFrameIntervalSeconds; // Elapsed time between current and previous gFrameTimeSeconds
+extern LLUnit<LLUnits::Seconds, F32> gFrameIntervalSeconds; // Elapsed time between current and previous gFrameTimeSeconds
extern F32 gFPSClamped; // Frames per second, smoothed, weighted toward last frame
extern F32 gFrameDTClamped;
extern U64 gStartTime;
diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index 4f6eaa5a5b..61f5ecc46f 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -463,7 +463,7 @@ void LLDrawPoolWater::renderReflection(LLFace* face)
gGL.getTexUnit(0)->bind(mHBTex[dr]);
- LLOverrideFaceColor override(this, face->getFaceColor().mV);
+ LLOverrideFaceColor override(this, LLColor4(face->getFaceColor().mV));
face->renderIndexed();
}
diff --git a/indra/newview/lltextureview.cpp b/indra/newview/lltextureview.cpp
index d734620f10..288c1233e5 100755
--- a/indra/newview/lltextureview.cpp
+++ b/indra/newview/lltextureview.cpp
@@ -503,17 +503,17 @@ private:
void LLGLTexMemBar::draw()
{
- LLUnit::Megabytes<S32> bound_mem = LLViewerTexture::sBoundTextureMemory;
- LLUnit::Megabytes<S32> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
- LLUnit::Megabytes<S32> total_mem = LLViewerTexture::sTotalTextureMemory;
- LLUnit::Megabytes<S32> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
+ LLUnit<LLUnits::Megabytes, S32> bound_mem = LLViewerTexture::sBoundTextureMemory;
+ LLUnit<LLUnits::Megabytes, S32> max_bound_mem = LLViewerTexture::sMaxBoundTextureMem;
+ LLUnit<LLUnits::Megabytes, S32> total_mem = LLViewerTexture::sTotalTextureMemory;
+ LLUnit<LLUnits::Megabytes, S32> max_total_mem = LLViewerTexture::sMaxTotalTextureMem;
F32 discard_bias = LLViewerTexture::sDesiredDiscardBias;
F32 cache_usage = (F32)LLTrace::Megabytes(LLAppViewer::getTextureCache()->getUsage()).value() ;
F32 cache_max_usage = (F32)LLTrace::Megabytes(LLAppViewer::getTextureCache()->getMaxUsage()).value() ;
S32 line_height = LLFontGL::getFontMonospace()->getLineHeight();
S32 v_offset = 0;//(S32)((texture_bar_height + 2.2f) * mTextureView->mNumTextureBars + 2.0f);
- LLUnit::Megabytes<F32> total_texture_downloaded = gTotalTextureData;
- LLUnit::Megabytes<F32> total_object_downloaded = gTotalObjectData;
+ LLUnit<LLUnits::Megabytes, F32> total_texture_downloaded = gTotalTextureData;
+ LLUnit<LLUnits::Megabytes, F32> total_object_downloaded = gTotalObjectData;
U32 total_http_requests = LLAppViewer::getTextureFetch()->getCurlRequest().getTotalIssuedRequests() ;
//----------------------------------------------------------------------------
LLGLSUIDefault gls_ui;
@@ -661,7 +661,7 @@ void LLGLTexSizeBar::draw()
if(LLImageGL::sCurTexSizeBar == mIndex)
{
- F32 text_color[] = {1.f, 1.f, 1.f, 0.75f};
+ LLColor4 text_color(1.f, 1.f, 1.f, 0.75f);
std::string text;
text = llformat("%d", mTopLoaded) ;
@@ -673,8 +673,8 @@ void LLGLTexSizeBar::draw()
text_color, LLFontGL::LEFT, LLFontGL::TOP);
}
- F32 loaded_color[] = {1.0f, 0.0f, 0.0f, 0.75f};
- F32 bound_color[] = {1.0f, 1.0f, 0.0f, 0.75f};
+ LLColor4 loaded_color(1.0f, 0.0f, 0.0f, 0.75f);
+ LLColor4 bound_color(1.0f, 1.0f, 0.0f, 0.75f);
gl_rect_2d(mLeft, mBottom + (S32)(mTopLoaded * mScale), (mLeft + mRight) / 2, mBottom, loaded_color) ;
gl_rect_2d((mLeft + mRight) / 2, mBottom + (S32)(mTopBound * mScale), mRight, mBottom, bound_color) ;
}
diff --git a/indra/newview/llviewerassetstats.cpp b/indra/newview/llviewerassetstats.cpp
index bad2f5b4cd..73a2e24424 100755
--- a/indra/newview/llviewerassetstats.cpp
+++ b/indra/newview/llviewerassetstats.cpp
@@ -430,10 +430,10 @@ void LLViewerAssetStats::getStats(AssetStats& stats, bool compact_output)
grid_from_region_handle(it->first, &grid_x, &grid_y);
r.grid_x(grid_x);
r.grid_y(grid_y);
- r.duration(LLUnit::Microseconds<F64>(rec.getDuration()).value());
+ r.duration(LLUnit<LLUnits::Microseconds, F64>(rec.getDuration()).value());
}
- stats.duration(mCurRecording ? LLUnit::Microseconds<F64>(mCurRecording->getDuration()).value() : 0.0);
+ stats.duration(mCurRecording ? LLUnit<LLUnits::Microseconds, F64>(mCurRecording->getDuration()).value() : 0.0);
stats.avatar.setProvided(true);
for (S32 rez_stat=0; rez_stat < mAvatarRezStates.size(); ++rez_stat)
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index acbe836c29..197d91593c 100755
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -2587,7 +2587,7 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
LLSD args;
args["SUBJECT"] = subj;
args["MESSAGE"] = mes;
- LLNotifications::instance().add(LLNotification::Params("GroupNotice").substitutions(args).payload(payload).time_stamp(timestamp));
+ LLNotifications::instance().add(LLNotification::Params("GroupNotice").substitutions(args).payload(payload).time_stamp(LLDate(timestamp)));
}
// Also send down the old path for now.
@@ -4416,18 +4416,18 @@ void send_agent_update(BOOL force_send, BOOL send_reliable)
// *TODO: Remove this dependency, or figure out a better way to handle
// this hack.
-extern LLUnit::Bits<U32> gObjectData;
+extern LLUnit<LLUnits::Bits, U32> gObjectData;
void process_object_update(LLMessageSystem *mesgsys, void **user_data)
{
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@@ -4439,11 +4439,11 @@ void process_compressed_object_update(LLMessageSystem *mesgsys, void **user_data
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@@ -4455,11 +4455,11 @@ void process_cached_object_update(LLMessageSystem *mesgsys, void **user_data)
// Update the data counters
if (mesgsys->getReceiveCompressedSize())
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
// Update the object...
@@ -4471,11 +4471,11 @@ void process_terse_object_update_improved(LLMessageSystem *mesgsys, void **user_
{
if (mesgsys->getReceiveCompressedSize())
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveCompressedSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveCompressedSize();
}
else
{
- gObjectData += (LLUnit::Bytes<U32>)mesgsys->getReceiveSize();
+ gObjectData += (LLUnit<LLUnits::Bytes, U32>)mesgsys->getReceiveSize();
}
gObjectList.processCompressedObjectUpdate(mesgsys, user_data, OUT_TERSE_IMPROVED);
diff --git a/indra/newview/llviewerstats.cpp b/indra/newview/llviewerstats.cpp
index 317fe5eaf8..36b1179e04 100755
--- a/indra/newview/llviewerstats.cpp
+++ b/indra/newview/llviewerstats.cpp
@@ -288,13 +288,13 @@ F32 gAveLandCompression = 0.f,
gWorstLandCompression = 0.f,
gWorstWaterCompression = 0.f;
-LLUnit::Bytes<U32> gTotalWorldData = 0,
+LLUnit<LLUnits::Bytes, U32> gTotalWorldData = 0,
gTotalObjectData = 0,
gTotalTextureData = 0;
U32 gSimPingCount = 0;
-LLUnit::Bits<U32> gObjectData = 0;
+LLUnit<LLUnits::Bits, U32> gObjectData = 0;
F32 gAvgSimPing = 0.f;
-LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
+LLUnit<LLUnits::Bytes, U32> gTotalTextureBytesPerBoostLevel[LLViewerTexture::MAX_GL_IMAGE_CATEGORY] = {0};
extern U32 gVisCompared;
extern U32 gVisTested;
diff --git a/indra/newview/llviewerstats.h b/indra/newview/llviewerstats.h
index eda7b3329d..14ee41dba0 100755
--- a/indra/newview/llviewerstats.h
+++ b/indra/newview/llviewerstats.h
@@ -319,7 +319,7 @@ void update_statistics();
void send_stats();
extern LLFrameTimer gTextureTimer;
-extern LLUnit::Bytes<U32> gTotalTextureData;
-extern LLUnit::Bytes<U32> gTotalObjectData;
-extern LLUnit::Bytes<U32> gTotalTextureBytesPerBoostLevel[] ;
+extern LLUnit<LLUnits::Bytes, U32> gTotalTextureData;
+extern LLUnit<LLUnits::Bytes, U32> gTotalObjectData;
+extern LLUnit<LLUnits::Bytes, U32> gTotalTextureBytesPerBoostLevel[] ;
#endif // LL_LLVIEWERSTATS_H
diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index ceb8d3155c..f4e8e3eae1 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -65,8 +65,8 @@
///////////////////////////////////////////////////////////////////////////////
// extern
-const LLUnit::Megabytes<S32> gMinVideoRam = 32;
-const LLUnit::Megabytes<S32> gMaxVideoRam = 512;
+const LLUnit<LLUnits::Megabytes, S32> gMinVideoRam = 32;
+const LLUnit<LLUnits::Megabytes, S32> gMaxVideoRam = 512;
// statics
@@ -87,11 +87,11 @@ S32 LLViewerTexture::sAuxCount = 0;
LLFrameTimer LLViewerTexture::sEvaluationTimer;
F32 LLViewerTexture::sDesiredDiscardBias = 0.f;
F32 LLViewerTexture::sDesiredDiscardScale = 1.1f;
-LLUnit::Bytes<S32> LLViewerTexture::sBoundTextureMemory = 0;
-LLUnit::Bytes<S32> LLViewerTexture::sTotalTextureMemory = 0;
-LLUnit::Megabytes<S32> LLViewerTexture::sMaxBoundTextureMem = 0;
-LLUnit::Megabytes<S32> LLViewerTexture::sMaxTotalTextureMem = 0;
-LLUnit::Bytes<S32> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
+LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sBoundTextureMemory = 0;
+LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sTotalTextureMemory = 0;
+LLUnit<LLUnits::Megabytes, S32> LLViewerTexture::sMaxBoundTextureMem = 0;
+LLUnit<LLUnits::Megabytes, S32> LLViewerTexture::sMaxTotalTextureMem = 0;
+LLUnit<LLUnits::Bytes, S32> LLViewerTexture::sMaxDesiredTextureMem = 0 ;
S8 LLViewerTexture::sCameraMovingDiscardBias = 0 ;
F32 LLViewerTexture::sCameraMovingBias = 0.0f ;
S32 LLViewerTexture::sMaxSculptRez = 128 ; //max sculpt image size
@@ -532,8 +532,8 @@ void LLViewerTexture::updateClass(const F32 velocity, const F32 angular_velocity
if (sBoundTextureMemory >= sMaxBoundTextureMem ||
sTotalTextureMemory >= sMaxTotalTextureMem)
{
- //when texture memory overflows, lower down the threashold to release the textures more aggressively.
- sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit::Bytes<S32>(gMaxVideoRam));
+ //when texture memory overflows, lower down the threshold to release the textures more aggressively.
+ sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, LLUnit<LLUnits::Bytes, S32>(gMaxVideoRam));
// If we are using more texture memory than we should,
// scale up the desired discard level
diff --git a/indra/newview/llviewertexture.h b/indra/newview/llviewertexture.h
index aa1e2010b4..e9efb751f8 100755
--- a/indra/newview/llviewertexture.h
+++ b/indra/newview/llviewertexture.h
@@ -39,8 +39,8 @@
#include <map>
#include <list>
-extern const LLUnit::Megabytes<S32> gMinVideoRam;
-extern const LLUnit::Megabytes<S32> gMaxVideoRam;
+extern const LLUnit<LLUnits::Megabytes, S32> gMinVideoRam;
+extern const LLUnit<LLUnits::Megabytes, S32> gMaxVideoRam;
class LLFace;
class LLImageGL ;
@@ -323,11 +323,11 @@ public:
static LLFrameTimer sEvaluationTimer;
static F32 sDesiredDiscardBias;
static F32 sDesiredDiscardScale;
- static LLUnit::Bytes<S32> sBoundTextureMemory;
- static LLUnit::Bytes<S32> sTotalTextureMemory;
- static LLUnit::Megabytes<S32> sMaxBoundTextureMem;
- static LLUnit::Megabytes<S32> sMaxTotalTextureMem;
- static LLUnit::Bytes<S32> sMaxDesiredTextureMem ;
+ static LLUnit<LLUnits::Bytes, S32> sBoundTextureMemory;
+ static LLUnit<LLUnits::Bytes, S32> sTotalTextureMemory;
+ static LLUnit<LLUnits::Megabytes, S32> sMaxBoundTextureMem;
+ static LLUnit<LLUnits::Megabytes, S32> sMaxTotalTextureMem;
+ static LLUnit<LLUnits::Bytes, S32> sMaxDesiredTextureMem ;
static S8 sCameraMovingDiscardBias;
static F32 sCameraMovingBias;
static S32 sMaxSculptRez ;
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index b7415669bb..8e72ca1d74 100755
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -733,7 +733,7 @@ public:
{
if(gTotalTextureBytesPerBoostLevel[i] > 0)
{
- addText(xpos, ypos, llformat("Boost_Level %d: %.3f MB", i, LLUnit::Megabytes<F32>(gTotalTextureBytesPerBoostLevel[i]).value()));
+ addText(xpos, ypos, llformat("Boost_Level %d: %.3f MB", i, LLUnit<LLUnits::Megabytes, F32>(gTotalTextureBytesPerBoostLevel[i]).value()));
ypos += y_inc;
}
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 15:29:06 +0000