summaryrefslogtreecommitdiff
path: root/indra/llcommon
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llcommon')
-rw-r--r--indra/llcommon/llcriticaldamp.cpp51
-rw-r--r--indra/llcommon/llcriticaldamp.h82
-rw-r--r--indra/llcommon/llmemory.h78
-rw-r--r--indra/llcommon/llstaticstringtable.h2
4 files changed, 103 insertions, 110 deletions
diff --git a/indra/llcommon/llcriticaldamp.cpp b/indra/llcommon/llcriticaldamp.cpp
index 87d79b1ee0..27fef0e6dc 100644
--- a/indra/llcommon/llcriticaldamp.cpp
+++ b/indra/llcommon/llcriticaldamp.cpp
@@ -32,8 +32,9 @@
// static members
//-----------------------------------------------------------------------------
LLFrameTimer LLCriticalDamp::sInternalTimer;
-std::map<F32, F32> LLCriticalDamp::sInterpolants;
F32 LLCriticalDamp::sTimeDelta;
+F32 LLCriticalDamp::sInterpolants[kNumCachedInterpolants];
+F32 LLCriticalDamp::sInterpolatedValues[kNumCachedInterpolants];
//-----------------------------------------------------------------------------
// LLCriticalDamp()
@@ -41,6 +42,17 @@ F32 LLCriticalDamp::sTimeDelta;
LLCriticalDamp::LLCriticalDamp()
{
sTimeDelta = 0.f;
+
+ // Init the core interpolant values (to which many, many enums map)
+ //
+ setInterpolantConstant(InterpDelta_0_025, 0.025f);
+ setInterpolantConstant(InterpDelta_0_05, 0.05f );
+ setInterpolantConstant(InterpDelta_0_06, 0.06f);
+ setInterpolantConstant(InterpDelta_0_10, 0.10f);
+ setInterpolantConstant(InterpDelta_0_15, 0.15f);
+ setInterpolantConstant(InterpDelta_0_20, 0.20f);
+ setInterpolantConstant(InterpDelta_0_25, 0.25f);
+ setInterpolantConstant(InterpDelta_0_30, 0.30f);
}
// static
@@ -51,39 +63,10 @@ void LLCriticalDamp::updateInterpolants()
{
sTimeDelta = sInternalTimer.getElapsedTimeAndResetF32();
- F32 time_constant;
-
- for (std::map<F32, F32>::iterator iter = sInterpolants.begin();
- iter != sInterpolants.end(); iter++)
- {
- time_constant = iter->first;
- F32 new_interpolant = 1.f - pow(2.f, -sTimeDelta / time_constant);
- new_interpolant = llclamp(new_interpolant, 0.f, 1.f);
- sInterpolants[time_constant] = new_interpolant;
- }
-}
-
-//-----------------------------------------------------------------------------
-// getInterpolant()
-//-----------------------------------------------------------------------------
-F32 LLCriticalDamp::getInterpolant(const F32 time_constant, BOOL use_cache)
-{
- if (time_constant == 0.f)
+ U32 i;
+ for (i = 0; i < kNumCachedInterpolants; i++)
{
- return 1.f;
+ sInterpolatedValues[i] = llclamp(sTimeDelta / sInterpolants[ i], 0.0f, 1.0f);
}
-
- if (use_cache && sInterpolants.count(time_constant))
- {
- return sInterpolants[time_constant];
- }
-
- F32 interpolant = 1.f - pow(2.f, -sTimeDelta / time_constant);
- interpolant = llclamp(interpolant, 0.f, 1.f);
- if (use_cache)
- {
- sInterpolants[time_constant] = interpolant;
- }
-
- return interpolant;
}
+
diff --git a/indra/llcommon/llcriticaldamp.h b/indra/llcommon/llcriticaldamp.h
index 52f052ae25..19a2ddb77a 100644
--- a/indra/llcommon/llcriticaldamp.h
+++ b/indra/llcommon/llcriticaldamp.h
@@ -32,22 +32,98 @@
#include "llframetimer.h"
+// These enums each represent one fixed-time delta value
+// that we interpolate once given the actual sTimeDelta time
+// that has passed. This allows us to calculate the interp portion
+// of those values once and then look them up repeatedly per frame.
+//
+enum InterpDelta
+{
+ InterpDelta_0_025, // 0.025
+ InterpDeltaTeenier = InterpDelta_0_025,
+ InterpDeltaFolderOpenTime = InterpDelta_0_025,
+ InterpDeltaFolderCloseTime = InterpDelta_0_025,
+ InterpDeltaCameraFocusHalfLife = InterpDelta_0_025, // USED TO BE ZERO....
+
+ InterpDelta_0_05, // 0.05
+ InterpDeltaTeeny = InterpDelta_0_05,
+
+ InterpDelta_0_06, // 0.06
+ InterpDeltaObjectDampingConstant = InterpDelta_0_06,
+ InterpDeltaCameraZoomHalfLife = InterpDelta_0_06,
+ InterpDeltaFovZoomHalfLife = InterpDelta_0_06,
+ InterpDeltaManipulatorScaleHalfLife = InterpDelta_0_06,
+ InterpDeltaContextFadeTime = InterpDelta_0_06,
+
+ InterpDelta_0_10, // 0.10
+ InterpDeltaSmaller = InterpDelta_0_10,
+ InterpDeltaTargetLagHalfLife = InterpDelta_0_10,
+ InterpDeltaSpeedAdjustTime = InterpDelta_0_10,
+
+ InterpDelta_0_15, // 0.15
+ InterpDeltaFadeWeight = InterpDelta_0_15,
+ InterpDeltaHeadLookAtLagHalfLife = InterpDelta_0_15,
+
+ InterpDelta_0_20, // 0.20
+ InterpDeltaSmall = InterpDelta_0_20,
+ InterpDeltaTorsoLagHalfLife = InterpDelta_0_20,
+ InterpDeltaPositionDampingTC = InterpDelta_0_20,
+
+ InterpDelta_0_25, // 0.25
+ InterpDeltaCameraLagHalfLife = InterpDelta_0_25,
+ InterpDeltaTorsoTargetLagHalfLife = InterpDelta_0_25,
+ InterpDeltaTorsoLookAtLagHalfLife = InterpDelta_0_25,
+
+ InterpDelta_0_30, // 0.3
+ InterpDeltaSmallish = InterpDelta_0_30,
+
+ // Dynamically set interpolants which use setInterpolantConstant
+ //
+ InterpDeltaCameraSmoothingHalfLife,
+ InterpDeltaBehindnessLag,
+ InterpDeltaFocusLag,
+ InterpDeltaPositionLag,
+ InterpDeltaOpenTime,
+ InterpDeltaCloseTime,
+
+ kNumCachedInterpolants
+};
+
class LL_COMMON_API LLCriticalDamp
{
public:
LLCriticalDamp();
- // MANIPULATORS
+ // Updates all the known interp delta values for fast lookup in calls to getInterpolant(InterpDelta)
+ //
static void updateInterpolants();
+ static inline void setInterpolantConstant(InterpDelta whichDelta, const F32 time_constant)
+ {
+ llassert(whichDelta < kNumCachedInterpolants);
+ sInterpolants[whichDelta] = time_constant;
+ }
+
// ACCESSORS
- static F32 getInterpolant(const F32 time_constant, BOOL use_cache = TRUE);
+ static inline F32 getInterpolant(InterpDelta whichDelta)
+ {
+ llassert(whichDelta < kNumCachedInterpolants);
+ return sInterpolatedValues[whichDelta];
+ }
+
+ static inline F32 getInterpolant(const F32 time_constant)
+ {
+ return llclamp((sTimeDelta / time_constant), 0.0f, 1.0f);
+ }
protected:
static LLFrameTimer sInternalTimer; // frame timer for calculating deltas
- static std::map<F32, F32> sInterpolants;
+ //static std::map<F32, F32> sInterpolants;
+ static F32 sInterpolants[kNumCachedInterpolants];
+ static F32 sInterpolatedValues[kNumCachedInterpolants];
static F32 sTimeDelta;
};
#endif // LL_LLCRITICALDAMP_H
+
diff --git a/indra/llcommon/llmemory.h b/indra/llcommon/llmemory.h
index 61e30f11cc..528af83b8f 100644
--- a/indra/llcommon/llmemory.h
+++ b/indra/llcommon/llmemory.h
@@ -182,78 +182,6 @@ inline void ll_aligned_free_32(void *p)
#endif
}
-
-// Copy words 16-byte blocks from src to dst. Source and destination MUST NOT OVERLAP.
-// Source and dest must be 16-byte aligned and size must be multiple of 16.
-//
-inline void ll_memcpy_nonaliased_aligned_16(char* __restrict dst, const char* __restrict src, size_t bytes)
-{
- assert(src != NULL);
- assert(dst != NULL);
- assert(bytes > 0);
- assert((bytes % sizeof(F32))== 0);
- ll_assert_aligned(src,16);
- ll_assert_aligned(dst,16);
- assert((src < dst) ? ((src + bytes) < dst) : ((dst + bytes) < src));
- assert(bytes%16==0);
-
- char* end = dst + bytes;
-
- if (bytes > 64)
- {
-
- // Find start of 64b aligned area within block
- //
- void* begin_64 = LL_NEXT_ALIGNED_ADDRESS_64(dst);
-
- //at least 64 bytes before the end of the destination, switch to 16 byte copies
- void* end_64 = end-64;
-
- // Prefetch the head of the 64b area now
- //
- _mm_prefetch((char*)begin_64, _MM_HINT_NTA);
- _mm_prefetch((char*)begin_64 + 64, _MM_HINT_NTA);
- _mm_prefetch((char*)begin_64 + 128, _MM_HINT_NTA);
- _mm_prefetch((char*)begin_64 + 192, _MM_HINT_NTA);
-
- // Copy 16b chunks until we're 64b aligned
- //
- while (dst < begin_64)
- {
-
- _mm_store_ps((F32*)dst, _mm_load_ps((F32*)src));
- dst += 16;
- src += 16;
- }
-
- // Copy 64b chunks up to your tail
- //
- // might be good to shmoo the 512b prefetch offset
- // (characterize performance for various values)
- //
- while (dst < end_64)
- {
- _mm_prefetch((char*)src + 512, _MM_HINT_NTA);
- _mm_prefetch((char*)dst + 512, _MM_HINT_NTA);
- _mm_store_ps((F32*)dst, _mm_load_ps((F32*)src));
- _mm_store_ps((F32*)(dst + 16), _mm_load_ps((F32*)(src + 16)));
- _mm_store_ps((F32*)(dst + 32), _mm_load_ps((F32*)(src + 32)));
- _mm_store_ps((F32*)(dst + 48), _mm_load_ps((F32*)(src + 48)));
- dst += 64;
- src += 64;
- }
- }
-
- // Copy remainder 16b tail chunks (or ALL 16b chunks for sub-64b copies)
- //
- while (dst < end)
- {
- _mm_store_ps((F32*)dst, _mm_load_ps((F32*)src));
- dst += 16;
- src += 16;
- }
-}
-
#ifndef __DEBUG_PRIVATE_MEM__
#define __DEBUG_PRIVATE_MEM__ 0
#endif
@@ -662,7 +590,13 @@ void LLPrivateMemoryPoolTester::operator delete[](void* addr)
// LLSingleton moved to llsingleton.h
+LL_COMMON_API void ll_assert_aligned_func(uintptr_t ptr,U32 alignment);
+#ifdef SHOW_ASSERT
+#define ll_assert_aligned(ptr,alignment) ll_assert_aligned_func(reinterpret_cast<uintptr_t>(ptr),((U32)alignment))
+#else
+#define ll_assert_aligned(ptr,alignment)
+#endif
#endif
diff --git a/indra/llcommon/llstaticstringtable.h b/indra/llcommon/llstaticstringtable.h
index 52049b0921..d7e0e8a08d 100644
--- a/indra/llcommon/llstaticstringtable.h
+++ b/indra/llcommon/llstaticstringtable.h
@@ -69,7 +69,7 @@ struct LLStaticStringHasher
{
enum { bucket_size = 8 };
size_t operator()(const LLStaticHashedString& key_value) const { return key_value.Hash(); }
- bool operator()(const LLStaticHashedString& left, const LLStaticHashedString& right) const { return left.Hash() < right.Hash(); }
+ bool operator()(const LLStaticHashedString& left, const LLStaticHashedString& right) const { return left.Hash() < right.Hash(); }
};
template< typename MappedObject >
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-02 20:37:10 +0000