mirror of
https://github.com/godotengine/godot
synced 2024-09-05 00:58:26 +00:00
b411a731fe
A common source of errors is to call functions (such as round()) expecting them to work in place, but them actually being designed only to return the processed value. Not using the return value in this case in indicative of a bug, and can be flagged as a warning by using the [[nodiscard]] attribute.
306 lines
9.6 KiB
C++
306 lines
9.6 KiB
C++
/*************************************************************************/
|
|
/* typedefs.h */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#ifndef TYPEDEFS_H
|
|
#define TYPEDEFS_H
|
|
|
|
#include <stddef.h>
|
|
|
|
/**
|
|
* Basic definitions and simple functions to be used everywhere.
|
|
*/
|
|
|
|
// Include first in case the platform needs to pre-define/include some things.
|
|
#include "platform_config.h"
|
|
|
|
// Should be available everywhere.
|
|
#include "core/error/error_list.h"
|
|
#include <cstdint>
|
|
|
|
// Turn argument to string constant:
|
|
// https://gcc.gnu.org/onlinedocs/cpp/Stringizing.html#Stringizing
|
|
#ifndef _STR
|
|
#define _STR(m_x) #m_x
|
|
#define _MKSTR(m_x) _STR(m_x)
|
|
#endif
|
|
|
|
// Should always inline no matter what.
|
|
#ifndef _ALWAYS_INLINE_
|
|
#if defined(__GNUC__)
|
|
#define _ALWAYS_INLINE_ __attribute__((always_inline)) inline
|
|
#elif defined(_MSC_VER)
|
|
#define _ALWAYS_INLINE_ __forceinline
|
|
#else
|
|
#define _ALWAYS_INLINE_ inline
|
|
#endif
|
|
#endif
|
|
|
|
// Should always inline, except in dev builds because it makes debugging harder.
|
|
#ifndef _FORCE_INLINE_
|
|
#ifdef DEV_ENABLED
|
|
#define _FORCE_INLINE_ inline
|
|
#else
|
|
#define _FORCE_INLINE_ _ALWAYS_INLINE_
|
|
#endif
|
|
#endif
|
|
|
|
// No discard allows the compiler to flag warnings if we don't use the return value of functions / classes
|
|
#ifndef _NO_DISCARD_
|
|
#define _NO_DISCARD_ [[nodiscard]]
|
|
#endif
|
|
|
|
// In some cases _NO_DISCARD_ will get false positives,
|
|
// we can prevent the warning in specific cases by preceding the call with a cast.
|
|
#ifndef _ALLOW_DISCARD_
|
|
#define _ALLOW_DISCARD_ (void)
|
|
#endif
|
|
|
|
// Windows badly defines a lot of stuff we'll never use. Undefine it.
|
|
#ifdef _WIN32
|
|
#undef min // override standard definition
|
|
#undef max // override standard definition
|
|
#undef ERROR // override (really stupid) wingdi.h standard definition
|
|
#undef DELETE // override (another really stupid) winnt.h standard definition
|
|
#undef MessageBox // override winuser.h standard definition
|
|
#undef MIN // override standard definition
|
|
#undef MAX // override standard definition
|
|
#undef CLAMP // override standard definition
|
|
#undef Error
|
|
#undef OK
|
|
#undef CONNECT_DEFERRED // override from Windows SDK, clashes with Object enum
|
|
#endif
|
|
|
|
// Generic ABS function, for math uses please use Math::abs.
|
|
#ifndef ABS
|
|
#define ABS(m_v) (((m_v) < 0) ? (-(m_v)) : (m_v))
|
|
#endif
|
|
|
|
#ifndef SIGN
|
|
#define SIGN(m_v) (((m_v) == 0) ? (0.0) : (((m_v) < 0) ? (-1.0) : (+1.0)))
|
|
#endif
|
|
|
|
#ifndef MIN
|
|
#define MIN(m_a, m_b) (((m_a) < (m_b)) ? (m_a) : (m_b))
|
|
#endif
|
|
|
|
#ifndef MAX
|
|
#define MAX(m_a, m_b) (((m_a) > (m_b)) ? (m_a) : (m_b))
|
|
#endif
|
|
|
|
#ifndef CLAMP
|
|
#define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a))
|
|
#endif
|
|
|
|
// Generic swap template.
|
|
#ifndef SWAP
|
|
#define SWAP(m_x, m_y) __swap_tmpl((m_x), (m_y))
|
|
template <class T>
|
|
inline void __swap_tmpl(T &x, T &y) {
|
|
T aux = x;
|
|
x = y;
|
|
y = aux;
|
|
}
|
|
#endif // SWAP
|
|
|
|
/* Functions to handle powers of 2 and shifting. */
|
|
|
|
// Function to find the next power of 2 to an integer.
|
|
static _FORCE_INLINE_ unsigned int next_power_of_2(unsigned int x) {
|
|
if (x == 0) {
|
|
return 0;
|
|
}
|
|
|
|
--x;
|
|
x |= x >> 1;
|
|
x |= x >> 2;
|
|
x |= x >> 4;
|
|
x |= x >> 8;
|
|
x |= x >> 16;
|
|
|
|
return ++x;
|
|
}
|
|
|
|
// Function to find the previous power of 2 to an integer.
|
|
static _FORCE_INLINE_ unsigned int previous_power_of_2(unsigned int x) {
|
|
x |= x >> 1;
|
|
x |= x >> 2;
|
|
x |= x >> 4;
|
|
x |= x >> 8;
|
|
x |= x >> 16;
|
|
return x - (x >> 1);
|
|
}
|
|
|
|
// Function to find the closest power of 2 to an integer.
|
|
static _FORCE_INLINE_ unsigned int closest_power_of_2(unsigned int x) {
|
|
unsigned int nx = next_power_of_2(x);
|
|
unsigned int px = previous_power_of_2(x);
|
|
return (nx - x) > (x - px) ? px : nx;
|
|
}
|
|
|
|
// Get a shift value from a power of 2.
|
|
static inline int get_shift_from_power_of_2(unsigned int p_bits) {
|
|
for (unsigned int i = 0; i < 32; i++) {
|
|
if (p_bits == (unsigned int)(1 << i)) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
template <class T>
|
|
static _FORCE_INLINE_ T nearest_power_of_2_templated(T x) {
|
|
--x;
|
|
|
|
// The number of operations on x is the base two logarithm
|
|
// of the number of bits in the type. Add three to account
|
|
// for sizeof(T) being in bytes.
|
|
size_t num = get_shift_from_power_of_2(sizeof(T)) + 3;
|
|
|
|
// If the compiler is smart, it unrolls this loop.
|
|
// If it's dumb, this is a bit slow.
|
|
for (size_t i = 0; i < num; i++) {
|
|
x |= x >> (1 << i);
|
|
}
|
|
|
|
return ++x;
|
|
}
|
|
|
|
// Function to find the nearest (bigger) power of 2 to an integer.
|
|
static inline unsigned int nearest_shift(unsigned int p_number) {
|
|
for (int i = 30; i >= 0; i--) {
|
|
if (p_number & (1 << i)) {
|
|
return i + 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// constexpr function to find the floored log2 of a number
|
|
template <typename T>
|
|
constexpr T floor_log2(T x) {
|
|
return x < 2 ? x : 1 + floor_log2(x >> 1);
|
|
}
|
|
|
|
// Get the number of bits needed to represent the number.
|
|
// IE, if you pass in 8, you will get 4.
|
|
// If you want to know how many bits are needed to store 8 values however, pass in (8 - 1).
|
|
template <typename T>
|
|
constexpr T get_num_bits(T x) {
|
|
return floor_log2(x);
|
|
}
|
|
|
|
// Swap 16, 32 and 64 bits value for endianness.
|
|
#if defined(__GNUC__)
|
|
#define BSWAP16(x) __builtin_bswap16(x)
|
|
#define BSWAP32(x) __builtin_bswap32(x)
|
|
#define BSWAP64(x) __builtin_bswap64(x)
|
|
#else
|
|
static inline uint16_t BSWAP16(uint16_t x) {
|
|
return (x >> 8) | (x << 8);
|
|
}
|
|
|
|
static inline uint32_t BSWAP32(uint32_t x) {
|
|
return ((x << 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x >> 24));
|
|
}
|
|
|
|
static inline uint64_t BSWAP64(uint64_t x) {
|
|
x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
|
|
x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
|
|
x = (x & 0x00FF00FF00FF00FF) << 8 | (x & 0xFF00FF00FF00FF00) >> 8;
|
|
return x;
|
|
}
|
|
#endif
|
|
|
|
// Generic comparator used in Map, List, etc.
|
|
template <class T>
|
|
struct Comparator {
|
|
_ALWAYS_INLINE_ bool operator()(const T &p_a, const T &p_b) const { return (p_a < p_b); }
|
|
};
|
|
|
|
// Global lock macro, relies on the static Mutex::_global_mutex.
|
|
void _global_lock();
|
|
void _global_unlock();
|
|
|
|
struct _GlobalLock {
|
|
_GlobalLock() { _global_lock(); }
|
|
~_GlobalLock() { _global_unlock(); }
|
|
};
|
|
|
|
#define GLOBAL_LOCK_FUNCTION _GlobalLock _global_lock_;
|
|
|
|
#if defined(__GNUC__)
|
|
#define likely(x) __builtin_expect(!!(x), 1)
|
|
#define unlikely(x) __builtin_expect(!!(x), 0)
|
|
#else
|
|
#define likely(x) x
|
|
#define unlikely(x) x
|
|
#endif
|
|
|
|
#if defined(__GNUC__)
|
|
#define _PRINTF_FORMAT_ATTRIBUTE_2_0 __attribute__((format(printf, 2, 0)))
|
|
#define _PRINTF_FORMAT_ATTRIBUTE_2_3 __attribute__((format(printf, 2, 3)))
|
|
#else
|
|
#define _PRINTF_FORMAT_ATTRIBUTE_2_0
|
|
#define _PRINTF_FORMAT_ATTRIBUTE_2_3
|
|
#endif
|
|
|
|
// This is needed due to a strange OpenGL API that expects a pointer
|
|
// type for an argument that is actually an offset.
|
|
#define CAST_INT_TO_UCHAR_PTR(ptr) ((uint8_t *)(uintptr_t)(ptr))
|
|
|
|
// Home-made index sequence trick, so it can be used everywhere without the costly include of std::tuple.
|
|
// https://stackoverflow.com/questions/15014096/c-index-of-type-during-variadic-template-expansion
|
|
template <size_t... Is>
|
|
struct IndexSequence {};
|
|
|
|
template <size_t N, size_t... Is>
|
|
struct BuildIndexSequence : BuildIndexSequence<N - 1, N - 1, Is...> {};
|
|
|
|
template <size_t... Is>
|
|
struct BuildIndexSequence<0, Is...> : IndexSequence<Is...> {};
|
|
|
|
// Limit the depth of recursive algorithms when dealing with Array/Dictionary
|
|
#define MAX_RECURSION 100
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
#define DEBUG_METHODS_ENABLED
|
|
#endif
|
|
|
|
// Macro GD_IS_DEFINED() allows to check if a macro is defined. It needs to be defined to anything (say 1) to work.
|
|
#define __GDARG_PLACEHOLDER_1 0,
|
|
#define __gd_take_second_arg(__ignored, val, ...) val
|
|
#define ____gd_is_defined(arg1_or_junk) __gd_take_second_arg(arg1_or_junk 1, 0)
|
|
#define ___gd_is_defined(val) ____gd_is_defined(__GDARG_PLACEHOLDER_##val)
|
|
#define GD_IS_DEFINED(x) ___gd_is_defined(x)
|
|
|
|
#endif // TYPEDEFS_H
|