mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-05 00:36:57 +00:00
169 lines
4.9 KiB
C++
169 lines
4.9 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
// Based on eos' math code
|
|
|
|
#ifndef COMMON_MATH_H
|
|
#define COMMON_MATH_H
|
|
|
|
#include "common/scummsys.h"
|
|
#ifdef _MSC_VER
|
|
// HACK:
|
|
// intrin.h on MSVC includes setjmp.h, which will fail compiling due to our
|
|
// forbidden symbol colde. Since we also can not assure that defining
|
|
// FORBIDDEN_SYMBOL_EXCEPTION_setjmp and FORBIDDEN_SYMBOL_EXCEPTION_longjmp
|
|
// will actually allow the symbols, since forbidden.h might be included
|
|
// earlier already we need to undefine them here...
|
|
#undef setjmp
|
|
#undef longjmp
|
|
#include <intrin.h>
|
|
// ...and redefine them here so no code can actually use it.
|
|
// This could be resolved by including intrin.h on MSVC in scummsys.h before
|
|
// the forbidden.h include. This might make sense, in case we use MSVC
|
|
// extensions like _BitScanReverse in more places. But for now this hack should
|
|
// be ok...
|
|
#ifndef FORBIDDEN_SYMBOL_EXCEPTION_setjmp
|
|
#undef setjmp
|
|
#define setjmp(a) FORBIDDEN_SYMBOL_REPLACEMENT
|
|
#endif
|
|
|
|
#ifndef FORBIDDEN_SYMBOL_EXCEPTION_longjmp
|
|
#undef longjmp
|
|
#define longjmp(a,b) FORBIDDEN_SYMBOL_REPLACEMENT
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef FLT_MIN
|
|
#define FLT_MIN 1E-37f
|
|
#endif
|
|
|
|
#ifndef FLT_MAX
|
|
#define FLT_MAX 1E+37f
|
|
#endif
|
|
|
|
namespace Common {
|
|
|
|
#if defined(__GNUC__)
|
|
inline int intLog2(uint32 v) {
|
|
// This is a slightly optimized implementation of log2 for natural numbers
|
|
// targeting gcc. It also saves some binary size over our fallback
|
|
// implementation, since it does not need any table.
|
|
if (v == 0)
|
|
return -1;
|
|
else
|
|
// This is really "sizeof(unsigned int) * CHAR_BIT - 1" but using 8
|
|
// instead of CHAR_BIT is sane enough and it saves us from including
|
|
// limits.h
|
|
return (sizeof(unsigned int) * 8 - 1) - __builtin_clz(v);
|
|
}
|
|
#elif defined(_MSC_VER)
|
|
inline int intLog2(uint32 v) {
|
|
unsigned long result = 0;
|
|
unsigned char nonZero = _BitScanReverse(&result, v);
|
|
// _BitScanReverse stores the position of the MSB set in case its result
|
|
// is non zero, thus we can just return it as is.
|
|
return nonZero ? result : -1;
|
|
}
|
|
#else
|
|
// See http://graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup
|
|
static const char LogTable256[256] = {
|
|
#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
|
|
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
|
|
LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7)
|
|
#undef LT
|
|
};
|
|
|
|
inline int intLog2(uint32 v) {
|
|
uint32 t, tt;
|
|
|
|
if ((tt = v >> 16))
|
|
return (t = tt >> 8) ? 24 + LogTable256[t] : 16 + LogTable256[tt];
|
|
else
|
|
return (t = v >> 8) ? 8 + LogTable256[t] : LogTable256[v];
|
|
}
|
|
#endif
|
|
|
|
// Round a number towards zero
|
|
// Input and Output type can be different
|
|
template<class InputT, class OutputT>
|
|
inline OutputT trunc(InputT x) {
|
|
return (x > 0) ? floor(x) : ceil(x);
|
|
}
|
|
|
|
// Round a number towards zero
|
|
// Input and Output type are the same
|
|
template<class T>
|
|
inline T trunc(T x) {
|
|
return trunc<T,T>(x);
|
|
}
|
|
|
|
// Convert radians to degrees
|
|
// Input and Output type can be different
|
|
// Upconvert everything to floats
|
|
template<class InputT, class OutputT>
|
|
inline OutputT rad2deg(InputT rad) {
|
|
return (OutputT)( (float)rad * (float)57.2957795130823); // 180.0/M_PI = 57.2957795130823
|
|
}
|
|
|
|
// Handle the case differently when the input type is double
|
|
template<class OutputT>
|
|
inline OutputT rad2deg(double rad) {
|
|
return (OutputT)( rad * 57.2957795130823);
|
|
}
|
|
|
|
// Convert radians to degrees
|
|
// Input and Output type are the same
|
|
template<class T>
|
|
inline T rad2deg(T rad) {
|
|
return rad2deg<T,T>(rad);
|
|
}
|
|
|
|
// Convert degrees to radians
|
|
// Input and Output type can be different
|
|
// Upconvert everything to floats
|
|
template<class InputT, class OutputT>
|
|
inline OutputT deg2rad(InputT deg) {
|
|
return (OutputT)( (float)deg * (float)0.0174532925199433); // M_PI/180.0 = 0.0174532925199433
|
|
}
|
|
|
|
// Handle the case differently when the input type is double
|
|
template<class OutputT>
|
|
inline OutputT deg2rad(double deg) {
|
|
return (OutputT)( deg * 0.0174532925199433);
|
|
}
|
|
|
|
// Convert degrees to radians
|
|
// Input and Output type are the same
|
|
template<class T>
|
|
inline T deg2rad(T deg) {
|
|
return deg2rad<T,T>(deg);
|
|
}
|
|
|
|
template<class T>
|
|
inline T hypotenuse(T xv, T yv) {
|
|
return (T)sqrt((double)(xv * xv + yv * yv));
|
|
}
|
|
|
|
} // End of namespace Common
|
|
|
|
#endif // COMMON_MATH_H
|