From 373dc625f82b47096893add42c4472e4a57ab7eb Mon Sep 17 00:00:00 2001 From: Aki Date: Wed, 9 Feb 2022 22:23:03 +0100 Subject: Moved third-party libraries to a separate subdirectory --- Opcode/Ice/IceUtils.h | 256 -------------------------------------------------- 1 file changed, 256 deletions(-) delete mode 100644 Opcode/Ice/IceUtils.h (limited to 'Opcode/Ice/IceUtils.h') diff --git a/Opcode/Ice/IceUtils.h b/Opcode/Ice/IceUtils.h deleted file mode 100644 index 789bbe5..0000000 --- a/Opcode/Ice/IceUtils.h +++ /dev/null @@ -1,256 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Contains misc. useful macros & defines. - * \file IceUtils.h - * \author Pierre Terdiman (collected from various sources) - * \date April, 4, 2000 - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Include Guard -#ifndef __ICEUTILS_H__ -#define __ICEUTILS_H__ - - #define START_RUNONCE { static bool __RunOnce__ = false; if(!__RunOnce__){ - #define END_RUNONCE __RunOnce__ = true;}} - - //! Reverse all the bits in a 32 bit word (from Steve Baker's Cute Code Collection) - //! (each line can be done in any order. - inline_ void ReverseBits(udword& n) - { - n = ((n >> 1) & 0x55555555) | ((n << 1) & 0xaaaaaaaa); - n = ((n >> 2) & 0x33333333) | ((n << 2) & 0xcccccccc); - n = ((n >> 4) & 0x0f0f0f0f) | ((n << 4) & 0xf0f0f0f0); - n = ((n >> 8) & 0x00ff00ff) | ((n << 8) & 0xff00ff00); - n = ((n >> 16) & 0x0000ffff) | ((n << 16) & 0xffff0000); - // Etc for larger intergers (64 bits in Java) - // NOTE: the >> operation must be unsigned! (>>> in java) - } - - //! Count the number of '1' bits in a 32 bit word (from Steve Baker's Cute Code Collection) - inline_ udword CountBits(udword n) - { - // This relies of the fact that the count of n bits can NOT overflow - // an n bit interger. EG: 1 bit count takes a 1 bit interger, 2 bit counts - // 2 bit interger, 3 bit count requires only a 2 bit interger. - // So we add all bit pairs, then each nible, then each byte etc... - n = (n & 0x55555555) + ((n & 0xaaaaaaaa) >> 1); - n = (n & 0x33333333) + ((n & 0xcccccccc) >> 2); - n = (n & 0x0f0f0f0f) + ((n & 0xf0f0f0f0) >> 4); - n = (n & 0x00ff00ff) + ((n & 0xff00ff00) >> 8); - n = (n & 0x0000ffff) + ((n & 0xffff0000) >> 16); - // Etc for larger intergers (64 bits in Java) - // NOTE: the >> operation must be unsigned! (>>> in java) - return n; - } - - //! Even faster? - inline_ udword CountBits2(udword bits) - { - bits = bits - ((bits >> 1) & 0x55555555); - bits = ((bits >> 2) & 0x33333333) + (bits & 0x33333333); - bits = ((bits >> 4) + bits) & 0x0F0F0F0F; - return (bits * 0x01010101) >> 24; - } - - //! Spread out bits. EG 00001111 -> 0101010101 - //! 00001010 -> 0100010000 - //! This is used to interleve to intergers to produce a `Morten Key' - //! used in Space Filling Curves (See DrDobbs Journal, July 1999) - //! Order is important. - inline_ void SpreadBits(udword& n) - { - n = ( n & 0x0000ffff) | (( n & 0xffff0000) << 16); - n = ( n & 0x000000ff) | (( n & 0x0000ff00) << 8); - n = ( n & 0x000f000f) | (( n & 0x00f000f0) << 4); - n = ( n & 0x03030303) | (( n & 0x0c0c0c0c) << 2); - n = ( n & 0x11111111) | (( n & 0x22222222) << 1); - } - - // Next Largest Power of 2 - // Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm - // that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with - // the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next - // largest power of 2. For a 32-bit value: - inline_ udword nlpo2(udword x) - { - x |= (x >> 1); - x |= (x >> 2); - x |= (x >> 4); - x |= (x >> 8); - x |= (x >> 16); - return x+1; - } - - //! Test to see if a number is an exact power of two (from Steve Baker's Cute Code Collection) - inline_ bool IsPowerOfTwo(udword n) { return ((n&(n-1))==0); } - - //! Zero the least significant '1' bit in a word. (from Steve Baker's Cute Code Collection) - inline_ void ZeroLeastSetBit(udword& n) { n&=(n-1); } - - //! Set the least significant N bits in a word. (from Steve Baker's Cute Code Collection) - inline_ void SetLeastNBits(udword& x, udword n) { x|=~(~0<> 31; return (x^y)-y; } - - //!< Alternative min function - inline_ sdword min_(sdword a, sdword b) { sdword delta = b-a; return a + (delta&(delta>>31)); } - - // Determine if one of the bytes in a 4 byte word is zero - inline_ BOOL HasNullByte(udword x) { return ((x + 0xfefefeff) & (~x) & 0x80808080); } - - // To find the smallest 1 bit in a word EG: ~~~~~~10---0 => 0----010---0 - inline_ udword LowestOneBit(udword w) { return ((w) & (~(w)+1)); } -// inline_ udword LowestOneBit_(udword w) { return ((w) & (-(w))); } - - // Most Significant 1 Bit - // Given a binary integer value x, the most significant 1 bit (highest numbered element of a bit set) - // can be computed using a SWAR algorithm that recursively "folds" the upper bits into the lower bits. - // This process yields a bit vector with the same most significant 1 as x, but all 1's below it. - // Bitwise AND of the original value with the complement of the "folded" value shifted down by one - // yields the most significant bit. For a 32-bit value: - inline_ udword msb32(udword x) - { - x |= (x >> 1); - x |= (x >> 2); - x |= (x >> 4); - x |= (x >> 8); - x |= (x >> 16); - return (x & ~(x >> 1)); - } - - /* - "Just call it repeatedly with various input values and always with the same variable as "memory". - The sharpness determines the degree of filtering, where 0 completely filters out the input, and 1 - does no filtering at all. - - I seem to recall from college that this is called an IIR (Infinite Impulse Response) filter. As opposed - to the more typical FIR (Finite Impulse Response). - - Also, I'd say that you can make more intelligent and interesting filters than this, for example filters - that remove wrong responses from the mouse because it's being moved too fast. You'd want such a filter - to be applied before this one, of course." - - (JCAB on Flipcode) - */ - inline_ float FeedbackFilter(float val, float& memory, float sharpness) - { - ASSERT(sharpness>=0.0f && sharpness<=1.0f && "Invalid sharpness value in feedback filter"); - if(sharpness<0.0f) sharpness = 0.0f; - else if(sharpness>1.0f) sharpness = 1.0f; - return memory = val * sharpness + memory * (1.0f - sharpness); - } - - //! If you can guarantee that your input domain (i.e. value of x) is slightly - //! limited (abs(x) must be < ((1<<31u)-32767)), then you can use the - //! following code to clamp the resulting value into [-32768,+32767] range: - inline_ int ClampToInt16(int x) - { -// ASSERT(abs(x) < (int)((1<<31u)-32767)); - - int delta = 32767 - x; - x += (delta>>31) & delta; - delta = x + 32768; - x -= (delta>>31) & delta; - return x; - } - - // Generic functions - template inline_ void TSwap(Type& a, Type& b) { const Type c = a; a = b; b = c; } - template inline_ Type TClamp(const Type& x, const Type& lo, const Type& hi) { return ((xhi) ? hi : x); } - - template inline_ void TSort(Type& a, Type& b) - { - if(a>b) TSwap(a, b); - } - - template inline_ void TSort(Type& a, Type& b, Type& c) - { - if(a>b) TSwap(a, b); - if(b>c) TSwap(b, c); - if(a>b) TSwap(a, b); - if(b>c) TSwap(b, c); - } - - // Prevent nasty user-manipulations (strategy borrowed from Charles Bloom) -// #define PREVENT_COPY(curclass) void operator = (const curclass& object) { ASSERT(!"Bad use of operator ="); } - // ... actually this is better ! - #define PREVENT_COPY(cur_class) private: cur_class(const cur_class& object); cur_class& operator=(const cur_class& object); - - //! TO BE DOCUMENTED - #define OFFSET_OF(Class, Member) (size_t)&(((Class*)0)->Member) - //! TO BE DOCUMENTED - #define ICEARRAYSIZE(p) (sizeof(p)/sizeof(p[0])) - - /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - /** - * Returns the alignment of the input address. - * \fn Alignment() - * \param address [in] address to check - * \return the best alignment (e.g. 1 for odd addresses, etc) - */ - /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - FUNCTION ICECORE_API udword Alignment(udword address); - - #define IS_ALIGNED_2(x) ((x&1)==0) - #define IS_ALIGNED_4(x) ((x&3)==0) - #define IS_ALIGNED_8(x) ((x&7)==0) - - inline_ void _prefetch(void const* ptr) { (void)*(char const volatile *)ptr; } - - // Compute implicit coords from an index: - // The idea is to get back 2D coords from a 1D index. - // For example: - // - // 0 1 2 ... nbu-1 - // nbu nbu+1 i ... - // - // We have i, we're looking for the equivalent (u=2, v=1) location. - // i = u + v*nbu - // <=> i/nbu = u/nbu + v - // Since 0 <= u < nbu, u/nbu = 0 (integer) - // Hence: v = i/nbu - // Then we simply put it back in the original equation to compute u = i - v*nbu - inline_ void Compute2DCoords(udword& u, udword& v, udword i, udword nbu) - { - v = i / nbu; - u = i - (v * nbu); - } - - // In 3D: i = u + v*nbu + w*nbu*nbv - // <=> i/(nbu*nbv) = u/(nbu*nbv) + v/nbv + w - // u/(nbu*nbv) is null since u/nbu was null already. - // v/nbv is null as well for the same reason. - // Hence w = i/(nbu*nbv) - // Then we're left with a 2D problem: i' = i - w*nbu*nbv = u + v*nbu - inline_ void Compute3DCoords(udword& u, udword& v, udword& w, udword i, udword nbu, udword nbu_nbv) - { - w = i / (nbu_nbv); - Compute2DCoords(u, v, i - (w * nbu_nbv), nbu); - } - -#endif // __ICEUTILS_H__ -- cgit v1.1