diff --git a/Release/include/ostd/BaseObject.hpp b/Release/include/ostd/BaseObject.hpp deleted file mode 100644 index f1fb914..0000000 --- a/Release/include/ostd/BaseObject.hpp +++ /dev/null @@ -1,71 +0,0 @@ -#ifndef __BASE_OBJECT_HPP__ -#define __BASE_OBJECT_HPP__ - -#include -#include -#include - -#include - -namespace ostd -{ - class OutputHandlerBase; - struct tSignal; - class BaseObject - { - public: - BaseObject(const BaseObject& copy); - inline virtual ~BaseObject(void) = default; - virtual BaseObject& operator=(const BaseObject& copy); - - virtual inline uint64_t getID(void) const { return m_uid; } - virtual inline void setID(uint64_t id) { m_uid = id; } - - virtual inline bool isValid(void) const { return !isInvalid(); } - virtual inline bool isInvalid(void) const { return !m_valid || m_oid == 0; } - virtual inline void invalidate(void) { m_valid = false; } - virtual inline void validate(void) { m_valid = true; } - virtual inline void setValid(bool valid) { m_valid = valid; } - - inline uint64_t getCompareOID(void) const { return m_oid; } - inline bool compareByOID(const BaseObject& other) const { return m_oid == other.m_oid; } - - inline static BaseObject& InvalidRef(void) { return BaseObject::s_invalid_obj; } - - inline void setTypeName(const String& tn) { m_typeName = tn; } - inline String getTypeName(void) const { return m_typeName; } - String getObjectHeaderString(void) const; - - inline bool signalsEnabled(void) { return m_signalsEnabled; } - inline void enableSignals(bool e = true) { m_signalsEnabled = e; } - - virtual inline String toString(void) const { return getObjectHeaderString(); }; - virtual void print(bool newLine = true, OutputHandlerBase* __destination = nullptr) const; - - virtual inline void handleSignal(tSignal& signal) { } - void connectSignal(uint32_t signal_id); - - void __handle_signal(tSignal& signal); - - friend std::ostream& operator<<(std::ostream& os, const BaseObject& obj); - - protected: - inline BaseObject(void) { m_uid = -1; m_valid = false; m_oid = BaseObject::s_next_oid++; } - private: - inline BaseObject(bool __valid) { m_uid = -1; m_valid = __valid; m_oid = 0; } - - private: - uint64_t m_uid; - uint64_t m_oid; - bool m_valid; - String m_typeName; - bool m_signalsEnabled { true }; - - inline static uint64_t s_next_oid { 1024 }; - static BaseObject s_invalid_obj; - }; -} - - - -#endif diff --git a/Release/include/ostd/Bitfields.hpp b/Release/include/ostd/Bitfields.hpp deleted file mode 100644 index 2b85182..0000000 --- a/Release/include/ostd/Bitfields.hpp +++ /dev/null @@ -1,914 +0,0 @@ -#ifndef __BITFIELDS_HPP__ -#define __BITFIELDS_HPP__ - -#include - -#define get_bit(__bit_field, __bit_n ) __bit_field.bits.b##__bit_n -#define set_bit(__bit_field, __bit_n ) __bit_field.bits.b##__bit_n = true -#define clr_bit(__bit_field, __bit_n ) __bit_field.bits.b##__bit_n = false -#define tgl_bit(__bit_field, __bit_n ) __bit_field.bits.b##__bit_n = !__bit_field.bits.b##__bit_n -#define val_bit(__bit_field, __bit_n, __val ) __bit_field.bits.b##__bit_n = __val - -namespace ostd -{ - union BitField_8 - { - uint8_t value = 0; - struct { - bool b0 : 1; - bool b1 : 1; - bool b2 : 1; - bool b3 : 1; - bool b4 : 1; - bool b5 : 1; - bool b6 : 1; - bool b7 : 1; - } bits; - }; - union BitField_16 - { - uint16_t value = 0; - struct { - bool b0 : 1; - bool b1 : 1; - bool b2 : 1; - bool b3 : 1; - bool b4 : 1; - bool b5 : 1; - bool b6 : 1; - bool b7 : 1; - bool b8 : 1; - bool b9 : 1; - bool b10 : 1; - bool b11 : 1; - bool b12 : 1; - bool b13 : 1; - bool b14 : 1; - bool b15 : 1; - } bits; - }; - union BitField_32 - { - uint32_t value = 0; - struct { - bool b0 : 1; - bool b1 : 1; - bool b2 : 1; - bool b3 : 1; - bool b4 : 1; - bool b5 : 1; - bool b6 : 1; - bool b7 : 1; - bool b8 : 1; - bool b9 : 1; - bool b10 : 1; - bool b11 : 1; - bool b12 : 1; - bool b13 : 1; - bool b14 : 1; - bool b15 : 1; - bool b16 : 1; - bool b17 : 1; - bool b18 : 1; - bool b19 : 1; - bool b20 : 1; - bool b21 : 1; - bool b22 : 1; - bool b23 : 1; - bool b24 : 1; - bool b25 : 1; - bool b26 : 1; - bool b27 : 1; - bool b28 : 1; - bool b29 : 1; - bool b30 : 1; - bool b31 : 1; - } bits; - }; - union BitField_64 - { - uint64_t value = 0; - struct { - bool b0 : 1; - bool b1 : 1; - bool b2 : 1; - bool b3 : 1; - bool b4 : 1; - bool b5 : 1; - bool b6 : 1; - bool b7 : 1; - bool b8 : 1; - bool b9 : 1; - bool b10 : 1; - bool b11 : 1; - bool b12 : 1; - bool b13 : 1; - bool b14 : 1; - bool b15 : 1; - bool b16 : 1; - bool b17 : 1; - bool b18 : 1; - bool b19 : 1; - bool b20 : 1; - bool b21 : 1; - bool b22 : 1; - bool b23 : 1; - bool b24 : 1; - bool b25 : 1; - bool b26 : 1; - bool b27 : 1; - bool b28 : 1; - bool b29 : 1; - bool b30 : 1; - bool b31 : 1; - bool b32 : 1; - bool b33 : 1; - bool b34 : 1; - bool b35 : 1; - bool b36 : 1; - bool b37 : 1; - bool b38 : 1; - bool b39 : 1; - bool b40 : 1; - bool b41 : 1; - bool b42 : 1; - bool b43 : 1; - bool b44 : 1; - bool b45 : 1; - bool b46 : 1; - bool b47 : 1; - bool b48 : 1; - bool b49 : 1; - bool b50 : 1; - bool b51 : 1; - bool b52 : 1; - bool b53 : 1; - bool b54 : 1; - bool b55 : 1; - bool b56 : 1; - bool b57 : 1; - bool b58 : 1; - bool b59 : 1; - bool b60 : 1; - bool b61 : 1; - bool b62 : 1; - bool b63 : 1; - } bits; - } ; - - class Bits - { - public: - //8-Bit field - static inline bool get(const BitField_8& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: return get_bit(bf, 0); - case 1: return get_bit(bf, 1); - case 2: return get_bit(bf, 2); - case 3: return get_bit(bf, 3); - case 4: return get_bit(bf, 4); - case 5: return get_bit(bf, 5); - case 6: return get_bit(bf, 6); - case 7: return get_bit(bf, 7); - default: return false; - } - } - static inline void set(BitField_8& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: set_bit(bf, 0); break; - case 1: set_bit(bf, 1); break; - case 2: set_bit(bf, 2); break; - case 3: set_bit(bf, 3); break; - case 4: set_bit(bf, 4); break; - case 5: set_bit(bf, 5); break; - case 6: set_bit(bf, 6); break; - case 7: set_bit(bf, 7); break; - default: break; - } - } - static inline void clr(BitField_8& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: clr_bit(bf, 0); break; - case 1: clr_bit(bf, 1); break; - case 2: clr_bit(bf, 2); break; - case 3: clr_bit(bf, 3); break; - case 4: clr_bit(bf, 4); break; - case 5: clr_bit(bf, 5); break; - case 6: clr_bit(bf, 6); break; - case 7: clr_bit(bf, 7); break; - default: break; - } - } - static inline void tgl(BitField_8& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: tgl_bit(bf, 0); break; - case 1: tgl_bit(bf, 1); break; - case 2: tgl_bit(bf, 2); break; - case 3: tgl_bit(bf, 3); break; - case 4: tgl_bit(bf, 4); break; - case 5: tgl_bit(bf, 5); break; - case 6: tgl_bit(bf, 6); break; - case 7: tgl_bit(bf, 7); break; - default: break; - } - } - static inline void val(BitField_8& bf, const uint8_t& bit, bool value) - { - switch (bit) - { - case 0: val_bit(bf, 0, value); break; - case 1: val_bit(bf, 1, value); break; - case 2: val_bit(bf, 2, value); break; - case 3: val_bit(bf, 3, value); break; - case 4: val_bit(bf, 4, value); break; - case 5: val_bit(bf, 5, value); break; - case 6: val_bit(bf, 6, value); break; - case 7: val_bit(bf, 7, value); break; - default: break; - } - } - - //16-Bit field - static inline bool get(const BitField_16& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: return get_bit(bf, 0); - case 1: return get_bit(bf, 1); - case 2: return get_bit(bf, 2); - case 3: return get_bit(bf, 3); - case 4: return get_bit(bf, 4); - case 5: return get_bit(bf, 5); - case 6: return get_bit(bf, 6); - case 7: return get_bit(bf, 7); - case 8: return get_bit(bf, 8); - case 9: return get_bit(bf, 9); - case 10: return get_bit(bf, 10); - case 11: return get_bit(bf, 11); - case 12: return get_bit(bf, 12); - case 13: return get_bit(bf, 13); - case 14: return get_bit(bf, 14); - case 15: return get_bit(bf, 15); - default: return false; - } - } - static inline void set(BitField_16& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: set_bit(bf, 0); break; - case 1: set_bit(bf, 1); break; - case 2: set_bit(bf, 2); break; - case 3: set_bit(bf, 3); break; - case 4: set_bit(bf, 4); break; - case 5: set_bit(bf, 5); break; - case 6: set_bit(bf, 6); break; - case 7: set_bit(bf, 7); break; - case 8: set_bit(bf, 8); break; - case 9: set_bit(bf, 9); break; - case 10: set_bit(bf, 10); break; - case 11: set_bit(bf, 11); break; - case 12: set_bit(bf, 12); break; - case 13: set_bit(bf, 13); break; - case 14: set_bit(bf, 14); break; - case 15: set_bit(bf, 15); break; - default: break; - } - } - static inline void clr(BitField_16& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: clr_bit(bf, 0); break; - case 1: clr_bit(bf, 1); break; - case 2: clr_bit(bf, 2); break; - case 3: clr_bit(bf, 3); break; - case 4: clr_bit(bf, 4); break; - case 5: clr_bit(bf, 5); break; - case 6: clr_bit(bf, 6); break; - case 7: clr_bit(bf, 7); break; - case 8: clr_bit(bf, 8); break; - case 9: clr_bit(bf, 9); break; - case 10: clr_bit(bf, 10); break; - case 11: clr_bit(bf, 11); break; - case 12: clr_bit(bf, 12); break; - case 13: clr_bit(bf, 13); break; - case 14: clr_bit(bf, 14); break; - case 15: clr_bit(bf, 15); break; - default: break; - } - } - static inline void tgl(BitField_16& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: tgl_bit(bf, 0); break; - case 1: tgl_bit(bf, 1); break; - case 2: tgl_bit(bf, 2); break; - case 3: tgl_bit(bf, 3); break; - case 4: tgl_bit(bf, 4); break; - case 5: tgl_bit(bf, 5); break; - case 6: tgl_bit(bf, 6); break; - case 7: tgl_bit(bf, 7); break; - case 8: tgl_bit(bf, 8); break; - case 9: tgl_bit(bf, 9); break; - case 10: tgl_bit(bf, 10); break; - case 11: tgl_bit(bf, 11); break; - case 12: tgl_bit(bf, 12); break; - case 13: tgl_bit(bf, 13); break; - case 14: tgl_bit(bf, 14); break; - case 15: tgl_bit(bf, 15); break; - default: break; - } - } - static inline void val(BitField_16& bf, const uint8_t& bit, bool value) - { - switch (bit) - { - case 0: val_bit(bf, 0, value); break; - case 1: val_bit(bf, 1, value); break; - case 2: val_bit(bf, 2, value); break; - case 3: val_bit(bf, 3, value); break; - case 4: val_bit(bf, 4, value); break; - case 5: val_bit(bf, 5, value); break; - case 6: val_bit(bf, 6, value); break; - case 7: val_bit(bf, 7, value); break; - case 8: val_bit(bf, 8, value); break; - case 9: val_bit(bf, 9, value); break; - case 10: val_bit(bf, 10, value); break; - case 11: val_bit(bf, 11, value); break; - case 12: val_bit(bf, 12, value); break; - case 13: val_bit(bf, 13, value); break; - case 14: val_bit(bf, 14, value); break; - case 15: val_bit(bf, 15, value); break; - default: break; - } - } - - //32-Bit field - static inline bool get(const BitField_32& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: return get_bit(bf, 0); - case 1: return get_bit(bf, 1); - case 2: return get_bit(bf, 2); - case 3: return get_bit(bf, 3); - case 4: return get_bit(bf, 4); - case 5: return get_bit(bf, 5); - case 6: return get_bit(bf, 6); - case 7: return get_bit(bf, 7); - case 8: return get_bit(bf, 8); - case 9: return get_bit(bf, 9); - case 10: return get_bit(bf, 10); - case 11: return get_bit(bf, 11); - case 12: return get_bit(bf, 12); - case 13: return get_bit(bf, 13); - case 14: return get_bit(bf, 14); - case 15: return get_bit(bf, 15); - case 16: return get_bit(bf, 16); - case 17: return get_bit(bf, 17); - case 18: return get_bit(bf, 18); - case 19: return get_bit(bf, 19); - case 20: return get_bit(bf, 20); - case 21: return get_bit(bf, 21); - case 22: return get_bit(bf, 22); - case 23: return get_bit(bf, 23); - case 24: return get_bit(bf, 24); - case 25: return get_bit(bf, 25); - case 26: return get_bit(bf, 26); - case 27: return get_bit(bf, 27); - case 28: return get_bit(bf, 28); - case 29: return get_bit(bf, 29); - case 30: return get_bit(bf, 30); - case 31: return get_bit(bf, 31); - default: return false; - } - } - static inline void set(BitField_32& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: set_bit(bf, 0); break; - case 1: set_bit(bf, 1); break; - case 2: set_bit(bf, 2); break; - case 3: set_bit(bf, 3); break; - case 4: set_bit(bf, 4); break; - case 5: set_bit(bf, 5); break; - case 6: set_bit(bf, 6); break; - case 7: set_bit(bf, 7); break; - case 8: set_bit(bf, 8); break; - case 9: set_bit(bf, 9); break; - case 10: set_bit(bf, 10); break; - case 11: set_bit(bf, 11); break; - case 12: set_bit(bf, 12); break; - case 13: set_bit(bf, 13); break; - case 14: set_bit(bf, 14); break; - case 15: set_bit(bf, 15); break; - case 16: set_bit(bf, 16); break; - case 17: set_bit(bf, 17); break; - case 18: set_bit(bf, 18); break; - case 19: set_bit(bf, 19); break; - case 20: set_bit(bf, 20); break; - case 21: set_bit(bf, 21); break; - case 22: set_bit(bf, 22); break; - case 23: set_bit(bf, 23); break; - case 24: set_bit(bf, 24); break; - case 25: set_bit(bf, 25); break; - case 26: set_bit(bf, 26); break; - case 27: set_bit(bf, 27); break; - case 28: set_bit(bf, 28); break; - case 29: set_bit(bf, 29); break; - case 30: set_bit(bf, 30); break; - case 31: set_bit(bf, 31); break; - default: break; - } - } - static inline void clr(BitField_32& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: clr_bit(bf, 0); break; - case 1: clr_bit(bf, 1); break; - case 2: clr_bit(bf, 2); break; - case 3: clr_bit(bf, 3); break; - case 4: clr_bit(bf, 4); break; - case 5: clr_bit(bf, 5); break; - case 6: clr_bit(bf, 6); break; - case 7: clr_bit(bf, 7); break; - case 8: clr_bit(bf, 8); break; - case 9: clr_bit(bf, 9); break; - case 10: clr_bit(bf, 10); break; - case 11: clr_bit(bf, 11); break; - case 12: clr_bit(bf, 12); break; - case 13: clr_bit(bf, 13); break; - case 14: clr_bit(bf, 14); break; - case 15: clr_bit(bf, 15); break; - case 16: clr_bit(bf, 16); break; - case 17: clr_bit(bf, 17); break; - case 18: clr_bit(bf, 18); break; - case 19: clr_bit(bf, 19); break; - case 20: clr_bit(bf, 20); break; - case 21: clr_bit(bf, 21); break; - case 22: clr_bit(bf, 22); break; - case 23: clr_bit(bf, 23); break; - case 24: clr_bit(bf, 24); break; - case 25: clr_bit(bf, 25); break; - case 26: clr_bit(bf, 26); break; - case 27: clr_bit(bf, 27); break; - case 28: clr_bit(bf, 28); break; - case 29: clr_bit(bf, 29); break; - case 30: clr_bit(bf, 30); break; - case 31: clr_bit(bf, 31); break; - default: break; - } - } - static inline void tgl(BitField_32& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: tgl_bit(bf, 0); break; - case 1: tgl_bit(bf, 1); break; - case 2: tgl_bit(bf, 2); break; - case 3: tgl_bit(bf, 3); break; - case 4: tgl_bit(bf, 4); break; - case 5: tgl_bit(bf, 5); break; - case 6: tgl_bit(bf, 6); break; - case 7: tgl_bit(bf, 7); break; - case 8: tgl_bit(bf, 8); break; - case 9: tgl_bit(bf, 9); break; - case 10: tgl_bit(bf, 10); break; - case 11: tgl_bit(bf, 11); break; - case 12: tgl_bit(bf, 12); break; - case 13: tgl_bit(bf, 13); break; - case 14: tgl_bit(bf, 14); break; - case 15: tgl_bit(bf, 15); break; - case 16: tgl_bit(bf, 16); break; - case 17: tgl_bit(bf, 17); break; - case 18: tgl_bit(bf, 18); break; - case 19: tgl_bit(bf, 19); break; - case 20: tgl_bit(bf, 20); break; - case 21: tgl_bit(bf, 21); break; - case 22: tgl_bit(bf, 22); break; - case 23: tgl_bit(bf, 23); break; - case 24: tgl_bit(bf, 24); break; - case 25: tgl_bit(bf, 25); break; - case 26: tgl_bit(bf, 26); break; - case 27: tgl_bit(bf, 27); break; - case 28: tgl_bit(bf, 28); break; - case 29: tgl_bit(bf, 29); break; - case 30: tgl_bit(bf, 30); break; - case 31: tgl_bit(bf, 31); break; - default: break; - } - } - static inline void val(BitField_32& bf, const uint8_t& bit, bool value) - { - switch (bit) - { - case 0: val_bit(bf, 0, value); break; - case 1: val_bit(bf, 1, value); break; - case 2: val_bit(bf, 2, value); break; - case 3: val_bit(bf, 3, value); break; - case 4: val_bit(bf, 4, value); break; - case 5: val_bit(bf, 5, value); break; - case 6: val_bit(bf, 6, value); break; - case 7: val_bit(bf, 7, value); break; - case 8: val_bit(bf, 8, value); break; - case 9: val_bit(bf, 9, value); break; - case 10: val_bit(bf, 10, value); break; - case 11: val_bit(bf, 11, value); break; - case 12: val_bit(bf, 12, value); break; - case 13: val_bit(bf, 13, value); break; - case 14: val_bit(bf, 14, value); break; - case 15: val_bit(bf, 15, value); break; - case 16: val_bit(bf, 16, value); break; - case 17: val_bit(bf, 17, value); break; - case 18: val_bit(bf, 18, value); break; - case 19: val_bit(bf, 19, value); break; - case 20: val_bit(bf, 20, value); break; - case 21: val_bit(bf, 21, value); break; - case 22: val_bit(bf, 22, value); break; - case 23: val_bit(bf, 23, value); break; - case 24: val_bit(bf, 24, value); break; - case 25: val_bit(bf, 25, value); break; - case 26: val_bit(bf, 26, value); break; - case 27: val_bit(bf, 27, value); break; - case 28: val_bit(bf, 28, value); break; - case 29: val_bit(bf, 29, value); break; - case 30: val_bit(bf, 30, value); break; - case 31: val_bit(bf, 31, value); break; - default: break; - } - } - - //64-Bit field - static inline bool get(const BitField_64& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: return get_bit(bf, 0); - case 1: return get_bit(bf, 1); - case 2: return get_bit(bf, 2); - case 3: return get_bit(bf, 3); - case 4: return get_bit(bf, 4); - case 5: return get_bit(bf, 5); - case 6: return get_bit(bf, 6); - case 7: return get_bit(bf, 7); - case 8: return get_bit(bf, 8); - case 9: return get_bit(bf, 9); - case 10: return get_bit(bf, 10); - case 11: return get_bit(bf, 11); - case 12: return get_bit(bf, 12); - case 13: return get_bit(bf, 13); - case 14: return get_bit(bf, 14); - case 15: return get_bit(bf, 15); - case 16: return get_bit(bf, 16); - case 17: return get_bit(bf, 17); - case 18: return get_bit(bf, 18); - case 19: return get_bit(bf, 19); - case 20: return get_bit(bf, 20); - case 21: return get_bit(bf, 21); - case 22: return get_bit(bf, 22); - case 23: return get_bit(bf, 23); - case 24: return get_bit(bf, 24); - case 25: return get_bit(bf, 25); - case 26: return get_bit(bf, 26); - case 27: return get_bit(bf, 27); - case 28: return get_bit(bf, 28); - case 29: return get_bit(bf, 29); - case 30: return get_bit(bf, 30); - case 31: return get_bit(bf, 31); - case 32: return get_bit(bf, 32); - case 33: return get_bit(bf, 33); - case 34: return get_bit(bf, 34); - case 35: return get_bit(bf, 35); - case 36: return get_bit(bf, 36); - case 37: return get_bit(bf, 37); - case 38: return get_bit(bf, 38); - case 39: return get_bit(bf, 39); - case 40: return get_bit(bf, 40); - case 41: return get_bit(bf, 41); - case 42: return get_bit(bf, 42); - case 43: return get_bit(bf, 43); - case 44: return get_bit(bf, 44); - case 45: return get_bit(bf, 45); - case 46: return get_bit(bf, 46); - case 47: return get_bit(bf, 47); - case 48: return get_bit(bf, 48); - case 49: return get_bit(bf, 49); - case 50: return get_bit(bf, 50); - case 51: return get_bit(bf, 51); - case 52: return get_bit(bf, 52); - case 53: return get_bit(bf, 53); - case 54: return get_bit(bf, 54); - case 55: return get_bit(bf, 55); - case 56: return get_bit(bf, 56); - case 57: return get_bit(bf, 57); - case 58: return get_bit(bf, 58); - case 59: return get_bit(bf, 59); - case 60: return get_bit(bf, 60); - case 61: return get_bit(bf, 61); - case 62: return get_bit(bf, 62); - case 63: return get_bit(bf, 63); - default: return false; - } - } - static inline void set(BitField_64& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: set_bit(bf, 0); break; - case 1: set_bit(bf, 1); break; - case 2: set_bit(bf, 2); break; - case 3: set_bit(bf, 3); break; - case 4: set_bit(bf, 4); break; - case 5: set_bit(bf, 5); break; - case 6: set_bit(bf, 6); break; - case 7: set_bit(bf, 7); break; - case 8: set_bit(bf, 8); break; - case 9: set_bit(bf, 9); break; - case 10: set_bit(bf, 10); break; - case 11: set_bit(bf, 11); break; - case 12: set_bit(bf, 12); break; - case 13: set_bit(bf, 13); break; - case 14: set_bit(bf, 14); break; - case 15: set_bit(bf, 15); break; - case 16: set_bit(bf, 16); break; - case 17: set_bit(bf, 17); break; - case 18: set_bit(bf, 18); break; - case 19: set_bit(bf, 19); break; - case 20: set_bit(bf, 20); break; - case 21: set_bit(bf, 21); break; - case 22: set_bit(bf, 22); break; - case 23: set_bit(bf, 23); break; - case 24: set_bit(bf, 24); break; - case 25: set_bit(bf, 25); break; - case 26: set_bit(bf, 26); break; - case 27: set_bit(bf, 27); break; - case 28: set_bit(bf, 28); break; - case 29: set_bit(bf, 29); break; - case 30: set_bit(bf, 30); break; - case 31: set_bit(bf, 31); break; - case 32: set_bit(bf, 32); break; - case 33: set_bit(bf, 33); break; - case 34: set_bit(bf, 34); break; - case 35: set_bit(bf, 35); break; - case 36: set_bit(bf, 36); break; - case 37: set_bit(bf, 37); break; - case 38: set_bit(bf, 38); break; - case 39: set_bit(bf, 39); break; - case 40: set_bit(bf, 40); break; - case 41: set_bit(bf, 41); break; - case 42: set_bit(bf, 42); break; - case 43: set_bit(bf, 43); break; - case 44: set_bit(bf, 44); break; - case 45: set_bit(bf, 45); break; - case 46: set_bit(bf, 46); break; - case 47: set_bit(bf, 47); break; - case 48: set_bit(bf, 48); break; - case 49: set_bit(bf, 49); break; - case 50: set_bit(bf, 50); break; - case 51: set_bit(bf, 51); break; - case 52: set_bit(bf, 52); break; - case 53: set_bit(bf, 53); break; - case 54: set_bit(bf, 54); break; - case 55: set_bit(bf, 55); break; - case 56: set_bit(bf, 56); break; - case 57: set_bit(bf, 57); break; - case 58: set_bit(bf, 58); break; - case 59: set_bit(bf, 59); break; - case 60: set_bit(bf, 60); break; - case 61: set_bit(bf, 61); break; - case 62: set_bit(bf, 62); break; - case 63: set_bit(bf, 63); break; - default: break; - } - } - static inline void clr(BitField_64& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: clr_bit(bf, 0); break; - case 1: clr_bit(bf, 1); break; - case 2: clr_bit(bf, 2); break; - case 3: clr_bit(bf, 3); break; - case 4: clr_bit(bf, 4); break; - case 5: clr_bit(bf, 5); break; - case 6: clr_bit(bf, 6); break; - case 7: clr_bit(bf, 7); break; - case 8: clr_bit(bf, 8); break; - case 9: clr_bit(bf, 9); break; - case 10: clr_bit(bf, 10); break; - case 11: clr_bit(bf, 11); break; - case 12: clr_bit(bf, 12); break; - case 13: clr_bit(bf, 13); break; - case 14: clr_bit(bf, 14); break; - case 15: clr_bit(bf, 15); break; - case 16: clr_bit(bf, 16); break; - case 17: clr_bit(bf, 17); break; - case 18: clr_bit(bf, 18); break; - case 19: clr_bit(bf, 19); break; - case 20: clr_bit(bf, 20); break; - case 21: clr_bit(bf, 21); break; - case 22: clr_bit(bf, 22); break; - case 23: clr_bit(bf, 23); break; - case 24: clr_bit(bf, 24); break; - case 25: clr_bit(bf, 25); break; - case 26: clr_bit(bf, 26); break; - case 27: clr_bit(bf, 27); break; - case 28: clr_bit(bf, 28); break; - case 29: clr_bit(bf, 29); break; - case 30: clr_bit(bf, 30); break; - case 31: clr_bit(bf, 31); break; - case 32: clr_bit(bf, 32); break; - case 33: clr_bit(bf, 33); break; - case 34: clr_bit(bf, 34); break; - case 35: clr_bit(bf, 35); break; - case 36: clr_bit(bf, 36); break; - case 37: clr_bit(bf, 37); break; - case 38: clr_bit(bf, 38); break; - case 39: clr_bit(bf, 39); break; - case 40: clr_bit(bf, 40); break; - case 41: clr_bit(bf, 41); break; - case 42: clr_bit(bf, 42); break; - case 43: clr_bit(bf, 43); break; - case 44: clr_bit(bf, 44); break; - case 45: clr_bit(bf, 45); break; - case 46: clr_bit(bf, 46); break; - case 47: clr_bit(bf, 47); break; - case 48: clr_bit(bf, 48); break; - case 49: clr_bit(bf, 49); break; - case 50: clr_bit(bf, 50); break; - case 51: clr_bit(bf, 51); break; - case 52: clr_bit(bf, 52); break; - case 53: clr_bit(bf, 53); break; - case 54: clr_bit(bf, 54); break; - case 55: clr_bit(bf, 55); break; - case 56: clr_bit(bf, 56); break; - case 57: clr_bit(bf, 57); break; - case 58: clr_bit(bf, 58); break; - case 59: clr_bit(bf, 59); break; - case 60: clr_bit(bf, 60); break; - case 61: clr_bit(bf, 61); break; - case 62: clr_bit(bf, 62); break; - case 63: clr_bit(bf, 63); break; - default: break; - } - } - static inline void tgl(BitField_64& bf, const uint8_t& bit) - { - switch (bit) - { - case 0: tgl_bit(bf, 0); break; - case 1: tgl_bit(bf, 1); break; - case 2: tgl_bit(bf, 2); break; - case 3: tgl_bit(bf, 3); break; - case 4: tgl_bit(bf, 4); break; - case 5: tgl_bit(bf, 5); break; - case 6: tgl_bit(bf, 6); break; - case 7: tgl_bit(bf, 7); break; - case 8: tgl_bit(bf, 8); break; - case 9: tgl_bit(bf, 9); break; - case 10: tgl_bit(bf, 10); break; - case 11: tgl_bit(bf, 11); break; - case 12: tgl_bit(bf, 12); break; - case 13: tgl_bit(bf, 13); break; - case 14: tgl_bit(bf, 14); break; - case 15: tgl_bit(bf, 15); break; - case 16: tgl_bit(bf, 16); break; - case 17: tgl_bit(bf, 17); break; - case 18: tgl_bit(bf, 18); break; - case 19: tgl_bit(bf, 19); break; - case 20: tgl_bit(bf, 20); break; - case 21: tgl_bit(bf, 21); break; - case 22: tgl_bit(bf, 22); break; - case 23: tgl_bit(bf, 23); break; - case 24: tgl_bit(bf, 24); break; - case 25: tgl_bit(bf, 25); break; - case 26: tgl_bit(bf, 26); break; - case 27: tgl_bit(bf, 27); break; - case 28: tgl_bit(bf, 28); break; - case 29: tgl_bit(bf, 29); break; - case 30: tgl_bit(bf, 30); break; - case 31: tgl_bit(bf, 31); break; - case 32: tgl_bit(bf, 32); break; - case 33: tgl_bit(bf, 33); break; - case 34: tgl_bit(bf, 34); break; - case 35: tgl_bit(bf, 35); break; - case 36: tgl_bit(bf, 36); break; - case 37: tgl_bit(bf, 37); break; - case 38: tgl_bit(bf, 38); break; - case 39: tgl_bit(bf, 39); break; - case 40: tgl_bit(bf, 40); break; - case 41: tgl_bit(bf, 41); break; - case 42: tgl_bit(bf, 42); break; - case 43: tgl_bit(bf, 43); break; - case 44: tgl_bit(bf, 44); break; - case 45: tgl_bit(bf, 45); break; - case 46: tgl_bit(bf, 46); break; - case 47: tgl_bit(bf, 47); break; - case 48: tgl_bit(bf, 48); break; - case 49: tgl_bit(bf, 49); break; - case 50: tgl_bit(bf, 50); break; - case 51: tgl_bit(bf, 51); break; - case 52: tgl_bit(bf, 52); break; - case 53: tgl_bit(bf, 53); break; - case 54: tgl_bit(bf, 54); break; - case 55: tgl_bit(bf, 55); break; - case 56: tgl_bit(bf, 56); break; - case 57: tgl_bit(bf, 57); break; - case 58: tgl_bit(bf, 58); break; - case 59: tgl_bit(bf, 59); break; - case 60: tgl_bit(bf, 60); break; - case 61: tgl_bit(bf, 61); break; - case 62: tgl_bit(bf, 62); break; - case 63: tgl_bit(bf, 63); break; - default: break; - } - } - static inline void val(BitField_64& bf, const uint8_t& bit, bool value) - { - switch (bit) - { - case 0: val_bit(bf, 0, value); break; - case 1: val_bit(bf, 1, value); break; - case 2: val_bit(bf, 2, value); break; - case 3: val_bit(bf, 3, value); break; - case 4: val_bit(bf, 4, value); break; - case 5: val_bit(bf, 5, value); break; - case 6: val_bit(bf, 6, value); break; - case 7: val_bit(bf, 7, value); break; - case 8: val_bit(bf, 8, value); break; - case 9: val_bit(bf, 9, value); break; - case 10: val_bit(bf, 10, value); break; - case 11: val_bit(bf, 11, value); break; - case 12: val_bit(bf, 12, value); break; - case 13: val_bit(bf, 13, value); break; - case 14: val_bit(bf, 14, value); break; - case 15: val_bit(bf, 15, value); break; - case 16: val_bit(bf, 16, value); break; - case 17: val_bit(bf, 17, value); break; - case 18: val_bit(bf, 18, value); break; - case 19: val_bit(bf, 19, value); break; - case 20: val_bit(bf, 20, value); break; - case 21: val_bit(bf, 21, value); break; - case 22: val_bit(bf, 22, value); break; - case 23: val_bit(bf, 23, value); break; - case 24: val_bit(bf, 24, value); break; - case 25: val_bit(bf, 25, value); break; - case 26: val_bit(bf, 26, value); break; - case 27: val_bit(bf, 27, value); break; - case 28: val_bit(bf, 28, value); break; - case 29: val_bit(bf, 29, value); break; - case 30: val_bit(bf, 30, value); break; - case 31: val_bit(bf, 31, value); break; - case 32: val_bit(bf, 32, value); break; - case 33: val_bit(bf, 33, value); break; - case 34: val_bit(bf, 34, value); break; - case 35: val_bit(bf, 35, value); break; - case 36: val_bit(bf, 36, value); break; - case 37: val_bit(bf, 37, value); break; - case 38: val_bit(bf, 38, value); break; - case 39: val_bit(bf, 39, value); break; - case 40: val_bit(bf, 40, value); break; - case 41: val_bit(bf, 41, value); break; - case 42: val_bit(bf, 42, value); break; - case 43: val_bit(bf, 43, value); break; - case 44: val_bit(bf, 44, value); break; - case 45: val_bit(bf, 45, value); break; - case 46: val_bit(bf, 46, value); break; - case 47: val_bit(bf, 47, value); break; - case 48: val_bit(bf, 48, value); break; - case 49: val_bit(bf, 49, value); break; - case 50: val_bit(bf, 50, value); break; - case 51: val_bit(bf, 51, value); break; - case 52: val_bit(bf, 52, value); break; - case 53: val_bit(bf, 53, value); break; - case 54: val_bit(bf, 54, value); break; - case 55: val_bit(bf, 55, value); break; - case 56: val_bit(bf, 56, value); break; - case 57: val_bit(bf, 57, value); break; - case 58: val_bit(bf, 58, value); break; - case 59: val_bit(bf, 59, value); break; - case 60: val_bit(bf, 60, value); break; - case 61: val_bit(bf, 61, value); break; - case 62: val_bit(bf, 62, value); break; - case 63: val_bit(bf, 63, value); break; - default: break; - } - } - }; -} // namesoace ox - - - -#endif \ No newline at end of file diff --git a/Release/include/ostd/Color.hpp b/Release/include/ostd/Color.hpp deleted file mode 100644 index 0015795..0000000 --- a/Release/include/ostd/Color.hpp +++ /dev/null @@ -1,62 +0,0 @@ -#ifndef __COLOR_HPP__ -#define __COLOR_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - class Color : public BaseObject - { - public: struct FloatCol - { - float r; - float g; - float b; - float a; - - FloatCol(void) : r(0.0f), g(0.0f), b(0.0f), a(1.0f) { } - FloatCol(float _r, float _g, float _b, float _a) : r(_r), g(_g), b(_b), a(_a) { } - }; - - public: - Color(void); - Color(uint8_t rgb_single_value, uint8_t alpha = 255); - Color(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t alpha = 255); - Color(const String& color_string); - Color(const FloatCol& normalized_color); - Color(const Color& copy); - - bool operator==(const Color& col2); - bool operator!=(const Color& col2); - Color& operator=(const Color& copy); - - Color& set(void); - Color& set(uint8_t rgb_single_value, uint8_t alpha = 255); - Color& set(uint8_t _r, uint8_t _g, uint8_t _b, uint8_t alpha = 255); - Color& set(const String& color_string); - Color& set(const FloatCol& normalized_color); - - String hexString(bool include_alpha = false, String prefix = "0x") const; - String rgbString(bool include_parenthesis = true, bool include_alpha = false) const; - uint32_t asInteger(void) const; - FloatCol getNormalizedColor(void) const; - - String toString(void) const override; - void print(bool newLine = true, OutputHandlerBase* __destination = nullptr) const override; - inline void invalidate(void) override { } - inline void setValid(bool valid) override { } - - public: - uint8_t r; - uint8_t g; - uint8_t b; - uint8_t a; - }; -} - - - -#endif diff --git a/Release/include/ostd/Console.hpp b/Release/include/ostd/Console.hpp deleted file mode 100644 index 2ed4326..0000000 --- a/Release/include/ostd/Console.hpp +++ /dev/null @@ -1,92 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace ostd -{ - class InteractiveConsole : public OutputHandlerBase - { - public: enum class eMode { Direct = 0, Buffered = 1 }; - public: struct tRichChar { - TextStyleParser::tColor foreground; - TextStyleParser::tColor background; - char ascii; - }; - public: - InteractiveConsole(void); - InteractiveConsole(bool clearOnStart, eMode mode = eMode::Direct); - - OutputHandlerBase& bg(const ConsoleColors::tConsoleColor& color) override; - OutputHandlerBase& bg(const String& color) override; - OutputHandlerBase& fg(const ConsoleColors::tConsoleColor& color) override; - OutputHandlerBase& fg(const String& color) override; - - OutputHandlerBase& pChar(char c) override; - OutputHandlerBase& pStyled(const String& styled) override; - OutputHandlerBase& pStyled(const TextStyleParser::tStyledString& styled) override; - OutputHandlerBase& pStyled(const TextStyleBuilder::IRichStringBase& styled) override; - OutputHandlerBase& pObject(const BaseObject& bo) override; - - OutputHandlerBase& p(const String& se) override; - OutputHandlerBase& p(uint8_t i) override; - OutputHandlerBase& p(int8_t i) override; - OutputHandlerBase& p(uint16_t i) override; - OutputHandlerBase& p(int16_t i) override; - OutputHandlerBase& p(uint32_t i) override; - OutputHandlerBase& p(int32_t i) override; - OutputHandlerBase& p(uint64_t i) override; - OutputHandlerBase& p(int64_t i) override; - OutputHandlerBase& p(float f, uint8_t precision = 0) override; - OutputHandlerBase& p(double f, uint8_t precision = 0) override; - - OutputHandlerBase& nl(void) override; - OutputHandlerBase& flush(void) override; - OutputHandlerBase& reset(void) override; - OutputHandlerBase& clear(void) override; - - inline OutputHandlerBase& xy(IPoint position) override { m_cursorPosition = position; __set_cursor(); return *this; } - inline OutputHandlerBase& xy(int32_t x, int32_t y) override { m_cursorPosition = { x, y }; __set_cursor(); return *this; } - inline OutputHandlerBase& x(int32_t x) override { m_cursorPosition.x = x; __set_cursor(); return *this; } - inline OutputHandlerBase& y(int32_t y) override { m_cursorPosition.y = y; __set_cursor(); return *this; } - - void getConsoleSize(int32_t& outColumns, int32_t& outRows) override; - IPoint getConsoleSize(void) override; - - inline IPoint getCursorPosition(void) override { return m_cursorPosition; } - inline void getCursorPosition(int32_t& outX, int32_t& outY) override { outX = m_cursorPosition.x; outY = m_cursorPosition.y; } - inline int32_t getCursorX(void) override { return m_cursorPosition.x; } - inline int32_t getCursorY(void) override { return m_cursorPosition.y; } - - //InteractiveConsole - inline void enableDirectMode(void) { m_mode = eMode::Direct; } - inline void enableBufferedMode(void) { m_mode = eMode::Buffered; } - inline void setMode(eMode mode) { m_mode = mode; } - inline eMode getMode(void) { return m_mode; } - - void update(void); - - - private: - void __set_cursor(void); - void __construct_buffer(void); - void __swap_buffers(void); - void __validate_and_clear_buffers(void); - - private: - IPoint m_cursorPosition { 0, 0 }; - IPoint m_oldConsoleSize { 0, 0 }; - eMode m_mode { eMode::Direct }; - std::vector m_buffer; - std::vector m_secondBuffer; - bool m_validBuffer { false }; - - tRichChar m_emptyChar { - { { 0, 0, 0, 255 }, "Black", false }, - { { 0, 0, 0, 255 }, "Black", true }, - ' ' - }; - - }; -} \ No newline at end of file diff --git a/Release/include/ostd/Defines.hpp b/Release/include/ostd/Defines.hpp deleted file mode 100644 index 17b7ed7..0000000 --- a/Release/include/ostd/Defines.hpp +++ /dev/null @@ -1,84 +0,0 @@ -#ifndef __DEFINES_HPP__ -#define __DEFINES_HPP__ - -#if defined(_WIN32) || defined(_WIN64) - #define WINDOWS_OS - #ifdef _WIN32_WINNT - #undef _WIN32_WINNT - #endif - #define _WIN32_WINNT 0x0501 -#else - #define LINUX_OS -#endif - -//Basic constants -#if !defined(BUILD_NR) - #define BUILD_NR 0 -#endif -#if !defined(MAJ_V) - #define MAJ_V 0 -#endif -#if !defined(MIN_V) - #define MIN_V 0 -#endif -#if !defined(VERSION_STR) - #define VERSION_STR "0.0.0" -#endif -#if !defined(NULL) - #define NULL 0 -#endif - -#define PI 3.1415926535898f -#define TWO_PI PI * 2.0f -#define HALF_PI PI / 2.0f -#define QUARTER_PI PI / 4.0f -#define DEG_TO_RAD(deg) (float)(deg * (PI / 180.0f)) -#define RAD_TO_DEG(rad) (float)(rad * (180.0f / PI)) - -//Game Time constants -#define TM_R_SECONDS_FOR_G_MINUTE 1 -#define TM_G_MINUTES_FOR_G_HOUR 60 -#define TM_G_HOURS_FOR_G_DAY 24 -#define TM_G_DAYS_FOR_G_LONG_MONTH 31 -#define TM_G_DAYS_FOR_G_MEDIUM_MONTH 30 -#define TM_G_DAYS_FOR_G_SHORT_MONTH 28 - -//Macro functions -#define ERROR_DATA() String(CPP_STR(__LINE__)), String(__FILE__) -#define STR_BOOL(b) (b ? "true" : "false") -#define INT_BOOL(i) (i == 0 ? false : true) -#define ZERO(n) (n > 0 ? n : 0) -#define FRAND() ((float)(rand() % 10000)) / 10000.0f -#define RANDOM(min, max) rand() % (max - min + 1) + min -#define LERP(n1, n2, f) (n2 - n1) * f + n1 -#define CAP(n, max) (n > max ? max : n) -#define CAPD(n, min) (n < min ? min : n) -#define CAPB(n, min, max) (n < min ? min : (n > max ? max : n)) -#define MAX(n1, n2) std::max(n1, n2) -#define MIN(n1, n2) std::min(n1, n2) -#define PROPORTION(w, x, y) ((x * w) / y) -#define CONVERT_1D_2D(i, width) IPoint(i % width, i / width) -#define CONVERT_2D_1D(x, y, width) (x + width * y) -#define PRINT(data) std::cout << data -#define PRINTLN(data) std::cout << data << "\n" -#define NEWLN() std::cout << "\n" -#define STDVEC_CONTAINS(vec, elem) (std::find(vec.begin(), vec.end(), elem) != vec.end()) - -//Memory management macros -#define new_sh(type) std::make_shared -#define sh_ptr(type) std::shared_ptr -#define new_un(type) std::make_unique -#define un_ptr(type) std::unique_ptr - -#define OX_NO_ERROR 0x00000000 -#define OX_WINDOW_ERR_MASK 0x00000000 -#define OX_SHADER_ERR_MASK 0x00001000 -#define OX_GLBUFFERS_ERR_MASK 0x00002000 -#define OX_TEXTURE_ERR_MASK 0x00003000 -#define OX_GFX_APPLICATION_2D_ERR_MASK 0x00004000 -#define OX_BITMAPFONT_ERR_MASK 0x00005000 -#define OX_RENDERER2D_ERR_MASK 0x00006000 -#define OX_RENDERTARGET_ERR_MASK 0x00007000 -#define OX_RENDERER2D_TEXT_ERR_MASK 0x00008000 - -#endif diff --git a/Release/include/ostd/Errors.hpp b/Release/include/ostd/Errors.hpp deleted file mode 100644 index 44e9c9d..0000000 --- a/Release/include/ostd/Errors.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __ERRORS_HPP__ -#define __ERRORS_HPP__ - -#include -#include -#include - -namespace ostd -{ - struct tErrorLevel - { - inline static constexpr uint8_t NoError = 0x00; - inline static constexpr uint8_t Warning = 0x01; - inline static constexpr uint8_t Error = 0x02; - inline static constexpr uint8_t Fatal = 0x03; - }; - - class RuntimeError : public BaseObject - { - public: - inline RuntimeError(void) { invalidate(); } - inline RuntimeError(uint8_t group, uint64_t code, uint8_t level, const String& msg) { create(group, code, level, msg); } - RuntimeError& create(uint8_t group, uint64_t code, uint8_t level, const String& msg); - - void fire(const String& extraMessage = "", OutputHandlerBase* outputHandler = nullptr, BaseObject& userData = BaseObject::InvalidRef(), int32_t _line_num = 0, const String& _file_name = ""); - - private: - uint8_t m_errGroup { 0x00 }; - uint8_t m_errLevel { tErrorLevel::NoError }; - uint64_t m_errCode { 0x0000000000000000 }; - String m_message { "" }; - - }; -} - -#endif diff --git a/Release/include/ostd/File.hpp b/Release/include/ostd/File.hpp deleted file mode 100644 index bd369ab..0000000 --- a/Release/include/ostd/File.hpp +++ /dev/null @@ -1,42 +0,0 @@ -#ifndef __FILE_HPP__ -#define __FILE_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - class TextFileBuffer : public BaseObject - { - public: - inline TextFileBuffer(void) { invalidate(); setTypeName("ostd::TextFileBuffer"); } - inline TextFileBuffer(const std::filesystem::path& filePath) { open(filePath); } - TextFileBuffer& open(const std::filesystem::path& filePath); - - inline const String& ext(void) const { return m_extension; } - inline const String& fullPath(void) const { return m_fullPath; } - inline const String& dirPath(void) const { return m_directoryPath; } - inline const String& dir(void) const { return m_directoryName; } - inline const String& fullName(void) const { return m_fullName; } - inline const String& name(void) const { return m_name; } - - inline const String& rawContent(void) { return m_buffer; } - std::vector getLines(const String& separator = "\n", bool trim_tokens = true, bool allow_white_space_only_tokens = false); - - inline bool exists(void) { return isValid(); } - - private: - String m_extension { "" }; - String m_fullPath { "" }; - String m_name { "" }; - String m_fullName { "" }; - String m_directoryPath { "" }; - String m_directoryName { "" }; - - String m_buffer { "" }; - }; -} - -#endif diff --git a/Release/include/ostd/Geometry.hpp b/Release/include/ostd/Geometry.hpp deleted file mode 100644 index abebc19..0000000 --- a/Release/include/ostd/Geometry.hpp +++ /dev/null @@ -1,358 +0,0 @@ -#ifndef __GEOMETRY_HPP__ -#define __GEOMETRY_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - class OutputHandlerBase; - template - class Point - { - public: - T x; - T y; - - public: - inline Point(void) : x(0), y(0) {} - inline Point(T xx, T yy) : x(xx), y(yy) {} - - inline bool operator==(const Point& op2 ) const { return (x == op2.x && y == op2.y); } - inline bool operator!=(const Point& op2 ) const { return (x != op2.x || y != op2.y); } - - template inline Point(Point copy) - { - x = (T2)(copy.x); - y = (T2)(copy.y); - } - }; - - typedef Point FPoint; - typedef Point DPoint; - typedef Point UIPoint; - typedef Point UI64Point; - typedef Point UI16Point; - typedef Point UI8Point; - typedef Point IPoint; - typedef Point I64Point; - typedef Point I16Point; - typedef Point I8Point; - - struct Vec2 - { - //======================== Data ======================== - float x; - float y; - //====================================================== - - - //==================== Construction ==================== - inline Vec2(float xx = 0, float yy = 0) : x(xx), y(yy) { } - inline Vec2(const Vec2& v2) { set(v2); } - inline Vec2& set(const Vec2& v2) { x = v2.x; y = v2.y; return *this; } - inline Vec2& set(float xx, float yy) { x = xx; y = yy; return *this; } - //====================================================== - - - //================== Static Functions ================== - inline static Vec2 fromAngle(float angle) { return Vec2(std::cos(angle), std::sin(angle)); } - inline static float angleBetween(const Vec2& v1, const Vec2& v2) { return std::acos(v1.dot(v2) / (v1.mag() * v2.mag())); } - //====================================================== - - - //===================== Conversion ===================== - inline Vec2 toIsometric(void) const { return Vec2(x - y, (x + y) / 2.0f); } - inline Vec2 toCartesian(void) const { return Vec2((2 * y + x) / 2.0f, (2 * y - x) / 2.0f); } - String toString(void) const; - //====================================================== - - - //===================== Operations ===================== - inline float mag(void) const { return std::sqrt((x * x) + (y * y)); } - - inline Vec2 add(Vec2 v2) const { return { x + v2.x, y + v2.y }; } - inline Vec2 add(float x2, float y2) const { return { x + x2, y + y2 }; } - inline Vec2 sub(Vec2 v2) const { return { x - v2.x, y - v2.y }; } - inline Vec2 sub(float x2, float y2) const { return { x - x2, y - y2 }; } - inline Vec2 mul(float scalar) const { return { x * scalar, y * scalar }; } - inline Vec2 div(float scalar) const { return { x / scalar, y / scalar }; } - - inline Vec2 normalize(void) const { float m = _zp(mag()); return { x / m, y / m }; } - inline float dist(Vec2 v2) const { return std::sqrt((float)((v2.x - x) * (v2.x - x)) + ((v2.y - y) * (v2.y - y))); } - inline float heading(void) const { return std::atan2(y, x); } - inline Vec2 rotate(float angle) const { return Vec2(*this).rotate(angle); } - inline float dot(const Vec2& v2) const { return (x * v2.x) + (y * v2.y); } - inline float cross(const Vec2& v2) const { return (x * v2.y) - (v2.x * y); } - //====================================================== - - - //===================== Modifiers ====================== - inline Vec2& addm(const Vec2& v2) { x += v2.x; y += v2.y; return *this; } - inline Vec2& addm(const float& x2, const float& y2) { x += x2; y += y2; return *this; } - inline Vec2& subm(const Vec2& v2) { x -= v2.x; y -= v2.y; return *this; } - inline Vec2& subm(const float& x2, const float& y2) { x -= x2; y -= y2; return *this; } - inline Vec2& mulm(const float& scalar) { x *= scalar; y *= scalar; return *this; } - inline Vec2& divm(const float& scalar) { x /= scalar; y /= scalar; return *this; } - - inline Vec2& normalizem(void) { float m = _zp(mag()); x /= m; y /= m; return *this; } - inline Vec2& setMag(const float& mag) { return normalizem().mulm(mag); } - inline Vec2& setHeading(const float& angle) { float m = mag(); set(m * std::cos(angle), m * std::sin(angle)); return *this; } - inline Vec2& rotate(const float& angle) { return setHeading(heading() + angle); } - inline Vec2& limit(const float& max) { float msq = mag(); msq *= msq; if (msq > (max * max)) divm(std::sqrt(msq)).mulm(max); return *this; } - //====================================================== - - - //===================== Operators ====================== - inline bool operator==(const Vec2& op2 ) const { return (x == op2.x && y == op2.y); } - inline bool operator!=(const Vec2& op2 ) const { return (x != op2.x || y != op2.y); } - inline Vec2 operator+ (const Vec2& op2 ) const { return add(op2); } - inline Vec2 operator- (const Vec2& op2 ) const { return sub(op2); } - inline Vec2 operator+ (const float& op2) const { return add(op2, op2); } - inline Vec2 operator- (const float& op2) const { return sub(op2, op2); } - inline Vec2 operator* (const float& op2) const { return mul(op2); } - inline Vec2 operator/ (const float& op2) const { return div(op2); } - inline Vec2& operator= (const Vec2& val ) { return set(val); } - inline Vec2& operator= (const float& val) { return set(val, val); } - inline Vec2& operator+=(const Vec2& op2 ) { return addm(op2); } - inline Vec2& operator-=(const Vec2& op2 ) { return subm(op2); } - inline Vec2& operator+=(const float& op2) { return addm(op2, op2); } - inline Vec2& operator-=(const float& op2) { return subm(op2, op2); } - inline Vec2& operator*=(const float& op2) { return mulm(op2); } - inline Vec2& operator/=(const float& op2) { return divm(op2); } - - friend std::ostream& operator<<(std::ostream& out, const Vec2& val); - //====================================================== - - private: - inline float _zp(float n1) const { return (n1 == 0 ? 1 : n1); } - - }; - - inline std::ostream& operator<<(std::ostream& out, const Vec2& val) - { - out << val.toString(); - return out; - } - - struct Vec3 - { - inline Vec3(float xx = 0, float yy = 0, float zz = 0) - { - x = xx; - y = yy; - z = zz; - } - inline Vec3(const Vec2& xy, float _z = 0.0f) { x = xy.x; y = xy.y; z = _z; } - inline Vec2 xy(void) const { return Vec2(x, y); } - inline Vec2 yz(void) const { return Vec2(y, z); } - inline Vec2 zx(void) const { return Vec2(z, x); } - String toString(void) const; - inline bool operator==(const Vec3& op2 ) const { return (x == op2.x && y == op2.y && op2.z == z); } - inline bool operator!=(const Vec3& op2 ) const { return (x != op2.x || y != op2.y || op2.z != z); } - inline Vec3& operator+=(const Vec3& op2 ) { x += op2.x; y += op2.y; z += op2.z; return *this; } - - friend std::ostream& operator<<(std::ostream& out, const Vec2& val); - - float x; - float y; - float z; - }; - - inline std::ostream& operator<<(std::ostream& out, const Vec3& val) - { - out << val.toString(); - return out; - } - - struct Vec4 - { - inline Vec4(float xx = 0, float yy = 0, float zz = 0, float ww = 0) - { - x = xx; - y = yy; - z = zz; - w = ww; - } - inline Vec4(const Vec2& xy, float _z = 0.0f, float _w = 0.0f) { x = xy.x; y = xy.y; z = _z; w = _w; } - inline Vec4(const Vec3& xyz, float _w = 0.0f) { x = xyz.x; y = xyz.y; z = xyz.z; w = _w; } - inline Vec4(const Vec2& xy, const Vec2& zw) { x = xy.x; y = xy.y; z = zw.x; w = zw.y; } - inline Vec2 xy(void) const { return Vec2(x, y); } - inline Vec2 yz(void) const { return Vec2(y, z); } - inline Vec2 zw(void) const { return Vec2(z, w); } - inline Vec2 wx(void) const { return Vec2(w, x); } - - - float x; - float y; - float z; - float w; - }; - - struct Triangle - { - Vec2 vA; - Vec2 vB; - Vec2 vC; - inline Triangle(void) {} - inline Triangle(Vec2 a, Vec2 b, Vec2 c) - { - vA = a; - vB = b; - vC = c; - } - inline Triangle(float ax, float ay, float bx, float by, float cx, float cy) - { - vA.x = ax; - vA.y = ay; - vB.x = bx; - vB.y = by; - vC.x = cx; - vC.y = cy; - } - bool contains(Vec2 p) - { - float d1, d2, d3; - bool has_neg, has_pos; - - d1 = __sign(p, vA, vB); - d2 = __sign(p, vB, vC); - d3 = __sign(p, vC, vA); - - has_neg = (d1 < 0) || (d2 < 0) || (d3 < 0); - has_pos = (d1 > 0) || (d2 > 0) || (d3 > 0); - - return !(has_neg && has_pos); - } - - private: - inline float __sign(Vec2 p1, Vec2 p2, Vec2 p3) - { - return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y); - } - }; - - class Rectangle - { - public: - inline Rectangle(void) : x(0), y(0), w(0), h(0) {} - inline Rectangle(float xx, float yy, float ww, float hh) : x(xx), y(yy), w(ww), h(hh) {} - inline Rectangle(float xw, float yh, bool position = true) { if (position) { x = xw; y = yh; } else { w = xw; h = yh; } } - inline Rectangle(float xx, float yy, Vec2 size) { x = xx; y = yy; w = size.x; h = size.y; } - inline Rectangle(Vec2 position, float ww, float hh) { x = position.x; y = position.y; w = ww; h = hh; } - inline Rectangle(Vec2 position, Vec2 size) { x = position.x; y = position.y; w = size.x; h = size.y; } - virtual ~Rectangle(void) = default; - - inline virtual float getx(void) const { return x; } - inline virtual float gety(void) const { return y; } - inline virtual float getw(void) const { return w; } - inline virtual float geth(void) const { return h; } - inline virtual float getCenterX(void) const { return getx() + getw() / 2; } - inline virtual float getCenterY(void) const { return gety() + geth() / 2; } - - inline virtual void setx(float xx) { x = xx; } - inline virtual void sety(float yy) { y = yy; } - inline virtual void setw(float ww) { w = ww; } - inline virtual void seth(float hh) { h = hh; } - - inline virtual Vec2 getPosition(void) const { return Vec2(getx(), gety()); } - inline virtual Vec2 getSize(void) const { return Vec2(getw(), geth()); } - inline virtual Vec2 getCenter(void) const { return Vec2(getx() + getw() / 2, gety() + geth() / 2); } - - inline virtual void setPosition(Vec2 pos) { setx(pos.x); sety(pos.y); } - inline virtual void setPosition(float xx, float yy) { setx(xx); sety(yy); } - inline virtual void setSize(Vec2 size) { setw(size.x); seth(size.y); } - inline virtual void setSize(float ww, float hh) { setw(ww); seth(hh); } - inline virtual void setBounds(float xx, float yy, float ww, float hh) { setx(xx); sety(yy); setw(ww); seth(hh); } - - inline virtual float addx(float xx) { setx(getx() + xx); return getx(); } - inline virtual float addy(float yy) { sety(gety() + yy); return gety(); } - inline virtual Vec2 addPos(float xx, float yy) { return Vec2(addx(xx), addy(yy)); } - inline virtual Vec2 addPos(Vec2 pos) { return addPos(pos.x, pos.y); } - inline virtual float addw(float ww) { setw(getw() + ww); return getw(); } - inline virtual float addh(float hh) { seth(geth() + hh); return geth(); } - inline virtual Vec2 addSize(float ww, float hh) { return Vec2(addw(ww), addh(hh)); } - inline virtual Vec2 addSize(Vec2 size) { return addPos(size.x, size.y); } - - inline virtual float subx(float xx) { setx(getx() - xx); return getx(); } - inline virtual float suby(float yy) { sety(gety() - yy); return gety(); } - inline virtual Vec2 subPos(float xx, float yy) { return Vec2(subx(xx), suby(yy)); } - inline virtual Vec2 subPos(Vec2 pos) { return subPos(pos.x, pos.y); } - inline virtual float subw(float ww) { setw(getw() - ww); return getw(); } - inline virtual float subh(float hh) { seth(geth() - hh); return geth(); } - inline virtual Vec2 subSize(float ww, float hh) { return Vec2(subw(ww), subh(hh)); } - inline virtual Vec2 subSize(Vec2 size) { return subPos(size.x, size.y); } - - inline virtual float mulx(float xx) { setx(getx() * xx); return getx(); } - inline virtual float muly(float yy) { sety(gety() * yy); return gety(); } - inline virtual Vec2 mulPos(float xx, float yy) { return Vec2(mulx(xx), muly(yy)); } - inline virtual Vec2 mulPos(Vec2 pos) { return mulPos(pos.x, pos.y); } - inline virtual float mulw(float ww) { setw(getw() * ww); return getw(); } - inline virtual float mulh(float hh) { seth(geth() * hh); return geth(); } - inline virtual Vec2 mulSize(float ww, float hh) { return Vec2(mulw(ww), mulh(hh)); } - inline virtual Vec2 mulSize(Vec2 size) { return mulPos(size.x, size.y); } - - inline virtual float divx(float xx) { setx(getx() / xx); return getx(); } - inline virtual float divy(float yy) { sety(gety() / yy); return gety(); } - inline virtual Vec2 divPos(float xx, float yy) { return Vec2(divx(xx), divy(yy)); } - inline virtual Vec2 divPos(Vec2 pos) { return divPos(pos.x, pos.y); } - inline virtual float divw(float ww) { setw(getw() / ww); return getw(); } - inline virtual float divh(float hh) { seth(geth() / hh); return geth(); } - inline virtual Vec2 divSize(float ww, float hh) { return Vec2(divw(ww), divh(hh)); } - inline virtual Vec2 divSize(Vec2 size) { return divPos(size.x, size.y); } - - inline virtual Vec2 topLeft(void) const { return getPosition(); } - inline virtual Vec2 topRight(void) const { return Vec2(getx() + getw(), gety()); } - inline virtual Vec2 bottomLeft(void) const { return Vec2(getx(), gety() + geth()); } - inline virtual Vec2 bottomRight(void) const { return Vec2(getx() + getw(), gety() + geth()); } - - inline virtual bool intersects(Rectangle rect, bool includeBounds = true) const - { - if (includeBounds) - { - if (x + w <= rect.x || x >= rect.x + rect.w) - return false; - if (y + h <= rect.y || y >= rect.y + rect.h) - return false; - } - else - { - if (x + w < rect.x || x > rect.x + rect.w) - return false; - if (y + h < rect.y || y > rect.y + rect.h) - return false; - } - return true; - } - inline virtual Rectangle getIntersection(Rectangle rect, bool includeBounds = true) const - { - if (!intersects(rect, includeBounds)) - return Rectangle(); - float leftX = std::max(x, rect.x); - float rightX = std::min(x + w, rect.x + rect.w); - float topY = std::max(y, rect.y); - float bottomY = std::min(y + h, rect.y + rect.h); - return { leftX, topY, rightX - leftX, bottomY - topY }; - } - inline virtual bool contains(Vec2 p, bool includeBounds = false) const - { - if (includeBounds) - return p.x >= x && p.y >= y & p.x <= x + w && p.y <= y + h; - else - return p.x > x && p.y > y & p.x < x + w && p.y < y + h; - } - inline virtual bool contains(float xx, float yy, bool includeBounds = false) const { return contains({ xx, yy }); } - - inline virtual float getDistance(Vec2 p) const { return sqrt(fabs((p.x - getx()) * (p.x - getx()) + (p.y - gety()) * (p.y - gety()))); } - - public: - float x; - float y; - float w; - float h; - }; -} - - #endif diff --git a/Release/include/ostd/IOHandlers.hpp b/Release/include/ostd/IOHandlers.hpp deleted file mode 100644 index 145d8b0..0000000 --- a/Release/include/ostd/IOHandlers.hpp +++ /dev/null @@ -1,332 +0,0 @@ -#pragma once - -#include -#include -#include -#include - -namespace ostd -{ - class BaseObject; - class ConsoleColors - { - public: struct tConsoleColor { - String name; - Color fullColor; - bool background; - - inline const tConsoleColor asBackground(void) const { return { name, fullColor, true }; } - inline const tConsoleColor asForeground(void) const { return { name, fullColor, false }; } - - private: inline tConsoleColor(void) = default; - private: inline tConsoleColor(const String& _name, const Color& _color, bool _background) : name(_name), fullColor(_color), background(_background) { } - - friend std::ostream& operator<<(std::ostream&, tConsoleColor const&); - - friend class ConsoleColors; - }; - public: - inline static const tConsoleColor Red { "red", { 255, 0, 0, 255 }, false}; - inline static const tConsoleColor BrightRed { "brightred", { 255, 70, 70, 255 }, false}; - inline static const tConsoleColor Green { "green", { 0, 255, 0, 255 }, false}; - inline static const tConsoleColor BrightGreen { "brightgreen", { 70, 255, 70, 255 }, false}; - inline static const tConsoleColor Blue { "blue", { 0, 255, 0, 255 }, false}; - inline static const tConsoleColor BrightBlue { "brightblue", { 70, 70, 255, 255 }, false}; - inline static const tConsoleColor Magenta { "magenta", { 255, 0, 255, 255 }, false}; - inline static const tConsoleColor BrightMagenta { "brightmagenta", { 255, 120, 255, 255 }, false}; - inline static const tConsoleColor Cyan { "cyan", { 0, 255, 255, 255 }, false}; - inline static const tConsoleColor BrightCyan { "brightcyan", { 170, 120, 255, 255 }, false}; - inline static const tConsoleColor Yellow { "yellow", { 255, 255, 0, 255 }, false}; - inline static const tConsoleColor BrightYellow { "brightyellow", { 255, 255, 170, 255 }, false}; - inline static const tConsoleColor Black { "black", { 0, 0, 0, 255 }, false}; - inline static const tConsoleColor Gray { "darkgray", { 50, 50, 50, 255 }, false}; - inline static const tConsoleColor BrightGray { "brightgray", { 150, 150, 150, 255 }, false}; - inline static const tConsoleColor White { "white", { 255, 255, 255, 255 }, false}; - - inline static const tConsoleColor OnRed { "red", { 255, 0, 0, 255 }, true}; - inline static const tConsoleColor OnBrightRed { "brightred", { 255, 70, 70, 255 }, true}; - inline static const tConsoleColor OnGreen { "green", { 0, 255, 0, 255 }, true}; - inline static const tConsoleColor OnBrightGreen { "brightgreen", { 70, 255, 70, 255 }, true}; - inline static const tConsoleColor OnBlue { "blue", { 0, 255, 0, 255 }, true}; - inline static const tConsoleColor OnBrightBlue { "brightblue", { 70, 70, 255, 255 }, true}; - inline static const tConsoleColor OnMagenta { "magenta", { 255, 0, 255, 255 }, true}; - inline static const tConsoleColor OnBrightMagenta { "brightmagenta", { 255, 120, 255, 255 }, true}; - inline static const tConsoleColor OnCyan { "cyan", { 0, 255, 255, 255 }, true}; - inline static const tConsoleColor OnBrightCyan { "brightcyan", { 170, 120, 255, 255 }, true}; - inline static const tConsoleColor OnYellow { "yellow", { 255, 255, 0, 255 }, true}; - inline static const tConsoleColor OnBrightYellow { "brightyellow", { 255, 255, 170, 255 }, true}; - inline static const tConsoleColor OnBlack { "black", { 0, 0, 0, 255 }, true}; - inline static const tConsoleColor OnGray { "darkgray", { 50, 50, 50, 255 }, true}; - inline static const tConsoleColor OnBrightGray { "brightgray", { 150, 150, 150, 255 }, true}; - inline static const tConsoleColor OnWhite { "white", { 255, 255, 255, 255 }, true}; - - inline static const tConsoleColor getFromName(const String& name, bool background = false) { - String edit = name; - edit.toLower().trim(); - if (edit == Red.name) return (background ? OnRed : Red); - if (edit == BrightRed.name) return (background ? OnBrightRed : BrightRed); - if (edit == Green.name) return (background ? OnGreen : Green); - if (edit == BrightGreen.name) return (background ? OnBrightGreen : BrightGreen); - if (edit == Blue.name) return (background ? OnBlue : Blue); - if (edit == BrightBlue.name) return (background ? OnBrightBlue : BrightBlue); - if (edit == Magenta.name) return (background ? OnMagenta : Magenta); - if (edit == BrightMagenta.name) return (background ? OnBrightMagenta : BrightMagenta); - if (edit == Cyan.name) return (background ? OnCyan : Cyan); - if (edit == BrightCyan.name) return (background ? OnBrightCyan : BrightCyan); - if (edit == Yellow.name) return (background ? OnYellow : Yellow); - if (edit == BrightYellow.name) return (background ? OnBrightYellow : BrightYellow); - if (edit == Black.name) return (background ? OnBlack : Black); - if (edit == Gray.name) return (background ? OnGray : Gray); - if (edit == BrightGray.name) return (background ? OnBrightGray : BrightGray); - if (edit == White.name) return (background ? OnWhite : White); - return (background ? OnBlack : Black); - } - inline static bool isConsoleColor(const String& name) { - String edit = name; - edit.toLower().trim(); - if (edit == Red.name) return true; - if (edit == BrightRed.name) return true; - if (edit == Green.name) return true; - if (edit == BrightGreen.name) return true; - if (edit == Blue.name) return true; - if (edit == BrightBlue.name) return true; - if (edit == Magenta.name) return true; - if (edit == BrightMagenta.name) return true; - if (edit == Cyan.name) return true; - if (edit == BrightCyan.name) return true; - if (edit == Yellow.name) return true; - if (edit == BrightYellow.name) return true; - if (edit == Black.name) return true; - if (edit == Gray.name) return true; - if (edit == BrightGray.name) return true; - if (edit == White.name) return true; - return false; - } - }; - - class OutputHandlerBase - { - public: - virtual ~OutputHandlerBase(void) = default; - - inline virtual OutputHandlerBase& bg(const Color& color) { return *this; } - inline virtual OutputHandlerBase& bg(const ConsoleColors::tConsoleColor& color) { return *this; } - inline virtual OutputHandlerBase& bg(const String& color) { return *this; } - inline virtual OutputHandlerBase& fg(const Color& color) { return *this; } - inline virtual OutputHandlerBase& fg(const ConsoleColors::tConsoleColor& color) { return *this; } - inline virtual OutputHandlerBase& fg(const String& color) { return *this; } - - inline virtual OutputHandlerBase& pChar(char c) { return *this; } - inline virtual OutputHandlerBase& pStyled(const String& styled) { return *this; } - inline virtual OutputHandlerBase& pStyled(const TextStyleParser::tStyledString& styled) { return *this; } - inline virtual OutputHandlerBase& pStyled(const TextStyleBuilder::IRichStringBase& styled) { return *this; } - inline virtual OutputHandlerBase& pObject(const BaseObject& bo) { return *this; } - - inline virtual OutputHandlerBase& p(const String& se) { return *this; } - inline virtual OutputHandlerBase& p(uint8_t i) { return *this; } - inline virtual OutputHandlerBase& p(int8_t i) { return *this; } - inline virtual OutputHandlerBase& p(uint16_t i) { return *this; } - inline virtual OutputHandlerBase& p(int16_t i) { return *this; } - inline virtual OutputHandlerBase& p(uint32_t i) { return *this; } - inline virtual OutputHandlerBase& p(int32_t i) { return *this; } - inline virtual OutputHandlerBase& p(uint64_t i) { return *this; } - inline virtual OutputHandlerBase& p(int64_t i) { return *this; } - inline virtual OutputHandlerBase& p(float f, uint8_t precision = 0) { return *this; } - inline virtual OutputHandlerBase& p(double f, uint8_t precision = 0) { return *this; } - - inline virtual OutputHandlerBase& nl(void) { return *this; } - inline virtual OutputHandlerBase& flush(void) { return *this; } - inline virtual OutputHandlerBase& reset(void) { return *this; } - inline virtual OutputHandlerBase& clear(void) { return *this; } - - inline virtual OutputHandlerBase& xy(IPoint position) { return *this; } - inline virtual OutputHandlerBase& xy(int32_t x, int32_t y) { return *this; } - inline virtual OutputHandlerBase& x(int32_t x) { return *this; } - inline virtual OutputHandlerBase& y(int32_t y) { return *this; } - - inline virtual IPoint getCursorPosition(void) { return { 0, 0 }; } - inline virtual void getCursorPosition(int32_t& outX, int32_t& outY) { } - inline virtual int32_t getCursorX(void) { return 0; } - inline virtual int32_t getCursorY(void) { return 0; } - - inline virtual void getConsoleSize(int32_t& outColumns, int32_t& outRows) { } - inline virtual IPoint getConsoleSize(void) { return { 0, 0 }; } - }; - - class ConsoleOutputHandler : public OutputHandlerBase - { - public: - OutputHandlerBase& bg(const ConsoleColors::tConsoleColor& color) override; - OutputHandlerBase& bg(const String& color) override; - OutputHandlerBase& fg(const ConsoleColors::tConsoleColor& color) override; - OutputHandlerBase& fg(const String& color) override; - - OutputHandlerBase& pChar(char c) override; - OutputHandlerBase& pStyled(const String& styled) override; - OutputHandlerBase& pStyled(const TextStyleParser::tStyledString& styled) override; - OutputHandlerBase& pStyled(const TextStyleBuilder::IRichStringBase& styled) override; - OutputHandlerBase& pObject(const BaseObject& bo) override; - - OutputHandlerBase& p(const String& se) override; - OutputHandlerBase& p(uint8_t i) override; - OutputHandlerBase& p(int8_t i) override; - OutputHandlerBase& p(uint16_t i) override; - OutputHandlerBase& p(int16_t i) override; - OutputHandlerBase& p(uint32_t i) override; - OutputHandlerBase& p(int32_t i) override; - OutputHandlerBase& p(uint64_t i) override; - OutputHandlerBase& p(int64_t i) override; - OutputHandlerBase& p(float f, uint8_t precision = 0) override; - OutputHandlerBase& p(double f, uint8_t precision = 0) override; - - OutputHandlerBase& nl(void) override; - OutputHandlerBase& flush(void) override; - OutputHandlerBase& reset(void) override; - OutputHandlerBase& clear(void) override; - }; - - - namespace legacy - { - struct ConsoleCol - { - inline static constexpr const char* Red = "red"; - inline static constexpr const char* BrightRed = "b-red"; - inline static constexpr const char* OnRed = "o-red"; - inline static constexpr const char* OnBrightRed = "ob-red"; - - inline static constexpr const char* Green = "green"; - inline static constexpr const char* BrightGreen = "b-green"; - inline static constexpr const char* OnGreen = "o-green"; - inline static constexpr const char* OnBrightGreen = "ob-green"; - - inline static constexpr const char* Blue = "blue"; - inline static constexpr const char* BrightBlue = "b-blue"; - inline static constexpr const char* OnBlue = "o-blue"; - inline static constexpr const char* OnBrightBlue = "ob-blue"; - - inline static constexpr const char* Magenta = "magenta"; - inline static constexpr const char* BrightMagenta = "b-magenta"; - inline static constexpr const char* OnMagenta = "o-magenta"; - inline static constexpr const char* OnBrightMagenta = "ob-magenta"; - - inline static constexpr const char* Cyan = "cyan"; - inline static constexpr const char* BrightCyan = "b-cyan"; - inline static constexpr const char* OnCyan = "o-cyan"; - inline static constexpr const char* OnBrightCyan = "ob-cyan"; - - inline static constexpr const char* Yellow = "yellow"; - inline static constexpr const char* BrightYellow = "b-yellow"; - inline static constexpr const char* OnYellow = "o-yellow"; - inline static constexpr const char* OnBrightYellow = "ob-yellow"; - - inline static constexpr const char* Black = "gray"; - inline static constexpr const char* BrightGray = "b-gray"; - inline static constexpr const char* OnBlack = "o-gray"; - inline static constexpr const char* OnBrightGray = "ob-gray"; - - inline static constexpr const char* Gray = "lgray"; - inline static constexpr const char* White = "white"; - inline static constexpr const char* onGray = "o-lgray"; - inline static constexpr const char* OnWhite = "o-white"; - }; - - class IOutputHandler - { - public: - virtual ~IOutputHandler(void) = default; - virtual IOutputHandler& col(String color) = 0; - virtual IOutputHandler& col(const Color& color) = 0; - //virtual IOutputHandler& p(String str) = 0; - virtual IOutputHandler& p(char c) = 0; - virtual IOutputHandler& p(const StringEditor& se) = 0; - //virtual IOutputHandler& p(const BaseObject& bo) = 0; - virtual IOutputHandler& pi(uint8_t i) = 0; - virtual IOutputHandler& pi(int8_t i) = 0; - virtual IOutputHandler& pi(uint16_t i) = 0; - virtual IOutputHandler& pi(int16_t i) = 0; - virtual IOutputHandler& pi(uint32_t i) = 0; - virtual IOutputHandler& pi(int32_t i) = 0; - virtual IOutputHandler& pi(uint64_t i) = 0; - virtual IOutputHandler& pi(int64_t i) = 0; - virtual IOutputHandler& pf(float f, uint8_t precision = 0) = 0; - virtual IOutputHandler& pf(double f, uint8_t precision = 0) = 0; - virtual IOutputHandler& pStyled(const StringEditor& styled) = 0; - virtual IOutputHandler& pStyled(const TextStyleParser::tStyledString& styled) = 0; - virtual IOutputHandler& pStyled(const TextStyleBuilder::IRichStringBase& styled) = 0; - virtual IOutputHandler& nl(void) = 0; - virtual IOutputHandler& flush(void) = 0; - virtual IOutputHandler& reset(void) = 0; - - virtual IOutputHandler& bgcol(const Color& color) = 0; - virtual IOutputHandler& bgcol(String color) = 0; - virtual IOutputHandler& resetColors(void) = 0; - virtual IOutputHandler& clear(void) = 0; - }; - - class ConsoleOutputHandler : public IOutputHandler - { - public: - IOutputHandler& col(String color) override; - IOutputHandler& col(const Color& color) override; - inline IOutputHandler& bgcol(const Color& color) override { return *this; } - inline IOutputHandler& bgcol(String color) override { return *this; } - inline IOutputHandler& resetColors(void) override { return *this; } - //IOutputHandler& p(String str); - IOutputHandler& p(char c) override; - IOutputHandler& p(const StringEditor& se) override; - //IOutputHandler& p(const BaseObject& bo); - IOutputHandler& pi(uint8_t i) override; - IOutputHandler& pi(int8_t i) override; - IOutputHandler& pi(uint16_t i) override; - IOutputHandler& pi(int16_t i) override; - IOutputHandler& pi(uint32_t i) override; - IOutputHandler& pi(int32_t i) override; - IOutputHandler& pi(uint64_t i) override; - IOutputHandler& pi(int64_t i) override; - IOutputHandler& pf(float f, uint8_t precision = 0) override; - IOutputHandler& pf(double f, uint8_t precision = 0) override; - IOutputHandler& pStyled(const StringEditor& styled) override; - IOutputHandler& pStyled(const TextStyleParser::tStyledString& styled) override; - IOutputHandler& pStyled(const TextStyleBuilder::IRichStringBase& styled) override; - IOutputHandler& nl(void) override; - IOutputHandler& flush(void) override; - IOutputHandler& reset(void) override; - IOutputHandler& clear(void) override; - }; - - class BufferedOutputHandler : public IOutputHandler - { - public: - inline IOutputHandler& col(String color) override { return *this; } - inline IOutputHandler& col(const Color& color) override { return *this; } - inline IOutputHandler& bgcol(const Color& color) override { return *this; } - inline IOutputHandler& bgcol(String color) override { return *this; } - inline IOutputHandler& resetColors(void) override { return *this; } - IOutputHandler& p(char c) override; - IOutputHandler& p(const StringEditor& se) override; - IOutputHandler& pi(uint8_t i) override; - IOutputHandler& pi(int8_t i) override; - IOutputHandler& pi(uint16_t i) override; - IOutputHandler& pi(int16_t i) override; - IOutputHandler& pi(uint32_t i) override; - IOutputHandler& pi(int32_t i) override; - IOutputHandler& pi(uint64_t i) override; - IOutputHandler& pi(int64_t i) override; - IOutputHandler& pf(float f, uint8_t precision = 0) override; - IOutputHandler& pf(double f, uint8_t precision = 0) override; - IOutputHandler& pStyled(const StringEditor& styled) override { return *this; }; - inline IOutputHandler& pStyled(const TextStyleParser::tStyledString& styled) override { return *this; } - inline IOutputHandler& pStyled(const TextStyleBuilder::IRichStringBase& styled) override { return *this; }; - IOutputHandler& nl(void) override; - inline IOutputHandler& flush(void) override { return *this; } - inline IOutputHandler& reset(void) override { return *this; } - - inline IOutputHandler& clear(void) override { m_buffer = ""; return *this; } - inline const StringEditor& getBuffer(void) { return m_buffer; } - - private: - StringEditor m_buffer; - }; - } -} \ No newline at end of file diff --git a/Release/include/ostd/Logger.hpp b/Release/include/ostd/Logger.hpp deleted file mode 100644 index 5f094f8..0000000 --- a/Release/include/ostd/Logger.hpp +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef __LOGGER_HPP__ -#define __LOGGER_HPP__ - -#include - -namespace ostd -{ - struct tLogLevel - { - inline static const uint8_t Fatal = 0; - inline static const uint8_t Error = 1; - inline static const uint8_t Warning = 2; - inline static const uint8_t Info = 3; - inline static const uint8_t Debug = 4; - inline static const uint8_t Trace = 5; - }; - - class OutputHandlerBase; - class Logger - { - public: - static void __log_output(uint8_t log_level, String message, ...); - static void setOutputHandler(OutputHandlerBase& __destination); - static void destroy(void); - static inline OutputHandlerBase& getOutputHandler(void) { return *m_out; } - - private: - static OutputHandlerBase* m_out; - }; -} - -#define OX_LOG_WARN_ENABLED 1 -#define OX_LOG_INFO_ENABLED 1 -#define OX_LOG_DEBUG_ENABLED 1 -#define OX_LOG_TRACE_ENABLED 1 - -#if OX_RELEASE == 1 - #define OX_LOG_DEBUG_ENABLED 0 - #define OX_LOG_TRACE_ENABLED 0 -#endif - -#define OX_FATAL(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Fatal, message, ##__VA_ARGS__) -#define OX_ERROR(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Error, message, ##__VA_ARGS__) -#if OX_LOG_WARN_ENABLED == 1 - #define OX_WARN(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Warning, message, ##__VA_ARGS__) -#else - #define OX_WARN(message, ...) -#endif -#if OX_LOG_INFO_ENABLED == 1 - #define OX_INFO(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Info, message, ##__VA_ARGS__) -#else - #define OX_INFO(message, ...) -#endif -#if OX_LOG_DEBUG_ENABLED == 1 - #define OX_DEBUG(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Debug, message, ##__VA_ARGS__) -#else - #define OX_DEBUG(message, ...) -#endif -#if OX_LOG_TRACE_ENABLED == 1 - #define OX_TRACE(message, ...) ostd::Logger::__log_output(ostd::tLogLevel::Trace, message, ##__VA_ARGS__) -#else - #define OX_TRACE(message, ...) -#endif - -#endif diff --git a/Release/include/ostd/Logic.hpp b/Release/include/ostd/Logic.hpp deleted file mode 100644 index 1ff7dd9..0000000 --- a/Release/include/ostd/Logic.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef __LOGIC_HPP__ -#define __LOGIC_HPP__ - -#include -#include - -namespace ostd -{ - enum class eLogicOp - { - AND = 0, - OR, - NOT, - XOR, - - NAND, - NOR, - XNOR, - - O_PARENTH = 125, - C_PARENTH = 126, - NONE = 127 - }; - - class LogicEvaluator - { - public: - static bool eval(String exp); - - private: - static bool applyOp(bool a, bool b, eLogicOp op); - static eLogicOp parseOp(char op); - }; -} - -#endif diff --git a/Release/include/ostd/PathFinder.hpp b/Release/include/ostd/PathFinder.hpp deleted file mode 100644 index ca274c6..0000000 --- a/Release/include/ostd/PathFinder.hpp +++ /dev/null @@ -1,83 +0,0 @@ -#ifndef __PATH_FINDER_HPP__ -#define __PATH_FINDER_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - enum class eHeuristicType - { - Euclidean = 0, - Manhattan, - Diagonal - }; - - struct KeyNode - { - int32_t x; - int32_t y; - float fscore; - - KeyNode(int32_t xx = 0, int32_t yy = 0, float f = 0.0f); - bool operator==(const KeyNode &other) const; - bool operator<(const KeyNode &other) const; - - struct hashFunc - { - std::size_t operator()(const KeyNode& k) const; - }; - }; - - struct OpenSet - { - OpenSet(void); - bool isEmpty(void) const; - void push(const KeyNode& k); - bool contains(const KeyNode& k); - const KeyNode& operator[](uint32_t index) const; - int32_t size(void) const; - void removeLowest(void); - void remove(uint32_t index); - void clear(void); - KeyNode& getLowest(void); - int32_t getLowestIndex(void); - - private: - int32_t m_lowest_index; - std::vector m_list; - KeyNode* m_lowest; - }; - - class PathFinder - { - public: - PathFinder(void); - void init(int32_t w, int32_t h, eHeuristicType ht = eHeuristicType::Euclidean); - void setObstacle(int32_t x, int32_t y, bool obst = true); - void setKeyPoints(int32_t startx, int32_t starty, int32_t endx, int32_t endy); - std::deque findPath(void); - - private: - float heuristics(KeyNode n); - - private: - std::unordered_map gscores; - std::unordered_map pathMap; - std::unordered_map obstacle; - OpenSet openSet; - - KeyNode __start; - KeyNode __goal; - eHeuristicType __ht; - - int32_t m_width; - int32_t m_height; - - bool m_initialized; - }; -} - -#endif diff --git a/Release/include/ostd/QuadTree.hpp b/Release/include/ostd/QuadTree.hpp deleted file mode 100644 index 2686609..0000000 --- a/Release/include/ostd/QuadTree.hpp +++ /dev/null @@ -1,47 +0,0 @@ -#ifndef __QUAD_TREE_HPP__ -#define __QUAD_TREE_HPP__ - -#include -#include -#include -#include -#include - -namespace ostd -{ - class QuadTree : public BaseObject - { - public: struct tElement - { - Vec2 pos; - void* data; - tElement(void); - tElement(Vec2 position, void* userData); - }; - public: - inline QuadTree(void) : m_points(nullptr), m_sw(nullptr), m_nw(nullptr), - m_se(nullptr),m_ne(nullptr), m_subdivided(false), - m_capacity(0), m_currentSize(0) - { invalidate(); } - inline QuadTree(Rectangle bounds, uint16_t capacity) { create(bounds, capacity); } - inline ~QuadTree(void) { destroy(); } - void destroy(void); - void create(Rectangle bounds, uint16_t capacity); - void subdivide(void); - bool insert(Vec2 point, void* data = nullptr); - void query(Rectangle range, std::vector& list); - - private: - tElement* m_points; - uint16_t m_currentSize; - uint16_t m_capacity; - Rectangle m_bounds; - bool m_subdivided; - un_ptr(QuadTree) m_nw; - un_ptr(QuadTree) m_sw; - un_ptr(QuadTree) m_ne; - un_ptr(QuadTree) m_se; - }; -} - -#endif diff --git a/Release/include/ostd/Random.hpp b/Release/include/ostd/Random.hpp deleted file mode 100644 index d4ee341..0000000 --- a/Release/include/ostd/Random.hpp +++ /dev/null @@ -1,81 +0,0 @@ -#ifndef __RANDOM_HPP__ -#define __RANDOM_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - class RandomGenerator - { - public: - inline RandomGenerator(bool auto_seed = true) { if (auto_seed) autoSeed(); } - inline RandomGenerator(int64_t _seed) { seed(_seed); } - - void seed(int64_t _seed); - void autoSeed(void); - int64_t getSeed(void); - - float getf32(float min = 0.0f, float max = 1.0f); - double getf64(double min = 0.0f, double max = 1.0f); - int64_t geti64(int64_t min = LLONG_MIN, int64_t max = LLONG_MAX); - int32_t geti32(int32_t min = INT_MIN, int32_t max = INT_MAX); - int16_t geti16(int16_t min = SHRT_MIN, int16_t max = SHRT_MAX); - int8_t geti8(int8_t min = CHAR_MIN, int8_t max = CHAR_MAX); - uint64_t getui64(uint64_t min = 0, uint64_t max = ULLONG_MAX); - uint32_t getui32(uint32_t min = 0, uint32_t max = UINT_MAX); - uint16_t getui16(uint16_t min = 0, uint16_t max = USHRT_MAX); - uint8_t getui8(uint8_t min = 0, uint8_t max = UCHAR_MAX); - bool getb(float true_percentage = 0.5f); - Vec2 getVec2(float min = 0.0f, float max = 1.0f, bool match_xy = false); - Vec2 getVec2(Vec2 minmax_x = { 0.0f, 1.0f }, Vec2 minmax_y = { 0.0f, 1.0f }); - float getOpenSimplex2D(float x, float y); - - inline FastNoiseLite& getNoiseGenerator(void) { return m_noiseGen; } - - template - inline T& getFromStdVec(std::vector& list) - { - uint64_t index = static_cast(geti64(0, list.size())); - return list[index]; - } - - private: - int64_t m_seed { 0 }; - std::mt19937_64 m_engine; - FastNoiseLite m_noiseGen; - }; - - class Random - { - public: - inline static void seed(int64_t _seed) { Random::s_gen.seed(_seed); } - inline static void autoSeed(void) { Random::s_gen.autoSeed(); } - inline static int64_t getSeed(void) { return Random::s_gen.getSeed(); } - - inline static float getf32(float min = 0.0f, float max = 1.0f) { return Random::s_gen.getf32(min, max); } - inline static double getf64(double min = 0.0f, double max = 1.0f) { return Random::s_gen.getf64(min, max); } - inline static int64_t geti64(int64_t min = LLONG_MIN, int64_t max = LLONG_MAX) { return Random::s_gen.geti64(min, max); } - inline static int32_t geti32(int32_t min = INT_MIN, int32_t max = INT_MAX) { return Random::s_gen.geti32(min, max); } - inline static int16_t geti16(int16_t min = SHRT_MIN, int16_t max = SHRT_MAX) { return Random::s_gen.geti16(min, max); } - inline static int8_t geti8(int8_t min = CHAR_MIN, int8_t max = CHAR_MAX) { return Random::s_gen.geti8(min, max); } - inline static uint64_t getui64(uint64_t min = 0, uint64_t max = ULLONG_MAX) { return Random::s_gen.getui64(min, max); } - inline static uint32_t getui32(uint32_t min = 0, uint32_t max = UINT_MAX) { return Random::s_gen.getui32(min, max); } - inline static uint16_t getui16(uint16_t min = 0, uint16_t max = USHRT_MAX) { return Random::s_gen.getui16(min, max); } - inline static uint8_t getui8(uint8_t min = 0, uint8_t max = UCHAR_MAX) { return Random::s_gen.getui8(min, max); } - inline static bool getb(float true_percentage = 0.5f) { return Random::s_gen.getb(true_percentage); } - inline static Vec2 getVec2(float min = 0.0f, float max = 1.0f, bool match_xy = false) { return Random::s_gen.getVec2(min, max, match_xy); } - inline static Vec2 getVec2(Vec2 minmax_x = { 0.0f, 1.0f }, Vec2 minmax_y = { 0.0f, 1.0f }) { return Random::s_gen.getVec2(minmax_x, minmax_y); } - inline static float getOpenSimplex2D(float x, float y) { return Random::s_gen.getOpenSimplex2D(x, y); } - - template - inline static T& getFromStdVec(std::vector& list) { return Random::s_gen.getFromStdVec(list); } - - private: - inline static RandomGenerator s_gen; - }; -} - -#endif diff --git a/Release/include/ostd/Serial.hpp b/Release/include/ostd/Serial.hpp deleted file mode 100644 index d832a3b..0000000 --- a/Release/include/ostd/Serial.hpp +++ /dev/null @@ -1,76 +0,0 @@ -#ifndef __SERIAL_HPP__ -#define __SERIAL_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - class OutputHandlerBase; - - namespace serial - { - class SerialIO - { - public: struct tEndianness { - inline static constexpr uint8_t LittleEndian = 0x00; - inline static constexpr uint8_t BigEndian = 0x01; - }; - - public: - inline SerialIO(void) { init(); } - inline SerialIO(uint64_t size, uint8_t endianness = tEndianness::BigEndian) { init(size, endianness); } - inline SerialIO(ByteStream& data, uint8_t endianness = tEndianness::BigEndian) { m_data = data; m_endianness = endianness; } - bool init(uint64_t size = SerialIO::DefaultMaxSize, uint8_t endianness = tEndianness::BigEndian); - bool r_QWord(StreamIndex addr, QWord& outVal); - bool r_DWord(StreamIndex addr, DWord& outVal); - bool r_Word(StreamIndex addr, Word& outVal); - bool r_Byte(StreamIndex addr, Byte& outVal); - bool r_Addr(StreamIndex addr, StreamIndex& outVal); - bool r_Float(StreamIndex addr, float& outVal); - bool r_Double(StreamIndex addr, double& outVal); - bool r_ByteStream(StreamIndex addr, ByteStream& outStream); - bool r_ByteStream(StreamIndex addr, ByteStream& outStream, uint32_t size); - bool r_String(StreamIndex addr, String& outString); - bool r_String(StreamIndex addr, String& outString, uint32_t size); - bool r_NullTerminatedString(StreamIndex addr, String& outString); - - bool w_QWord(StreamIndex addr, QWord val); - bool w_DWord(StreamIndex addr, DWord val); - bool w_Word(StreamIndex addr, Word val); - bool w_Byte(StreamIndex addr, Byte val); - bool w_Addr(StreamIndex addr, StreamIndex val); - bool w_Float(StreamIndex addr, float val); - bool w_Double(StreamIndex addr, double val); - bool w_ByteStream(StreamIndex addr, const ByteStream& stream, bool store_size = true); - bool w_String(StreamIndex addr, const String& str, bool store_size = false, bool null_terminate = true); - bool is_validAddr(StreamIndex addr, StreamIndex offset = 1); - inline uint64_t size(void) { return m_data.size(); } - inline ByteStream& getData(void) { return m_data; } - - void print(StreamIndex start, OutputHandlerBase& out); - bool saveToFile(const String& filePath); - - inline uint8_t getEndianness(void) const { return m_endianness; } - inline bool isLittleEndian(void) const { return m_endianness == tEndianness::LittleEndian; } - inline bool isBigEndian(void) const { return m_endianness == tEndianness::BigEndian; } - - inline bool isAutoResizeEnabled(void) const { return m_autoResize; } - inline void enableAutoResize(bool val = true, int32_t resizeAmount = 1024) { m_autoResize = val; if (!val) return; m_resizeAmount = resizeAmount; } - - private: - ByteStream m_data; - uint8_t m_endianness { tEndianness::BigEndian }; - bool m_autoResize { true }; - int32_t m_resizeAmount { 1024 }; - bool m_statuWriting { false }; - - public: - inline static constexpr uint64_t DefaultMaxSize = 512; - }; - } //namespace serial -} // namespace ostd - -#endif diff --git a/Release/include/ostd/Signals.hpp b/Release/include/ostd/Signals.hpp deleted file mode 100644 index 4913890..0000000 --- a/Release/include/ostd/Signals.hpp +++ /dev/null @@ -1,106 +0,0 @@ -#ifndef __SIGNALS_HPP__ -#define __SIGNALS_HPP__ - -#include -#include -#include -#include - -namespace ostd -{ - //INFO: (Note to self) When adding new Builtin signals, the corresponding static list must - // be addeed to the ox::SignalHandler class, and the appropriate branch must be added - // to the ox::SignalHandler::emitSignal and the ox::SignalHandler::connect functions. - // Also, correct initialization in the ox::SignalHandler::init function must be added - struct tBuiltinSignals - { - inline static constexpr uint32_t NoSignal = 0x0000; - - /** Builtin Signals **/ - inline static constexpr uint32_t KeyPressed = 0x0001; - inline static constexpr uint32_t KeyReleased = 0x0002; - inline static constexpr uint32_t MousePressed = 0x0003; - inline static constexpr uint32_t MouseReleased = 0x0004; - inline static constexpr uint32_t MouseMoved = 0x0005; - - inline static constexpr uint32_t OnGuiEvent = 0x2001; - - inline static constexpr uint32_t WindowResized = 0x1001; - /*********************/ - - inline static constexpr uint32_t CustomSignalBase = 0xFF0000; - }; - - struct tSignalPriority - { - inline static constexpr uint8_t RealTime = 0; - inline static constexpr uint8_t Normal = 1; - }; - - struct tSignal - { - const uint8_t priority; - const uint32_t ID; - bool handled { false }; - BaseObject& userData; - - inline tSignal(uint32_t id, BaseObject& _userData = BaseObject::InvalidRef(), uint8_t prio = tSignalPriority::Normal) : priority(prio), ID(id), userData(_userData) { } - }; - - class SignalHandler - { - private: struct tSignalObjPair - { - BaseObject* object { nullptr }; - uint32_t signal_id { tBuiltinSignals::NoSignal }; - }; - private: struct tDelegateSignal - { - uint32_t id; - BaseObject& ud; - - inline tDelegateSignal(uint32_t _id, BaseObject& _ud) : id(_id), ud(_ud) { } - }; - public: - static void init(void); - static void refresh(void); - - static void emitSignal(uint32_t signal_id, uint8_t prio = tSignalPriority::Normal, BaseObject& userData = BaseObject::InvalidRef()); - static void connect(BaseObject& object, uint32_t signal_id); - - inline static uint32_t newCustomSignal(uint32_t sub_id) { return tBuiltinSignals::CustomSignalBase + sub_id; } - - private: - inline static std::vector m_customRecievers; - inline static std::vector m_delegatedSignals; - - /** Builtin signal recievers lists **/ - inline static std::vector m_mousePressedRecievers; - inline static std::vector m_mouseReleasedRecievers; - inline static std::vector m_keyPressedRecievers; - inline static std::vector m_keyReleasedRecievers; - inline static std::vector m_mouseMovedRecievers; - inline static std::vector m_windowResizedRecievers; - inline static std::vector m_onGuiEventRecievers; - /************************************/ - - inline static constexpr uint16_t __SIGNAL_BUFFER_START_SIZE { 128 }; - inline static constexpr uint16_t __DELEGATED_SIGNALS_BUFFER_START_SIZE { 128 }; - }; - - class WindowSizeObj : public BaseObject - { - public: - const int32_t width; - const int32_t height; - - inline WindowSizeObj(int32_t _w, int32_t _h) : width(_w), height(_h) - { - setTypeName("ox::WindowSizeObj"); - validate(); - } - }; - -} - -#endif diff --git a/Release/include/ostd/SineWave.hpp b/Release/include/ostd/SineWave.hpp deleted file mode 100644 index 41c0512..0000000 --- a/Release/include/ostd/SineWave.hpp +++ /dev/null @@ -1,39 +0,0 @@ -#ifndef __SINE_WAVE_HPP__ -#define __SINE_WAVE_HPP__ - -#include -#include - -#include - -namespace ostd -{ - class SineWave - { - public: - inline SineWave(void) { period = 1.0f; phase = 0.0f; amplitude = 1.0f; } - inline SineWave(float pr, float am, float ph = 0.0f) { set(pr, am, ph); } - inline SineWave& set(float pr, float am, float ph = 0.0f) { period = pr; phase = ph; amplitude = am; return *this; } - inline float evaluate(float x) { return std::sin(phase + TWO_PI * x / period) * amplitude; } - - public: - float period; - float phase; - float amplitude; - }; - - class AdditiveWave : public SineWave - { - public: - inline AdditiveWave(void) { waves.clear(); } - inline AdditiveWave& addWave(SineWave wave) { waves.push_back(wave); return *this; } - inline AdditiveWave& addWave(AdditiveWave wave) { additiveWaves.push_back(wave); return *this; } - float evaluate(float x); - - public: - std::vector waves; - std::vector additiveWaves; - }; -} - -#endif diff --git a/Release/include/ostd/String.hpp b/Release/include/ostd/String.hpp deleted file mode 100644 index 2ee9871..0000000 --- a/Release/include/ostd/String.hpp +++ /dev/null @@ -1,261 +0,0 @@ -#pragma once - -#include -#include - -namespace ostd -{ - class String - { - public: class Tokens - { - public: - inline bool hasNext(void) { return m_tokens.size() > 0 && m_current_index < m_tokens.size(); } - inline bool hasPrevious(void) { return m_tokens.size() > 0 && m_current_index > 0; } - String next(void); - String previous(void); - inline uint32_t count(void) { return m_tokens.size(); } - inline std::vector getRawData(void) { return m_tokens; } - inline uint32_t getCurrentIndex(void) { return m_current_index; } - inline void cycle(void) { m_current_index = 0; } - - inline auto begin(void) { return m_tokens.begin(); } - inline auto end(void) { return m_tokens.end(); } - inline auto cbegin(void) const { return m_tokens.begin(); } - inline auto cend(void) const { return m_tokens.end(); } - inline auto begin(void) const { return m_tokens.begin(); } - inline auto end(void) const { return m_tokens.end(); } - - private: - inline Tokens(void) { m_current_index = 0; } - - private: - std::vector m_tokens; - uint32_t m_current_index; - - public: - inline static const cpp_string END = "%END%"; - - friend class String; - }; - public: enum class ePaddingBehavior { ForceEvenPositive = 1, ForceEvenNegative, AllowOddExtraLeft, AllowOddExtraRight }; - public: - inline String(void) { m_data = ""; } - inline String(const cpp_string& str) { m_data = str; } - inline String(const char* str) { m_data = str; } - - inline cpp_string cpp_str(void) const { return m_data; } - inline cpp_string& cpp_str_ref(void) { return m_data; } - inline const char* c_str(void) const { return m_data.c_str(); } - inline char at(uint32_t index) const { return m_data[index]; } - inline uint32_t len(void) const { return m_data.length(); } - inline char operator[](uint32_t index) const { return m_data[index]; } - inline bool operator== (const char* str2) const { return std::strcmp(c_str(), str2) == 0; } - inline bool operator!= (const char* str2) const { return std::strcmp(c_str(), str2) != 0; } - // friend bool operator== (const char* str1, const String& str2); - // friend bool operator!= (const char* str1, const String& str2); - inline String operator+(const String& str2) const { return m_data + str2.cpp_str(); } - friend String operator+(const cpp_string& str1, const String& str); - inline String& operator+=(const String& str2) { m_data += str2.cpp_str(); return *this; } - inline String& operator+=(const char& c) { m_data += c; return *this; } - inline operator std::string() const { return m_data; } - inline operator const char*() const { return c_str(); } - inline String& clr(void) { m_data = ""; return *this; } - inline String& set(const cpp_string& str) { m_data = str; return *this; } - - inline auto begin(void) { return m_data.begin(); } - inline auto end(void) { return m_data.end(); } - inline auto cbegin(void) const { return m_data.begin(); } - inline auto cend(void) const { return m_data.end(); } - inline auto begin(void) const { return m_data.begin(); } - inline auto end(void) const { return m_data.end(); } - - //Modifiers - String& ltrim(void); - String& rtrim(void); - String& trim(void); - String& toLower(void); - String& toUpper(void); - String& addPadding(uint32_t new_string_length, char c = ' ', ePaddingBehavior padding_behavior = ePaddingBehavior::ForceEvenPositive); - String& addLeftPadding(uint32_t new_string_length, char c = ' '); - String& addRightPadding(uint32_t new_string_length, char c = ' '); - String& reverse(void); - String& replaceAll(const String& what, const String& with); - String& replaceFirst(const String& what, const String& with); - String& regexReplace(const String& regex_pattern, const String& replace_with, bool case_insensitive = false); - String& put(uint32_t index, char c); - String& substr(uint32_t start, int32_t end = -1); - - String& addChar(char c); - String& add(const String& se); - String& add(uint8_t i); - String& add(int8_t i); - String& add(uint16_t i); - String& add(int16_t i); - String& add(uint32_t i); - String& add(int32_t i); - String& add(uint64_t i); - String& add(int64_t i); - String& add(float f, uint8_t precision = 0); - String& add(double f, uint8_t precision = 0); - - //New String - String new_ltrim(void) const; - String new_rtrim(void) const; - String new_trim(void) const; - String new_toLower(void) const; - String new_toUpper(void) const; - String new_addPadding(uint32_t new_string_length, char c = ' ', ePaddingBehavior padding_behavior = ePaddingBehavior::ForceEvenPositive) const; - String new_addLeftPadding(uint32_t new_string_length, char c = ' ') const; - String new_addRightPadding(uint32_t new_string_length, char c = ' ') const; - String new_reverse(void) const; - String new_replaceAll(const String& what, const String& with) const; - String new_replaceFirst(const String& what, const String& with) const; - String new_regexReplace(const String& regex_pattern, const String& replace_with, bool case_insensitive = false) const; - String new_put(uint32_t index, char c) const; - String new_substr(uint32_t start, int32_t end = -1) const; - - String new_addChar(char c); - String new_add(const String& se); - String new_add(uint8_t i); - String new_add(int8_t i); - String new_add(uint16_t i); - String new_add(int16_t i); - String new_add(uint32_t i); - String new_add(int32_t i); - String new_add(uint64_t i); - String new_add(int64_t i); - String new_add(float f, uint8_t precision = 0); - String new_add(double f, uint8_t precision = 0); - - //Utility - int64_t toInt(void) const; - float toFloat(void) const; - double toDouble(void) const; - bool isNumeric(bool decimal = false) const; - bool contains(char c) const; - bool contains(const String& str) const; - bool startsWith(const String& str) const; - bool endsWith(const String& str) const; - uint32_t count(const String& str) const; - int32_t indexOf(char c, uint32_t start = 0) const; - int32_t indexOf(const String& str, uint32_t start = 0) const; - int32_t lastIndexOf(char c) const; - int32_t lastIndexOf(const String& str) const; - Tokens tokenize(const String& delimiter = " ", bool trim_tokens = true, bool allow_white_space_only_tokens = false) const; - - friend std::ostream& operator<<(std::ostream& out, const String& val); - - private: - ostd::cpp_string m_data; - }; - - - - - - namespace legacy - { - class StringEditor - { - public: class Tokens - { - public: - inline bool hasNext(void) { return m_tokens.size() > 0 && m_current_index < m_tokens.size(); } - inline bool hasPrevious(void) { return m_tokens.size() > 0 && m_current_index > 0; } - String next(void); - String previous(void); - inline uint32_t count(void) { return m_tokens.size(); } - inline std::vector getRawData(void) { return m_tokens; } - inline uint32_t getCurrentIndex(void) { return m_current_index; } - inline void cycle(void) { m_current_index = 0; } - - inline auto begin(void) { return m_tokens.begin(); } - inline auto end(void) { return m_tokens.end(); } - inline auto cbegin(void) const { return m_tokens.begin(); } - inline auto cend(void) const { return m_tokens.end(); } - inline auto begin(void) const { return m_tokens.begin(); } - inline auto end(void) const { return m_tokens.end(); } - - private: - inline Tokens(void) { m_current_index = 0; } - - private: - std::vector m_tokens; - uint32_t m_current_index; - - public: - inline static const String END = "%END%"; - - friend class StringEditor; - }; - - public: - inline StringEditor(void) { m_data = ""; } - inline StringEditor(const String& str) { m_data = str; } - inline StringEditor(const char* str) { m_data = str; } - inline String str(void) const { return m_data; } - inline uint32_t len(void) const { return m_data.length(); } - inline StringEditor& clr(void) { m_data = ""; return *this; } - inline const char* c_str(void) const { return m_data.c_str(); } - inline char at(uint32_t index) const { return m_data[index]; } - inline char operator[](uint32_t index) const { return m_data[index]; } - inline StringEditor& set(String str) { m_data = str; return *this; } - - StringEditor& ltrim(void); - StringEditor& rtrim(void); - StringEditor& trim(void); - - StringEditor& toLower(void); - StringEditor& toUpper(void); - - StringEditor& addPadding(char c = ' ', uint32_t count = 10); - //StringEditor& add(const StringEditor& se); - StringEditor& add(String str); - StringEditor& add(char c); - StringEditor& addi(uint8_t i); - StringEditor& addi(int8_t i); - StringEditor& addi(uint16_t i); - StringEditor& addi(int16_t i); - StringEditor& addi(uint32_t i); - StringEditor& addi(int32_t i); - StringEditor& addi(uint64_t i); - StringEditor& addi(int64_t i); - StringEditor& addf(float f); - StringEditor& addf(double f); - - StringEditor& reverse(void); - StringEditor& replaceAll(String what, String with); - StringEditor& replaceFirst(String what, String with); - StringEditor& regexReplace(String regex_pattern, String replace_with, bool case_insensitive = false); - - StringEditor& put(uint32_t index, char c); - - int64_t toInt(void); - float toFloat(void); - double toDouble(void); - bool isNumeric(bool decimal = false); - bool contains(char c); - bool contains(String str); - bool startsWith(String str); - bool endsWith(String str); - String getReverse(void); - - uint32_t count(String str); - - int32_t indexOf(char c, uint32_t start = 0); - int32_t indexOf(String str, uint32_t start = 0); - int32_t lastIndexOf(char c); - int32_t lastIndexOf(String str); - - String substr(uint32_t start, int32_t end = -1); - Tokens tokenize(String delimiter = " ", bool trim_tokens = true, bool allow_white_space_only_tokens = false); - - friend std::ostream& operator<<(std::ostream& out, const StringEditor& val); - - private: - String m_data; - }; - } - -} \ No newline at end of file diff --git a/Release/include/ostd/TextStyleParser.hpp b/Release/include/ostd/TextStyleParser.hpp deleted file mode 100644 index 1288d6c..0000000 --- a/Release/include/ostd/TextStyleParser.hpp +++ /dev/null @@ -1,120 +0,0 @@ -#pragma once - -#include -#include - -namespace ostd -{ - class String; - class TextStyleParser - { - public: enum class eBlockParserReturnValue { CloseBlock = 0, ValidBlock, InvalidBlock }; - - public: struct tColor { - Color fullColor; - String consoleColor; - bool background; - }; - - public: struct tStyledString { - String text { "" }; - std::vector backgroundColors; - std::vector foregroundColors; - - void add(const String& str, tColor background, tColor foreground); - bool validate(void) const; - - friend std::ostream& operator<<(std::ostream&, tStyledString const&); - }; - - public: - static tStyledString parse(const String& styledString); - static tStyledString parse(const String& styledString, tColor defaultBackgorundColor, tColor defaultForegroundColor); - - static tColor convertColor(const String& name); - - private: - static bool test_for_block(const String& block_part); - static eBlockParserReturnValue parse_block(const String& blockString, tColor& outBackgroundColor, tColor& outForegroundColor); - - private: - inline static tColor s_defaultBackgroundColor; - inline static tColor s_defaultForegroundColor; - inline static const String BlockString_Close = "/"; - inline static const String BlockString_Style = "style"; - }; - - class TextStyleBuilder - { - public: class IRichStringBase { - public: - virtual TextStyleParser::tStyledString getStyledString(void) const = 0; - friend std::ostream& operator<<(std::ostream&, IRichStringBase const&); - }; - - public: class Console : public IRichStringBase { - public: - Console(void); - Console& bg(const String& consoleColor); - Console& fg(const String& consoleColor); - Console& clr(void); - Console& add(const String& text); - Console& add(uint8_t i); - Console& add(int8_t i); - Console& add(uint16_t i); - Console& add(int16_t i); - Console& add(uint32_t i); - Console& add(int32_t i); - Console& add(uint64_t i); - Console& add(int64_t i); - Console& add(float f); - Console& add(double f); - Console& addc(char c); - - Console& print(OutputHandlerBase& out); - Console& print(void); - - inline TextStyleParser::tStyledString getStyledString(void) const override { return m_styledString; } - - friend std::ostream& operator<<(std::ostream&, Console const&); - - private: - TextStyleParser::tColor find_color(const String& consoleColor); - - private: - TextStyleParser::tStyledString m_styledString; - TextStyleParser::tColor m_backgroundColor; - TextStyleParser::tColor m_foregroundColor; - }; - - public: class Regex : public IRichStringBase { - public: - inline Regex(void) { m_rawString = ""; } - inline Regex(const String& rawString) { setRawString(rawString); } - inline String getRawString(void) const { return m_rawString; } - Regex& setRawString(const String& rawString); - - Regex& fg(const String& regex, const String& foreground_color, bool case_insensitive = false); - Regex& bg(const String& regex, const String& background_color, bool case_insensitive = false); - Regex& col(const String& regex, const String& foreground_color, const String& background_color, bool case_insensitive = false); - - TextStyleParser::tStyledString getStyledString(void) const override; - - Regex& print(void); - Regex& print(OutputHandlerBase& out); - - friend std::ostream& operator<<(std::ostream&, Regex const&); - - private: - String m_rawString { "" }; - }; - - //TODO: Implement - // public: class FullColor { - - // }; - }; - - typedef TextStyleBuilder::Console ConsoleRichString; - typedef TextStyleBuilder::Regex RegexRichString; -} \ No newline at end of file diff --git a/Release/include/ostd/Types.hpp b/Release/include/ostd/Types.hpp deleted file mode 100644 index 1899d93..0000000 --- a/Release/include/ostd/Types.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef __TYPES_HPP__ -#define __TYPES_HPP__ - -#include -#include -#include - -namespace ostd -{ - namespace legacy - { - typedef std::string String; - } - typedef std::string cpp_string; - - typedef int64_t QWord; - typedef int32_t DWord; - typedef int16_t Word; - typedef int8_t Byte; - - typedef uint64_t UQWord; - typedef uint32_t UDWord; - typedef uint16_t UWord; - typedef uint8_t UByte; - - typedef uint32_t StreamIndex; - - typedef union { - float val; - Byte data[4]; - int32_t raw; - } __float_parser; - typedef union { - double val; - Byte data[8]; - int64_t raw; - } __double_parser; - - struct tTypeSize - { - static inline const uint8_t BYTE = 1; - static inline const uint8_t WORD = 2; - static inline const uint8_t DWORD = 4; - static inline const uint8_t QWORD = 8; - static inline const uint8_t ADDR = 4; - static inline const uint8_t FLOAT = 4; - static inline const uint8_t DOUBLE = 8; - }; - - typedef std::vector ByteStream; -} - - - -#endif diff --git a/Release/include/ostd/Utils.hpp b/Release/include/ostd/Utils.hpp deleted file mode 100644 index cbd518f..0000000 --- a/Release/include/ostd/Utils.hpp +++ /dev/null @@ -1,173 +0,0 @@ -#ifndef __DATATYPES__HPP__ -#define __DATATYPES__HPP__ - -#include -#include - -#include - -namespace ostd -{ - enum class eTimeUnits - { - Seconds = 0, - Milliseconds, - Microseconds, - Nanoseconds - }; - enum class eMonths - { - January = 0, - February, - March, - April, - May, - June, - July, - August, - September, - October, - November, - December - }; - - - class OutputHandlerBase; - class Timer - { - public: - inline Timer(void) { m_started = false; m_current = 0; m_timeUnit = eTimeUnits::Nanoseconds; m_dest = nullptr; } - uint64_t start(bool print = true, String name = "", eTimeUnits timeUnit = eTimeUnits::Nanoseconds, OutputHandlerBase* __destination = nullptr); - uint64_t end(bool print = true); - - static uint64_t getEpoch(eTimeUnits timeUnit = eTimeUnits::Milliseconds); - - inline const String& getName(void) const { return m_name; } - - private: - bool m_started; - int64_t m_current; - eTimeUnits m_timeUnit; - String m_name; - OutputHandlerBase* m_dest; - }; - - struct GameClock - { - public: - GameClock(void); - const float& start(void); - inline const float& getTimeOfDay(void) const { return m_timeOfDay; } - String asString(void); - void update(void); - - private: - String getFormattedTime(void); - String convertMonth(void); - - public: - uint8_t minutes; - uint8_t hours; - uint16_t days; - uint8_t months; - uint16_t years; - - private: - Timer m_rtClock; - float m_timeOfDay; - float m_totalSeconds; - }; - - class LocalTime - { - public: - String getFullString(bool include_date = true, bool include_time = true, bool day_name = true, bool month_as_name = true, bool include_seconds = true) const; - inline String getDateString(bool day_name = true, bool month_as_name = true) { return getFullString(true, false, day_name, month_as_name, false); } - inline String getTimeString(bool include_seconds = true) { return getFullString(false, true, false, false, include_seconds); } - int32_t hours(void) const; - int32_t minutes(void) const; - int32_t seconds(void) const; - int32_t day(void) const; - int32_t month(void) const; - int32_t year(void) const; - int32_t weekDay(void) const; - String shours(bool leading_zero = true) const; - String sminutes(bool leading_zero = true) const; - String sseconds(bool leading_zero = true) const; - String sday(bool leading_zero = true) const; - String smonth(bool leading_zero = true, bool month_name = true) const; - String syear(void) const; - String sWeekDay(bool day_name = true) const; - - protected: - virtual String monthToText(int32_t month) const; - virtual String weekDayToText(int32_t day) const; - }; - typedef LocalTime LocalTime_EN; - class LocalTime_IT : public LocalTime - { - protected: - String monthToText(int32_t month) const override; - String weekDayToText(int32_t day) const override; - }; - class LocalTime_ES : public LocalTime - { - protected: - String monthToText(int32_t month) const override; - String weekDayToText(int32_t day) const override; - }; - class LocalTime_DE : public LocalTime - { - protected: - String monthToText(int32_t month) const override; - String weekDayToText(int32_t day) const override; - }; - - class Utils - { - public: - //Implemented in - static inline const uint64_t getStartTime(void) { return Utils::s_startTime_ms; } - static void init(void); - static bool isHex(String hex); - static bool isBin(String bin); - static bool isInt(String str); - static int64_t strToInt(String str); - static bool readFile(String fileName, std::vector& outLines); - static String getHexStr(uint64_t value, bool prefix = true, uint8_t nbytes = 1); - static String getBinStr(uint64_t value, bool prefix = true, uint8_t nbytes = 1); - static String duplicateChar(unsigned char c, uint16_t count); - static void sleep(uint32_t __time, eTimeUnits __unit = eTimeUnits::Milliseconds); - static uint64_t getRunningTime_ms(void); - static float map_value(float input, float input_start, float input_end, float output_start, float output_end); - static bool loadFileFromHppResource(String output_file_path, const char* resource_buffer, unsigned int size); - static void printByteStream(const ByteStream& data, StreamIndex start, uint8_t line_len, uint16_t n_rows, OutputHandlerBase& out, int32_t addrHighlight = -1, uint32_t highlightRange = 1, const String& title = ""); - static bool saveByteStreamToFile(const ByteStream& stream, const String& filePath); - static bool loadByteStreamFromFile(const String& filePath, ByteStream& outStream); - static ByteStream stringToByteStream(const String& data); - static String byteStreamToString(const ByteStream& data); - - //Implemented in - static std::vector listFilesInDirectory(const String& directoryPath); - static std::vector listDirectoriesInDirectory(const String& directoryPath); - static std::vector listDirectory(const String& directoryPath); - static std::vector listFilesInDirectoryRecursive(const String& directoryPath); - static std::vector listDirectoriesInDirectoryRecursive(const String& directoryPath); - static std::vector listDirectoryRecursive(const String& directoryPath); - - //Implemented in - static int32_t solveIntegerExpression(const String& expr); - - //Implemented in - static void clearConsole(void); - static void getConsoleSize(int32_t& outColumns, int32_t& outRows); - static void setConsoleCursorPosition(int32_t x, int32_t y); - static int32_t getConsoleWidth(void); - static int32_t getConsoleHeight(void); - - private: - inline static uint64_t s_startTime_ms; - }; -} - -#endif diff --git a/Release/include/ostd/vendor/FastNoiseLite.hpp b/Release/include/ostd/vendor/FastNoiseLite.hpp deleted file mode 100644 index 526f287..0000000 --- a/Release/include/ostd/vendor/FastNoiseLite.hpp +++ /dev/null @@ -1,2586 +0,0 @@ -// MIT License -// -// Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com) -// Copyright(c) 2020 Contributors -// -// 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. -// -// .'',;:cldxkO00KKXXNNWWWNNXKOkxdollcc::::::;:::ccllloooolllllllllooollc:,'... ...........',;cldxkO000Okxdlc::;;;,,;;;::cclllllll -// ..',;:ldxO0KXXNNNNNNNNXXK0kxdolcc::::::;;;,,,,,,;;;;;;;;;;:::cclllllc:;'.... ...........',;:ldxO0KXXXK0Okxdolc::;;;;::cllodddddo -// ...',:loxO0KXNNNNNXXKK0Okxdolc::;::::::::;;;,,'''''.....''',;:clllllc:;,'............''''''''',;:loxO0KXNNNNNXK0Okxdollccccllodxxxxxxd -// ....';:ldkO0KXXXKK00Okxdolcc:;;;;;::cclllcc:;;,''..... ....',;clooddolcc:;;;;,,;;;;;::::;;;;;;:cloxk0KXNWWWWWWNXKK0Okxddoooddxxkkkkkxx -// .....';:ldxkOOOOOkxxdolcc:;;;,,,;;:cllooooolcc:;'... ..,:codxkkkxddooollloooooooollcc:::::clodkO0KXNWWWWWWNNXK00Okxxxxxxxxkkkkxxx -// . ....';:cloddddo___________,,,,;;:clooddddoolc:,... ..,:ldx__00OOOkkk___kkkkkkxxdollc::::cclodkO0KXXNNNNNNXXK0OOkxxxxxxxxxxxxddd -// .......',;:cccc:| |,,,;;:cclooddddoll:;'.. ..';cox| \KKK000| |KK00OOkxdocc___;::clldxxkO0KKKKK00Okkxdddddddddddddddoo -// .......'',,,,,''| ________|',,;;::cclloooooolc:;'......___:ldk| \KK000| |XKKK0Okxolc| |;;::cclodxxkkkkxxdoolllcclllooodddooooo -// ''......''''....| | ....'',,,,;;;::cclloooollc:;,''.'| |oxk| \OOO0| |KKK00Oxdoll|___|;;;;;::ccllllllcc::;;,,;;;:cclloooooooo -// ;;,''.......... | |_____',,;;;____:___cllo________.___| |___| \xkk| |KK_______ool___:::;________;;;_______...'',;;:ccclllloo -// c:;,''......... | |:::/ ' |lo/ | | \dx| |0/ \d| |cc/ |'/ \......',,;;:ccllo -// ol:;,'..........| _____|ll/ __ |o/ ______|____ ___| | \o| |/ ___ \| |o/ ______|/ ___ \ .......'',;:clo -// dlc;,...........| |::clooo| / | |x\___ \KXKKK0| |dol| |\ \| | | | | |d\___ \..| | / / ....',:cl -// xoc;'... .....'| |llodddd| \__| |_____\ \KKK0O| |lc:| |'\ | |___| | |_____\ \.| |_/___/... ...',;:c -// dlc;'... ....',;| |oddddddo\ | |Okkx| |::;| |..\ |\ /| | | \ |... ....',;:c -// ol:,'.......',:c|___|xxxddollc\_____,___|_________/ddoll|___|,,,|___|...\_____|:\ ______/l|___|_________/...\________|'........',;::cc -// c:;'.......';:codxxkkkkxxolc::;::clodxkOO0OOkkxdollc::;;,,''''',,,,''''''''''',,'''''',;:loxkkOOkxol:;,'''',,;:ccllcc:;,'''''',;::ccll -// ;,'.......',:codxkOO0OOkxdlc:;,,;;:cldxxkkxxdolc:;;,,''.....'',;;:::;;,,,'''''........,;cldkO0KK0Okdoc::;;::cloodddoolc:;;;;;::ccllooo -// .........',;:lodxOO0000Okdoc:,,',,;:clloddoolc:;,''.......'',;:clooollc:;;,,''.......',:ldkOKXNNXX0Oxdolllloddxxxxxxdolccccccllooodddd -// . .....';:cldxkO0000Okxol:;,''',,;::cccc:;,,'.......'',;:cldxxkkxxdolc:;;,'.......';coxOKXNWWWNXKOkxddddxxkkkkkkxdoollllooddxxxxkkk -// ....',;:codxkO000OOxdoc:;,''',,,;;;;,''.......',,;:clodkO00000Okxolc::;,,''..',;:ldxOKXNWWWNNK0OkkkkkkkkkkkxxddooooodxxkOOOOO000 -// ....',;;clodxkkOOOkkdolc:;,,,,,,,,'..........,;:clodxkO0KKXKK0Okxdolcc::;;,,,;;:codkO0XXNNNNXKK0OOOOOkkkkxxdoollloodxkO0KKKXXXXX -// -// VERSION: 1.0.1 -// https://github.com/Auburn/FastNoise - -#ifndef FASTNOISELITE_H -#define FASTNOISELITE_H - -#include - -class FastNoiseLite -{ -public: - enum NoiseType - { - NoiseType_OpenSimplex2, - NoiseType_OpenSimplex2S, - NoiseType_Cellular, - NoiseType_Perlin, - NoiseType_ValueCubic, - NoiseType_Value - }; - - enum RotationType3D - { - RotationType3D_None, - RotationType3D_ImproveXYPlanes, - RotationType3D_ImproveXZPlanes - }; - - enum FractalType - { - FractalType_None, - FractalType_FBm, - FractalType_Ridged, - FractalType_PingPong, - FractalType_DomainWarpProgressive, - FractalType_DomainWarpIndependent - }; - - enum CellularDistanceFunction - { - CellularDistanceFunction_Euclidean, - CellularDistanceFunction_EuclideanSq, - CellularDistanceFunction_Manhattan, - CellularDistanceFunction_Hybrid - }; - - enum CellularReturnType - { - CellularReturnType_CellValue, - CellularReturnType_Distance, - CellularReturnType_Distance2, - CellularReturnType_Distance2Add, - CellularReturnType_Distance2Sub, - CellularReturnType_Distance2Mul, - CellularReturnType_Distance2Div - }; - - enum DomainWarpType - { - DomainWarpType_OpenSimplex2, - DomainWarpType_OpenSimplex2Reduced, - DomainWarpType_BasicGrid - }; - - /// - /// Create new FastNoise object with optional seed - /// - FastNoiseLite(int seed = 1337) - { - mSeed = seed; - mFrequency = 0.01f; - mNoiseType = NoiseType_OpenSimplex2; - mRotationType3D = RotationType3D_None; - mTransformType3D = TransformType3D_DefaultOpenSimplex2; - - mFractalType = FractalType_None; - mOctaves = 3; - mLacunarity = 2.0f; - mGain = 0.5f; - mWeightedStrength = 0.0f; - mPingPongStrength = 2.0f; - - mFractalBounding = 1 / 1.75f; - - mCellularDistanceFunction = CellularDistanceFunction_EuclideanSq; - mCellularReturnType = CellularReturnType_Distance; - mCellularJitterModifier = 1.0f; - - mDomainWarpType = DomainWarpType_OpenSimplex2; - mWarpTransformType3D = TransformType3D_DefaultOpenSimplex2; - mDomainWarpAmp = 1.0f; - } - - /// - /// Sets seed used for all noise types - /// - /// - /// Default: 1337 - /// - void SetSeed(int seed) { mSeed = seed; } - - /// - /// Sets frequency for all noise types - /// - /// - /// Default: 0.01 - /// - void SetFrequency(float frequency) { mFrequency = frequency; } - - /// - /// Sets noise algorithm used for GetNoise(...) - /// - /// - /// Default: OpenSimplex2 - /// - void SetNoiseType(NoiseType noiseType) - { - mNoiseType = noiseType; - UpdateTransformType3D(); - } - - /// - /// Sets domain rotation type for 3D Noise and 3D DomainWarp. - /// Can aid in reducing directional artifacts when sampling a 2D plane in 3D - /// - /// - /// Default: None - /// - void SetRotationType3D(RotationType3D rotationType3D) - { - mRotationType3D = rotationType3D; - UpdateTransformType3D(); - UpdateWarpTransformType3D(); - } - - /// - /// Sets method for combining octaves in all fractal noise types - /// - /// - /// Default: None - /// Note: FractalType_DomainWarp... only affects DomainWarp(...) - /// - void SetFractalType(FractalType fractalType) { mFractalType = fractalType; } - - /// - /// Sets octave count for all fractal noise types - /// - /// - /// Default: 3 - /// - void SetFractalOctaves(int octaves) - { - mOctaves = octaves; - CalculateFractalBounding(); - } - - /// - /// Sets octave lacunarity for all fractal noise types - /// - /// - /// Default: 2.0 - /// - void SetFractalLacunarity(float lacunarity) { mLacunarity = lacunarity; } - - /// - /// Sets octave gain for all fractal noise types - /// - /// - /// Default: 0.5 - /// - void SetFractalGain(float gain) - { - mGain = gain; - CalculateFractalBounding(); - } - - /// - /// Sets octave weighting for all none DomainWarp fratal types - /// - /// - /// Default: 0.0 - /// Note: Keep between 0...1 to maintain -1...1 output bounding - /// - void SetFractalWeightedStrength(float weightedStrength) { mWeightedStrength = weightedStrength; } - - /// - /// Sets strength of the fractal ping pong effect - /// - /// - /// Default: 2.0 - /// - void SetFractalPingPongStrength(float pingPongStrength) { mPingPongStrength = pingPongStrength; } - - - /// - /// Sets distance function used in cellular noise calculations - /// - /// - /// Default: Distance - /// - void SetCellularDistanceFunction(CellularDistanceFunction cellularDistanceFunction) { mCellularDistanceFunction = cellularDistanceFunction; } - - /// - /// Sets return type from cellular noise calculations - /// - /// - /// Default: EuclideanSq - /// - void SetCellularReturnType(CellularReturnType cellularReturnType) { mCellularReturnType = cellularReturnType; } - - /// - /// Sets the maximum distance a cellular point can move from it's grid position - /// - /// - /// Default: 1.0 - /// Note: Setting this higher than 1 will cause artifacts - /// - void SetCellularJitter(float cellularJitter) { mCellularJitterModifier = cellularJitter; } - - - /// - /// Sets the warp algorithm when using DomainWarp(...) - /// - /// - /// Default: OpenSimplex2 - /// - void SetDomainWarpType(DomainWarpType domainWarpType) - { - mDomainWarpType = domainWarpType; - UpdateWarpTransformType3D(); - } - - - /// - /// Sets the maximum warp distance from original position when using DomainWarp(...) - /// - /// - /// Default: 1.0 - /// - void SetDomainWarpAmp(float domainWarpAmp) { mDomainWarpAmp = domainWarpAmp; } - - - /// - /// 2D noise at given position using current settings - /// - /// - /// Noise output bounded between -1...1 - /// - template - float GetNoise(FNfloat x, FNfloat y) - { - Arguments_must_be_floating_point_values(); - - TransformNoiseCoordinate(x, y); - - switch (mFractalType) - { - default: - return GenNoiseSingle(mSeed, x, y); - case FractalType_FBm: - return GenFractalFBm(x, y); - case FractalType_Ridged: - return GenFractalRidged(x, y); - case FractalType_PingPong: - return GenFractalPingPong(x, y); - } - } - - /// - /// 3D noise at given position using current settings - /// - /// - /// Noise output bounded between -1...1 - /// - template - float GetNoise(FNfloat x, FNfloat y, FNfloat z) - { - Arguments_must_be_floating_point_values(); - - TransformNoiseCoordinate(x, y, z); - - switch (mFractalType) - { - default: - return GenNoiseSingle(mSeed, x, y, z); - case FractalType_FBm: - return GenFractalFBm(x, y, z); - case FractalType_Ridged: - return GenFractalRidged(x, y, z); - case FractalType_PingPong: - return GenFractalPingPong(x, y, z); - } - } - - - /// - /// 2D warps the input position using current domain warp settings - /// - /// - /// Example usage with GetNoise - /// DomainWarp(x, y) - /// noise = GetNoise(x, y) - /// - template - void DomainWarp(FNfloat& x, FNfloat& y) - { - Arguments_must_be_floating_point_values(); - - switch (mFractalType) - { - default: - DomainWarpSingle(x, y); - break; - case FractalType_DomainWarpProgressive: - DomainWarpFractalProgressive(x, y); - break; - case FractalType_DomainWarpIndependent: - DomainWarpFractalIndependent(x, y); - break; - } - } - - /// - /// 3D warps the input position using current domain warp settings - /// - /// - /// Example usage with GetNoise - /// DomainWarp(x, y, z) - /// noise = GetNoise(x, y, z) - /// - template - void DomainWarp(FNfloat& x, FNfloat& y, FNfloat& z) - { - Arguments_must_be_floating_point_values(); - - switch (mFractalType) - { - default: - DomainWarpSingle(x, y, z); - break; - case FractalType_DomainWarpProgressive: - DomainWarpFractalProgressive(x, y, z); - break; - case FractalType_DomainWarpIndependent: - DomainWarpFractalIndependent(x, y, z); - break; - } - } - -private: - template - struct Arguments_must_be_floating_point_values; - - enum TransformType3D - { - TransformType3D_None, - TransformType3D_ImproveXYPlanes, - TransformType3D_ImproveXZPlanes, - TransformType3D_DefaultOpenSimplex2 - }; - - int mSeed; - float mFrequency; - NoiseType mNoiseType; - RotationType3D mRotationType3D; - TransformType3D mTransformType3D; - - FractalType mFractalType; - int mOctaves; - float mLacunarity; - float mGain; - float mWeightedStrength; - float mPingPongStrength; - - float mFractalBounding; - - CellularDistanceFunction mCellularDistanceFunction; - CellularReturnType mCellularReturnType; - float mCellularJitterModifier; - - DomainWarpType mDomainWarpType; - TransformType3D mWarpTransformType3D; - float mDomainWarpAmp; - - - template - struct Lookup - { - static const T Gradients2D[]; - static const T Gradients3D[]; - static const T RandVecs2D[]; - static const T RandVecs3D[]; - }; - - static float FastMin(float a, float b) { return a < b ? a : b; } - - static float FastMax(float a, float b) { return a > b ? a : b; } - - static float FastAbs(float f) { return f < 0 ? -f : f; } - - static float FastSqrt(float f) { return sqrtf(f); } - - template - static int FastFloor(FNfloat f) { return f >= 0 ? (int)f : (int)f - 1; } - - template - static int FastRound(FNfloat f) { return f >= 0 ? (int)(f + 0.5f) : (int)(f - 0.5f); } - - static float Lerp(float a, float b, float t) { return a + t * (b - a); } - - static float InterpHermite(float t) { return t * t * (3 - 2 * t); } - - static float InterpQuintic(float t) { return t * t * t * (t * (t * 6 - 15) + 10); } - - static float CubicLerp(float a, float b, float c, float d, float t) - { - float p = (d - c) - (a - b); - return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b; - } - - static float PingPong(float t) - { - t -= (int)(t * 0.5f) * 2; - return t < 1 ? t : 2 - t; - } - - void CalculateFractalBounding() - { - float gain = FastAbs(mGain); - float amp = gain; - float ampFractal = 1.0f; - for (int i = 1; i < mOctaves; i++) - { - ampFractal += amp; - amp *= gain; - } - mFractalBounding = 1 / ampFractal; - } - - // Hashing - static const int PrimeX = 501125321; - static const int PrimeY = 1136930381; - static const int PrimeZ = 1720413743; - - static int Hash(int seed, int xPrimed, int yPrimed) - { - int hash = seed ^ xPrimed ^ yPrimed; - - hash *= 0x27d4eb2d; - return hash; - } - - - static int Hash(int seed, int xPrimed, int yPrimed, int zPrimed) - { - int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed; - - hash *= 0x27d4eb2d; - return hash; - } - - - static float ValCoord(int seed, int xPrimed, int yPrimed) - { - int hash = Hash(seed, xPrimed, yPrimed); - - hash *= hash; - hash ^= hash << 19; - return hash * (1 / 2147483648.0f); - } - - - static float ValCoord(int seed, int xPrimed, int yPrimed, int zPrimed) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - - hash *= hash; - hash ^= hash << 19; - return hash * (1 / 2147483648.0f); - } - - - float GradCoord(int seed, int xPrimed, int yPrimed, float xd, float yd) - { - int hash = Hash(seed, xPrimed, yPrimed); - hash ^= hash >> 15; - hash &= 127 << 1; - - float xg = Lookup::Gradients2D[hash]; - float yg = Lookup::Gradients2D[hash | 1]; - - return xd * xg + yd * yg; - } - - - float GradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - hash ^= hash >> 15; - hash &= 63 << 2; - - float xg = Lookup::Gradients3D[hash]; - float yg = Lookup::Gradients3D[hash | 1]; - float zg = Lookup::Gradients3D[hash | 2]; - - return xd * xg + yd * yg + zd * zg; - } - - - void GradCoordOut(int seed, int xPrimed, int yPrimed, float& xo, float& yo) - { - int hash = Hash(seed, xPrimed, yPrimed) & (255 << 1); - - xo = Lookup::RandVecs2D[hash]; - yo = Lookup::RandVecs2D[hash | 1]; - } - - - void GradCoordOut(int seed, int xPrimed, int yPrimed, int zPrimed, float& xo, float& yo, float& zo) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed) & (255 << 2); - - xo = Lookup::RandVecs3D[hash]; - yo = Lookup::RandVecs3D[hash | 1]; - zo = Lookup::RandVecs3D[hash | 2]; - } - - - void GradCoordDual(int seed, int xPrimed, int yPrimed, float xd, float yd, float& xo, float& yo) - { - int hash = Hash(seed, xPrimed, yPrimed); - int index1 = hash & (127 << 1); - int index2 = (hash >> 7) & (255 << 1); - - float xg = Lookup::Gradients2D[index1]; - float yg = Lookup::Gradients2D[index1 | 1]; - float value = xd * xg + yd * yg; - - float xgo = Lookup::RandVecs2D[index2]; - float ygo = Lookup::RandVecs2D[index2 | 1]; - - xo = value * xgo; - yo = value * ygo; - } - - - void GradCoordDual(int seed, int xPrimed, int yPrimed, int zPrimed, float xd, float yd, float zd, float& xo, float& yo, float& zo) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - int index1 = hash & (63 << 2); - int index2 = (hash >> 6) & (255 << 2); - - float xg = Lookup::Gradients3D[index1]; - float yg = Lookup::Gradients3D[index1 | 1]; - float zg = Lookup::Gradients3D[index1 | 2]; - float value = xd * xg + yd * yg + zd * zg; - - float xgo = Lookup::RandVecs3D[index2]; - float ygo = Lookup::RandVecs3D[index2 | 1]; - float zgo = Lookup::RandVecs3D[index2 | 2]; - - xo = value * xgo; - yo = value * ygo; - zo = value * zgo; - } - - - // Generic noise gen - - template - float GenNoiseSingle(int seed, FNfloat x, FNfloat y) - { - switch (mNoiseType) - { - case NoiseType_OpenSimplex2: - return SingleSimplex(seed, x, y); - case NoiseType_OpenSimplex2S: - return SingleOpenSimplex2S(seed, x, y); - case NoiseType_Cellular: - return SingleCellular(seed, x, y); - case NoiseType_Perlin: - return SinglePerlin(seed, x, y); - case NoiseType_ValueCubic: - return SingleValueCubic(seed, x, y); - case NoiseType_Value: - return SingleValue(seed, x, y); - default: - return 0; - } - } - - template - float GenNoiseSingle(int seed, FNfloat x, FNfloat y, FNfloat z) - { - switch (mNoiseType) - { - case NoiseType_OpenSimplex2: - return SingleOpenSimplex2(seed, x, y, z); - case NoiseType_OpenSimplex2S: - return SingleOpenSimplex2S(seed, x, y, z); - case NoiseType_Cellular: - return SingleCellular(seed, x, y, z); - case NoiseType_Perlin: - return SinglePerlin(seed, x, y, z); - case NoiseType_ValueCubic: - return SingleValueCubic(seed, x, y, z); - case NoiseType_Value: - return SingleValue(seed, x, y, z); - default: - return 0; - } - } - - - // Noise Coordinate Transforms (frequency, and possible skew or rotation) - - template - void TransformNoiseCoordinate(FNfloat& x, FNfloat& y) - { - x *= mFrequency; - y *= mFrequency; - - switch (mNoiseType) - { - case NoiseType_OpenSimplex2: - case NoiseType_OpenSimplex2S: - { - const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059; - const FNfloat F2 = 0.5f * (SQRT3 - 1); - FNfloat t = (x + y) * F2; - x += t; - y += t; - } - break; - default: - break; - } - } - - template - void TransformNoiseCoordinate(FNfloat& x, FNfloat& y, FNfloat& z) - { - x *= mFrequency; - y *= mFrequency; - z *= mFrequency; - - switch (mTransformType3D) - { - case TransformType3D_ImproveXYPlanes: - { - FNfloat xy = x + y; - FNfloat s2 = xy * -(FNfloat)0.211324865405187; - z *= (FNfloat)0.577350269189626; - x += s2 - z; - y = y + s2 - z; - z += xy * (FNfloat)0.577350269189626; - } - break; - case TransformType3D_ImproveXZPlanes: - { - FNfloat xz = x + z; - FNfloat s2 = xz * -(FNfloat)0.211324865405187; - y *= (FNfloat)0.577350269189626; - x += s2 - y; - z += s2 - y; - y += xz * (FNfloat)0.577350269189626; - } - break; - case TransformType3D_DefaultOpenSimplex2: - { - const FNfloat R3 = (FNfloat)(2.0 / 3.0); - FNfloat r = (x + y + z) * R3; // Rotation, not skew - x = r - x; - y = r - y; - z = r - z; - } - break; - default: - break; - } - } - - void UpdateTransformType3D() - { - switch (mRotationType3D) - { - case RotationType3D_ImproveXYPlanes: - mTransformType3D = TransformType3D_ImproveXYPlanes; - break; - case RotationType3D_ImproveXZPlanes: - mTransformType3D = TransformType3D_ImproveXZPlanes; - break; - default: - switch (mNoiseType) - { - case NoiseType_OpenSimplex2: - case NoiseType_OpenSimplex2S: - mTransformType3D = TransformType3D_DefaultOpenSimplex2; - break; - default: - mTransformType3D = TransformType3D_None; - break; - } - break; - } - } - - - // Domain Warp Coordinate Transforms - - template - void TransformDomainWarpCoordinate(FNfloat& x, FNfloat& y) - { - switch (mDomainWarpType) - { - case DomainWarpType_OpenSimplex2: - case DomainWarpType_OpenSimplex2Reduced: - { - const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059; - const FNfloat F2 = 0.5f * (SQRT3 - 1); - FNfloat t = (x + y) * F2; - x += t; - y += t; - } - break; - default: - break; - } - } - - template - void TransformDomainWarpCoordinate(FNfloat& x, FNfloat& y, FNfloat& z) - { - switch (mWarpTransformType3D) - { - case TransformType3D_ImproveXYPlanes: - { - FNfloat xy = x + y; - FNfloat s2 = xy * -(FNfloat)0.211324865405187; - z *= (FNfloat)0.577350269189626; - x += s2 - z; - y = y + s2 - z; - z += xy * (FNfloat)0.577350269189626; - } - break; - case TransformType3D_ImproveXZPlanes: - { - FNfloat xz = x + z; - FNfloat s2 = xz * -(FNfloat)0.211324865405187; - y *= (FNfloat)0.577350269189626; - x += s2 - y; - z += s2 - y; - y += xz * (FNfloat)0.577350269189626; - } - break; - case TransformType3D_DefaultOpenSimplex2: - { - const FNfloat R3 = (FNfloat)(2.0 / 3.0); - FNfloat r = (x + y + z) * R3; // Rotation, not skew - x = r - x; - y = r - y; - z = r - z; - } - break; - default: - break; - } - } - - void UpdateWarpTransformType3D() - { - switch (mRotationType3D) - { - case RotationType3D_ImproveXYPlanes: - mWarpTransformType3D = TransformType3D_ImproveXYPlanes; - break; - case RotationType3D_ImproveXZPlanes: - mWarpTransformType3D = TransformType3D_ImproveXZPlanes; - break; - default: - switch (mDomainWarpType) - { - case DomainWarpType_OpenSimplex2: - case DomainWarpType_OpenSimplex2Reduced: - mWarpTransformType3D = TransformType3D_DefaultOpenSimplex2; - break; - default: - mWarpTransformType3D = TransformType3D_None; - break; - } - break; - } - } - - - // Fractal FBm - - template - float GenFractalFBm(FNfloat x, FNfloat y) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = GenNoiseSingle(seed++, x, y); - sum += noise * amp; - amp *= Lerp(1.0f, FastMin(noise + 1, 2) * 0.5f, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - template - float GenFractalFBm(FNfloat x, FNfloat y, FNfloat z) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = GenNoiseSingle(seed++, x, y, z); - sum += noise * amp; - amp *= Lerp(1.0f, (noise + 1) * 0.5f, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - z *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - - // Fractal Ridged - - template - float GenFractalRidged(FNfloat x, FNfloat y) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = FastAbs(GenNoiseSingle(seed++, x, y)); - sum += (noise * -2 + 1) * amp; - amp *= Lerp(1.0f, 1 - noise, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - template - float GenFractalRidged(FNfloat x, FNfloat y, FNfloat z) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = FastAbs(GenNoiseSingle(seed++, x, y, z)); - sum += (noise * -2 + 1) * amp; - amp *= Lerp(1.0f, 1 - noise, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - z *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - - // Fractal PingPong - - template - float GenFractalPingPong(FNfloat x, FNfloat y) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = PingPong((GenNoiseSingle(seed++, x, y) + 1) * mPingPongStrength); - sum += (noise - 0.5f) * 2 * amp; - amp *= Lerp(1.0f, noise, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - template - float GenFractalPingPong(FNfloat x, FNfloat y, FNfloat z) - { - int seed = mSeed; - float sum = 0; - float amp = mFractalBounding; - - for (int i = 0; i < mOctaves; i++) - { - float noise = PingPong((GenNoiseSingle(seed++, x, y, z) + 1) * mPingPongStrength); - sum += (noise - 0.5f) * 2 * amp; - amp *= Lerp(1.0f, noise, mWeightedStrength); - - x *= mLacunarity; - y *= mLacunarity; - z *= mLacunarity; - amp *= mGain; - } - - return sum; - } - - - // Simplex/OpenSimplex2 Noise - - template - float SingleSimplex(int seed, FNfloat x, FNfloat y) - { - // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex. - - const float SQRT3 = 1.7320508075688772935274463415059f; - const float G2 = (3 - SQRT3) / 6; - - /* - * --- Skew moved to TransformNoiseCoordinate method --- - * const FNfloat F2 = 0.5f * (SQRT3 - 1); - * FNfloat s = (x + y) * F2; - * x += s; y += s; - */ - - int i = FastFloor(x); - int j = FastFloor(y); - float xi = (float)(x - i); - float yi = (float)(y - j); - - float t = (xi + yi) * G2; - float x0 = (float)(xi - t); - float y0 = (float)(yi - t); - - i *= PrimeX; - j *= PrimeY; - - float n0, n1, n2; - - float a = 0.5f - x0 * x0 - y0 * y0; - if (a <= 0) n0 = 0; - else - { - n0 = (a * a) * (a * a) * GradCoord(seed, i, j, x0, y0); - } - - float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a); - if (c <= 0) n2 = 0; - else - { - float x2 = x0 + (2 * (float)G2 - 1); - float y2 = y0 + (2 * (float)G2 - 1); - n2 = (c * c) * (c * c) * GradCoord(seed, i + PrimeX, j + PrimeY, x2, y2); - } - - if (y0 > x0) - { - float x1 = x0 + (float)G2; - float y1 = y0 + ((float)G2 - 1); - float b = 0.5f - x1 * x1 - y1 * y1; - if (b <= 0) n1 = 0; - else - { - n1 = (b * b) * (b * b) * GradCoord(seed, i, j + PrimeY, x1, y1); - } - } - else - { - float x1 = x0 + ((float)G2 - 1); - float y1 = y0 + (float)G2; - float b = 0.5f - x1 * x1 - y1 * y1; - if (b <= 0) n1 = 0; - else - { - n1 = (b * b) * (b * b) * GradCoord(seed, i + PrimeX, j, x1, y1); - } - } - - return (n0 + n1 + n2) * 99.83685446303647f; - } - - template - float SingleOpenSimplex2(int seed, FNfloat x, FNfloat y, FNfloat z) - { - // 3D OpenSimplex2 case uses two offset rotated cube grids. - - /* - * --- Rotation moved to TransformNoiseCoordinate method --- - * const FNfloat R3 = (FNfloat)(2.0 / 3.0); - * FNfloat r = (x + y + z) * R3; // Rotation, not skew - * x = r - x; y = r - y; z = r - z; - */ - - int i = FastRound(x); - int j = FastRound(y); - int k = FastRound(z); - float x0 = (float)(x - i); - float y0 = (float)(y - j); - float z0 = (float)(z - k); - - int xNSign = (int)(-1.0f - x0) | 1; - int yNSign = (int)(-1.0f - y0) | 1; - int zNSign = (int)(-1.0f - z0) | 1; - - float ax0 = xNSign * -x0; - float ay0 = yNSign * -y0; - float az0 = zNSign * -z0; - - i *= PrimeX; - j *= PrimeY; - k *= PrimeZ; - - float value = 0; - float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0); - - for (int l = 0; ; l++) - { - if (a > 0) - { - value += (a * a) * (a * a) * GradCoord(seed, i, j, k, x0, y0, z0); - } - - float b = a + 1; - int i1 = i; - int j1 = j; - int k1 = k; - float x1 = x0; - float y1 = y0; - float z1 = z0; - - if (ax0 >= ay0 && ax0 >= az0) - { - x1 += xNSign; - b -= xNSign * 2 * x1; - i1 -= xNSign * PrimeX; - } - else if (ay0 > ax0 && ay0 >= az0) - { - y1 += yNSign; - b -= yNSign * 2 * y1; - j1 -= yNSign * PrimeY; - } - else - { - z1 += zNSign; - b -= zNSign * 2 * z1; - k1 -= zNSign * PrimeZ; - } - - if (b > 0) - { - value += (b * b) * (b * b) * GradCoord(seed, i1, j1, k1, x1, y1, z1); - } - - if (l == 1) break; - - ax0 = 0.5f - ax0; - ay0 = 0.5f - ay0; - az0 = 0.5f - az0; - - x0 = xNSign * ax0; - y0 = yNSign * ay0; - z0 = zNSign * az0; - - a += (0.75f - ax0) - (ay0 + az0); - - i += (xNSign >> 1) & PrimeX; - j += (yNSign >> 1) & PrimeY; - k += (zNSign >> 1) & PrimeZ; - - xNSign = -xNSign; - yNSign = -yNSign; - zNSign = -zNSign; - - seed = ~seed; - } - - return value * 32.69428253173828125f; - } - - - // OpenSimplex2S Noise - - template - float SingleOpenSimplex2S(int seed, FNfloat x, FNfloat y) - { - // 2D OpenSimplex2S case is a modified 2D simplex noise. - - const FNfloat SQRT3 = (FNfloat)1.7320508075688772935274463415059; - const FNfloat G2 = (3 - SQRT3) / 6; - - /* - * --- Skew moved to TransformNoiseCoordinate method --- - * const FNfloat F2 = 0.5f * (SQRT3 - 1); - * FNfloat s = (x + y) * F2; - * x += s; y += s; - */ - - int i = FastFloor(x); - int j = FastFloor(y); - float xi = (float)(x - i); - float yi = (float)(y - j); - - i *= PrimeX; - j *= PrimeY; - int i1 = i + PrimeX; - int j1 = j + PrimeY; - - float t = (xi + yi) * (float)G2; - float x0 = xi - t; - float y0 = yi - t; - - float a0 = (2.0f / 3.0f) - x0 * x0 - y0 * y0; - float value = (a0 * a0) * (a0 * a0) * GradCoord(seed, i, j, x0, y0); - - float a1 = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0); - float x1 = x0 - (float)(1 - 2 * G2); - float y1 = y0 - (float)(1 - 2 * G2); - value += (a1 * a1) * (a1 * a1) * GradCoord(seed, i1, j1, x1, y1); - - // Nested conditionals were faster than compact bit logic/arithmetic. - float xmyi = xi - yi; - if (t > G2) - { - if (xi + xmyi > 1) - { - float x2 = x0 + (float)(3 * G2 - 2); - float y2 = y0 + (float)(3 * G2 - 1); - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + (PrimeX << 1), j + PrimeY, x2, y2); - } - } - else - { - float x2 = x0 + (float)G2; - float y2 = y0 + (float)(G2 - 1); - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2); - } - } - - if (yi - xmyi > 1) - { - float x3 = x0 + (float)(3 * G2 - 1); - float y3 = y0 + (float)(3 * G2 - 2); - float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3; - if (a3 > 0) - { - value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j + (PrimeY << 1), x3, y3); - } - } - else - { - float x3 = x0 + (float)(G2 - 1); - float y3 = y0 + (float)G2; - float a3 = (2.0f / 3.0f) - x3 * x3 - y3 * y3; - if (a3 > 0) - { - value += (a3 * a3) * (a3 * a3) * GradCoord(seed, i + PrimeX, j, x3, y3); - } - } - } - else - { - if (xi + xmyi < 0) - { - float x2 = x0 + (float)(1 - G2); - float y2 = y0 - (float)G2; - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i - PrimeX, j, x2, y2); - } - } - else - { - float x2 = x0 + (float)(G2 - 1); - float y2 = y0 + (float)G2; - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i + PrimeX, j, x2, y2); - } - } - - if (yi < xmyi) - { - float x2 = x0 - (float)G2; - float y2 = y0 - (float)(G2 - 1); - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j - PrimeY, x2, y2); - } - } - else - { - float x2 = x0 + (float)G2; - float y2 = y0 + (float)(G2 - 1); - float a2 = (2.0f / 3.0f) - x2 * x2 - y2 * y2; - if (a2 > 0) - { - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, i, j + PrimeY, x2, y2); - } - } - } - - return value * 18.24196194486065f; - } - - template - float SingleOpenSimplex2S(int seed, FNfloat x, FNfloat y, FNfloat z) - { - // 3D OpenSimplex2S case uses two offset rotated cube grids. - - /* - * --- Rotation moved to TransformNoiseCoordinate method --- - * const FNfloat R3 = (FNfloat)(2.0 / 3.0); - * FNfloat r = (x + y + z) * R3; // Rotation, not skew - * x = r - x; y = r - y; z = r - z; - */ - - int i = FastFloor(x); - int j = FastFloor(y); - int k = FastFloor(z); - float xi = (float)(x - i); - float yi = (float)(y - j); - float zi = (float)(z - k); - - i *= PrimeX; - j *= PrimeY; - k *= PrimeZ; - int seed2 = seed + 1293373; - - int xNMask = (int)(-0.5f - xi); - int yNMask = (int)(-0.5f - yi); - int zNMask = (int)(-0.5f - zi); - - float x0 = xi + xNMask; - float y0 = yi + yNMask; - float z0 = zi + zNMask; - float a0 = 0.75f - x0 * x0 - y0 * y0 - z0 * z0; - float value = (a0 * a0) * (a0 * a0) * GradCoord(seed, - i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x0, y0, z0); - - float x1 = xi - 0.5f; - float y1 = yi - 0.5f; - float z1 = zi - 0.5f; - float a1 = 0.75f - x1 * x1 - y1 * y1 - z1 * z1; - value += (a1 * a1) * (a1 * a1) * GradCoord(seed2, - i + PrimeX, j + PrimeY, k + PrimeZ, x1, y1, z1); - - float xAFlipMask0 = ((xNMask | 1) << 1) * x1; - float yAFlipMask0 = ((yNMask | 1) << 1) * y1; - float zAFlipMask0 = ((zNMask | 1) << 1) * z1; - float xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0f; - float yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0f; - float zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0f; - - bool skip5 = false; - float a2 = xAFlipMask0 + a0; - if (a2 > 0) - { - float x2 = x0 - (xNMask | 1); - float y2 = y0; - float z2 = z0; - value += (a2 * a2) * (a2 * a2) * GradCoord(seed, - i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (zNMask & PrimeZ), x2, y2, z2); - } - else - { - float a3 = yAFlipMask0 + zAFlipMask0 + a0; - if (a3 > 0) - { - float x3 = x0; - float y3 = y0 - (yNMask | 1); - float z3 = z0 - (zNMask | 1); - value += (a3 * a3) * (a3 * a3) * GradCoord(seed, - i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (~zNMask & PrimeZ), x3, y3, z3); - } - - float a4 = xAFlipMask1 + a1; - if (a4 > 0) - { - float x4 = (xNMask | 1) + x1; - float y4 = y1; - float z4 = z1; - value += (a4 * a4) * (a4 * a4) * GradCoord(seed2, - i + (xNMask & (PrimeX * 2)), j + PrimeY, k + PrimeZ, x4, y4, z4); - skip5 = true; - } - } - - bool skip9 = false; - float a6 = yAFlipMask0 + a0; - if (a6 > 0) - { - float x6 = x0; - float y6 = y0 - (yNMask | 1); - float z6 = z0; - value += (a6 * a6) * (a6 * a6) * GradCoord(seed, - i + (xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), x6, y6, z6); - } - else - { - float a7 = xAFlipMask0 + zAFlipMask0 + a0; - if (a7 > 0) - { - float x7 = x0 - (xNMask | 1); - float y7 = y0; - float z7 = z0 - (zNMask | 1); - value += (a7 * a7) * (a7 * a7) * GradCoord(seed, - i + (~xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), x7, y7, z7); - } - - float a8 = yAFlipMask1 + a1; - if (a8 > 0) - { - float x8 = x1; - float y8 = (yNMask | 1) + y1; - float z8 = z1; - value += (a8 * a8) * (a8 * a8) * GradCoord(seed2, - i + PrimeX, j + (yNMask & (PrimeY << 1)), k + PrimeZ, x8, y8, z8); - skip9 = true; - } - } - - bool skipD = false; - float aA = zAFlipMask0 + a0; - if (aA > 0) - { - float xA = x0; - float yA = y0; - float zA = z0 - (zNMask | 1); - value += (aA * aA) * (aA * aA) * GradCoord(seed, - i + (xNMask & PrimeX), j + (yNMask & PrimeY), k + (~zNMask & PrimeZ), xA, yA, zA); - } - else - { - float aB = xAFlipMask0 + yAFlipMask0 + a0; - if (aB > 0) - { - float xB = x0 - (xNMask | 1); - float yB = y0 - (yNMask | 1); - float zB = z0; - value += (aB * aB) * (aB * aB) * GradCoord(seed, - i + (~xNMask & PrimeX), j + (~yNMask & PrimeY), k + (zNMask & PrimeZ), xB, yB, zB); - } - - float aC = zAFlipMask1 + a1; - if (aC > 0) - { - float xC = x1; - float yC = y1; - float zC = (zNMask | 1) + z1; - value += (aC * aC) * (aC * aC) * GradCoord(seed2, - i + PrimeX, j + PrimeY, k + (zNMask & (PrimeZ << 1)), xC, yC, zC); - skipD = true; - } - } - - if (!skip5) - { - float a5 = yAFlipMask1 + zAFlipMask1 + a1; - if (a5 > 0) - { - float x5 = x1; - float y5 = (yNMask | 1) + y1; - float z5 = (zNMask | 1) + z1; - value += (a5 * a5) * (a5 * a5) * GradCoord(seed2, - i + PrimeX, j + (yNMask & (PrimeY << 1)), k + (zNMask & (PrimeZ << 1)), x5, y5, z5); - } - } - - if (!skip9) - { - float a9 = xAFlipMask1 + zAFlipMask1 + a1; - if (a9 > 0) - { - float x9 = (xNMask | 1) + x1; - float y9 = y1; - float z9 = (zNMask | 1) + z1; - value += (a9 * a9) * (a9 * a9) * GradCoord(seed2, - i + (xNMask & (PrimeX * 2)), j + PrimeY, k + (zNMask & (PrimeZ << 1)), x9, y9, z9); - } - } - - if (!skipD) - { - float aD = xAFlipMask1 + yAFlipMask1 + a1; - if (aD > 0) - { - float xD = (xNMask | 1) + x1; - float yD = (yNMask | 1) + y1; - float zD = z1; - value += (aD * aD) * (aD * aD) * GradCoord(seed2, - i + (xNMask & (PrimeX << 1)), j + (yNMask & (PrimeY << 1)), k + PrimeZ, xD, yD, zD); - } - } - - return value * 9.046026385208288f; - } - - - // Cellular Noise - - template - float SingleCellular(int seed, FNfloat x, FNfloat y) - { - int xr = FastRound(x); - int yr = FastRound(y); - - float distance0 = 1e10f; - float distance1 = 1e10f; - int closestHash = 0; - - float cellularJitter = 0.43701595f * mCellularJitterModifier; - - int xPrimed = (xr - 1) * PrimeX; - int yPrimedBase = (yr - 1) * PrimeY; - - switch (mCellularDistanceFunction) - { - default: - case CellularDistanceFunction_Euclidean: - case CellularDistanceFunction_EuclideanSq: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int hash = Hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - float vecX = (float)(xi - x) + Lookup::RandVecs2D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs2D[idx | 1] * cellularJitter; - - float newDistance = vecX * vecX + vecY * vecY; - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - case CellularDistanceFunction_Manhattan: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int hash = Hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - float vecX = (float)(xi - x) + Lookup::RandVecs2D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs2D[idx | 1] * cellularJitter; - - float newDistance = FastAbs(vecX) + FastAbs(vecY); - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - case CellularDistanceFunction_Hybrid: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int hash = Hash(seed, xPrimed, yPrimed); - int idx = hash & (255 << 1); - - float vecX = (float)(xi - x) + Lookup::RandVecs2D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs2D[idx | 1] * cellularJitter; - - float newDistance = (FastAbs(vecX) + FastAbs(vecY)) + (vecX * vecX + vecY * vecY); - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - } - - if (mCellularDistanceFunction == CellularDistanceFunction_Euclidean && mCellularReturnType >= CellularReturnType_Distance) - { - distance0 = FastSqrt(distance0); - - if (mCellularReturnType >= CellularReturnType_Distance2) - { - distance1 = FastSqrt(distance1); - } - } - - switch (mCellularReturnType) - { - case CellularReturnType_CellValue: - return closestHash * (1 / 2147483648.0f); - case CellularReturnType_Distance: - return distance0 - 1; - case CellularReturnType_Distance2: - return distance1 - 1; - case CellularReturnType_Distance2Add: - return (distance1 + distance0) * 0.5f - 1; - case CellularReturnType_Distance2Sub: - return distance1 - distance0 - 1; - case CellularReturnType_Distance2Mul: - return distance1 * distance0 * 0.5f - 1; - case CellularReturnType_Distance2Div: - return distance0 / distance1 - 1; - default: - return 0; - } - } - - template - float SingleCellular(int seed, FNfloat x, FNfloat y, FNfloat z) - { - int xr = FastRound(x); - int yr = FastRound(y); - int zr = FastRound(z); - - float distance0 = 1e10f; - float distance1 = 1e10f; - int closestHash = 0; - - float cellularJitter = 0.39614353f * mCellularJitterModifier; - - int xPrimed = (xr - 1) * PrimeX; - int yPrimedBase = (yr - 1) * PrimeY; - int zPrimedBase = (zr - 1) * PrimeZ; - - switch (mCellularDistanceFunction) - { - case CellularDistanceFunction_Euclidean: - case CellularDistanceFunction_EuclideanSq: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int zPrimed = zPrimedBase; - - for (int zi = zr - 1; zi <= zr + 1; zi++) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - float vecX = (float)(xi - x) + Lookup::RandVecs3D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; - float vecZ = (float)(zi - z) + Lookup::RandVecs3D[idx | 2] * cellularJitter; - - float newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ; - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - zPrimed += PrimeZ; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - case CellularDistanceFunction_Manhattan: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int zPrimed = zPrimedBase; - - for (int zi = zr - 1; zi <= zr + 1; zi++) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - float vecX = (float)(xi - x) + Lookup::RandVecs3D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; - float vecZ = (float)(zi - z) + Lookup::RandVecs3D[idx | 2] * cellularJitter; - - float newDistance = FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ); - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - zPrimed += PrimeZ; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - case CellularDistanceFunction_Hybrid: - for (int xi = xr - 1; xi <= xr + 1; xi++) - { - int yPrimed = yPrimedBase; - - for (int yi = yr - 1; yi <= yr + 1; yi++) - { - int zPrimed = zPrimedBase; - - for (int zi = zr - 1; zi <= zr + 1; zi++) - { - int hash = Hash(seed, xPrimed, yPrimed, zPrimed); - int idx = hash & (255 << 2); - - float vecX = (float)(xi - x) + Lookup::RandVecs3D[idx] * cellularJitter; - float vecY = (float)(yi - y) + Lookup::RandVecs3D[idx | 1] * cellularJitter; - float vecZ = (float)(zi - z) + Lookup::RandVecs3D[idx | 2] * cellularJitter; - - float newDistance = (FastAbs(vecX) + FastAbs(vecY) + FastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ); - - distance1 = FastMax(FastMin(distance1, newDistance), distance0); - if (newDistance < distance0) - { - distance0 = newDistance; - closestHash = hash; - } - zPrimed += PrimeZ; - } - yPrimed += PrimeY; - } - xPrimed += PrimeX; - } - break; - default: - break; - } - - if (mCellularDistanceFunction == CellularDistanceFunction_Euclidean && mCellularReturnType >= CellularReturnType_Distance) - { - distance0 = FastSqrt(distance0); - - if (mCellularReturnType >= CellularReturnType_Distance2) - { - distance1 = FastSqrt(distance1); - } - } - - switch (mCellularReturnType) - { - case CellularReturnType_CellValue: - return closestHash * (1 / 2147483648.0f); - case CellularReturnType_Distance: - return distance0 - 1; - case CellularReturnType_Distance2: - return distance1 - 1; - case CellularReturnType_Distance2Add: - return (distance1 + distance0) * 0.5f - 1; - case CellularReturnType_Distance2Sub: - return distance1 - distance0 - 1; - case CellularReturnType_Distance2Mul: - return distance1 * distance0 * 0.5f - 1; - case CellularReturnType_Distance2Div: - return distance0 / distance1 - 1; - default: - return 0; - } - } - - - // Perlin Noise - - template - float SinglePerlin(int seed, FNfloat x, FNfloat y) - { - int x0 = FastFloor(x); - int y0 = FastFloor(y); - - float xd0 = (float)(x - x0); - float yd0 = (float)(y - y0); - float xd1 = xd0 - 1; - float yd1 = yd0 - 1; - - float xs = InterpQuintic(xd0); - float ys = InterpQuintic(yd0); - - x0 *= PrimeX; - y0 *= PrimeY; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - - float xf0 = Lerp(GradCoord(seed, x0, y0, xd0, yd0), GradCoord(seed, x1, y0, xd1, yd0), xs); - float xf1 = Lerp(GradCoord(seed, x0, y1, xd0, yd1), GradCoord(seed, x1, y1, xd1, yd1), xs); - - return Lerp(xf0, xf1, ys) * 1.4247691104677813f; - } - - template - float SinglePerlin(int seed, FNfloat x, FNfloat y, FNfloat z) - { - int x0 = FastFloor(x); - int y0 = FastFloor(y); - int z0 = FastFloor(z); - - float xd0 = (float)(x - x0); - float yd0 = (float)(y - y0); - float zd0 = (float)(z - z0); - float xd1 = xd0 - 1; - float yd1 = yd0 - 1; - float zd1 = zd0 - 1; - - float xs = InterpQuintic(xd0); - float ys = InterpQuintic(yd0); - float zs = InterpQuintic(zd0); - - x0 *= PrimeX; - y0 *= PrimeY; - z0 *= PrimeZ; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - int z1 = z0 + PrimeZ; - - float xf00 = Lerp(GradCoord(seed, x0, y0, z0, xd0, yd0, zd0), GradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs); - float xf10 = Lerp(GradCoord(seed, x0, y1, z0, xd0, yd1, zd0), GradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs); - float xf01 = Lerp(GradCoord(seed, x0, y0, z1, xd0, yd0, zd1), GradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs); - float xf11 = Lerp(GradCoord(seed, x0, y1, z1, xd0, yd1, zd1), GradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs); - - float yf0 = Lerp(xf00, xf10, ys); - float yf1 = Lerp(xf01, xf11, ys); - - return Lerp(yf0, yf1, zs) * 0.964921414852142333984375f; - } - - - // Value Cubic Noise - - template - float SingleValueCubic(int seed, FNfloat x, FNfloat y) - { - int x1 = FastFloor(x); - int y1 = FastFloor(y); - - float xs = (float)(x - x1); - float ys = (float)(y - y1); - - x1 *= PrimeX; - y1 *= PrimeY; - int x0 = x1 - PrimeX; - int y0 = y1 - PrimeY; - int x2 = x1 + PrimeX; - int y2 = y1 + PrimeY; - int x3 = x1 + (int)((long)PrimeX << 1); - int y3 = y1 + (int)((long)PrimeY << 1); - - return CubicLerp( - CubicLerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), ValCoord(seed, x2, y0), ValCoord(seed, x3, y0), - xs), - CubicLerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), ValCoord(seed, x2, y1), ValCoord(seed, x3, y1), - xs), - CubicLerp(ValCoord(seed, x0, y2), ValCoord(seed, x1, y2), ValCoord(seed, x2, y2), ValCoord(seed, x3, y2), - xs), - CubicLerp(ValCoord(seed, x0, y3), ValCoord(seed, x1, y3), ValCoord(seed, x2, y3), ValCoord(seed, x3, y3), - xs), - ys) * (1 / (1.5f * 1.5f)); - } - - template - float SingleValueCubic(int seed, FNfloat x, FNfloat y, FNfloat z) - { - int x1 = FastFloor(x); - int y1 = FastFloor(y); - int z1 = FastFloor(z); - - float xs = (float)(x - x1); - float ys = (float)(y - y1); - float zs = (float)(z - z1); - - x1 *= PrimeX; - y1 *= PrimeY; - z1 *= PrimeZ; - - int x0 = x1 - PrimeX; - int y0 = y1 - PrimeY; - int z0 = z1 - PrimeZ; - int x2 = x1 + PrimeX; - int y2 = y1 + PrimeY; - int z2 = z1 + PrimeZ; - int x3 = x1 + (int)((long)PrimeX << 1); - int y3 = y1 + (int)((long)PrimeY << 1); - int z3 = z1 + (int)((long)PrimeZ << 1); - - - return CubicLerp( - CubicLerp( - CubicLerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), ValCoord(seed, x2, y0, z0), ValCoord(seed, x3, y0, z0), xs), - CubicLerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), ValCoord(seed, x2, y1, z0), ValCoord(seed, x3, y1, z0), xs), - CubicLerp(ValCoord(seed, x0, y2, z0), ValCoord(seed, x1, y2, z0), ValCoord(seed, x2, y2, z0), ValCoord(seed, x3, y2, z0), xs), - CubicLerp(ValCoord(seed, x0, y3, z0), ValCoord(seed, x1, y3, z0), ValCoord(seed, x2, y3, z0), ValCoord(seed, x3, y3, z0), xs), - ys), - CubicLerp( - CubicLerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), ValCoord(seed, x2, y0, z1), ValCoord(seed, x3, y0, z1), xs), - CubicLerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), ValCoord(seed, x2, y1, z1), ValCoord(seed, x3, y1, z1), xs), - CubicLerp(ValCoord(seed, x0, y2, z1), ValCoord(seed, x1, y2, z1), ValCoord(seed, x2, y2, z1), ValCoord(seed, x3, y2, z1), xs), - CubicLerp(ValCoord(seed, x0, y3, z1), ValCoord(seed, x1, y3, z1), ValCoord(seed, x2, y3, z1), ValCoord(seed, x3, y3, z1), xs), - ys), - CubicLerp( - CubicLerp(ValCoord(seed, x0, y0, z2), ValCoord(seed, x1, y0, z2), ValCoord(seed, x2, y0, z2), ValCoord(seed, x3, y0, z2), xs), - CubicLerp(ValCoord(seed, x0, y1, z2), ValCoord(seed, x1, y1, z2), ValCoord(seed, x2, y1, z2), ValCoord(seed, x3, y1, z2), xs), - CubicLerp(ValCoord(seed, x0, y2, z2), ValCoord(seed, x1, y2, z2), ValCoord(seed, x2, y2, z2), ValCoord(seed, x3, y2, z2), xs), - CubicLerp(ValCoord(seed, x0, y3, z2), ValCoord(seed, x1, y3, z2), ValCoord(seed, x2, y3, z2), ValCoord(seed, x3, y3, z2), xs), - ys), - CubicLerp( - CubicLerp(ValCoord(seed, x0, y0, z3), ValCoord(seed, x1, y0, z3), ValCoord(seed, x2, y0, z3), ValCoord(seed, x3, y0, z3), xs), - CubicLerp(ValCoord(seed, x0, y1, z3), ValCoord(seed, x1, y1, z3), ValCoord(seed, x2, y1, z3), ValCoord(seed, x3, y1, z3), xs), - CubicLerp(ValCoord(seed, x0, y2, z3), ValCoord(seed, x1, y2, z3), ValCoord(seed, x2, y2, z3), ValCoord(seed, x3, y2, z3), xs), - CubicLerp(ValCoord(seed, x0, y3, z3), ValCoord(seed, x1, y3, z3), ValCoord(seed, x2, y3, z3), ValCoord(seed, x3, y3, z3), xs), - ys), - zs) * (1 / (1.5f * 1.5f * 1.5f)); - } - - - // Value Noise - - template - float SingleValue(int seed, FNfloat x, FNfloat y) - { - int x0 = FastFloor(x); - int y0 = FastFloor(y); - - float xs = InterpHermite((float)(x - x0)); - float ys = InterpHermite((float)(y - y0)); - - x0 *= PrimeX; - y0 *= PrimeY; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - - float xf0 = Lerp(ValCoord(seed, x0, y0), ValCoord(seed, x1, y0), xs); - float xf1 = Lerp(ValCoord(seed, x0, y1), ValCoord(seed, x1, y1), xs); - - return Lerp(xf0, xf1, ys); - } - - template - float SingleValue(int seed, FNfloat x, FNfloat y, FNfloat z) - { - int x0 = FastFloor(x); - int y0 = FastFloor(y); - int z0 = FastFloor(z); - - float xs = InterpHermite((float)(x - x0)); - float ys = InterpHermite((float)(y - y0)); - float zs = InterpHermite((float)(z - z0)); - - x0 *= PrimeX; - y0 *= PrimeY; - z0 *= PrimeZ; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - int z1 = z0 + PrimeZ; - - float xf00 = Lerp(ValCoord(seed, x0, y0, z0), ValCoord(seed, x1, y0, z0), xs); - float xf10 = Lerp(ValCoord(seed, x0, y1, z0), ValCoord(seed, x1, y1, z0), xs); - float xf01 = Lerp(ValCoord(seed, x0, y0, z1), ValCoord(seed, x1, y0, z1), xs); - float xf11 = Lerp(ValCoord(seed, x0, y1, z1), ValCoord(seed, x1, y1, z1), xs); - - float yf0 = Lerp(xf00, xf10, ys); - float yf1 = Lerp(xf01, xf11, ys); - - return Lerp(yf0, yf1, zs); - } - - - // Domain Warp - - template - void DoSingleDomainWarp(int seed, float amp, float freq, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr) - { - switch (mDomainWarpType) - { - case DomainWarpType_OpenSimplex2: - SingleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375f, freq, x, y, xr, yr, false); - break; - case DomainWarpType_OpenSimplex2Reduced: - SingleDomainWarpSimplexGradient(seed, amp * 16.0f, freq, x, y, xr, yr, true); - break; - case DomainWarpType_BasicGrid: - SingleDomainWarpBasicGrid(seed, amp, freq, x, y, xr, yr); - break; - } - } - - template - void DoSingleDomainWarp(int seed, float amp, float freq, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr) - { - switch (mDomainWarpType) - { - case DomainWarpType_OpenSimplex2: - SingleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125f, freq, x, y, z, xr, yr, zr, false); - break; - case DomainWarpType_OpenSimplex2Reduced: - SingleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605f, freq, x, y, z, xr, yr, zr, true); - break; - case DomainWarpType_BasicGrid: - SingleDomainWarpBasicGrid(seed, amp, freq, x, y, z, xr, yr, zr); - break; - } - } - - - // Domain Warp Single Wrapper - - template - void DomainWarpSingle(FNfloat& x, FNfloat& y) - { - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - FNfloat xs = x; - FNfloat ys = y; - TransformDomainWarpCoordinate(xs, ys); - - DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y); - } - - template - void DomainWarpSingle(FNfloat& x, FNfloat& y, FNfloat& z) - { - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - FNfloat xs = x; - FNfloat ys = y; - FNfloat zs = z; - TransformDomainWarpCoordinate(xs, ys, zs); - - DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z); - } - - - // Domain Warp Fractal Progressive - - template - void DomainWarpFractalProgressive(FNfloat& x, FNfloat& y) - { - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - for (int i = 0; i < mOctaves; i++) - { - FNfloat xs = x; - FNfloat ys = y; - TransformDomainWarpCoordinate(xs, ys); - - DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y); - - seed++; - amp *= mGain; - freq *= mLacunarity; - } - } - - template - void DomainWarpFractalProgressive(FNfloat& x, FNfloat& y, FNfloat& z) - { - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - for (int i = 0; i < mOctaves; i++) - { - FNfloat xs = x; - FNfloat ys = y; - FNfloat zs = z; - TransformDomainWarpCoordinate(xs, ys, zs); - - DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z); - - seed++; - amp *= mGain; - freq *= mLacunarity; - } - } - - - // Domain Warp Fractal Independant - - template - void DomainWarpFractalIndependent(FNfloat& x, FNfloat& y) - { - FNfloat xs = x; - FNfloat ys = y; - TransformDomainWarpCoordinate(xs, ys); - - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - for (int i = 0; i < mOctaves; i++) - { - DoSingleDomainWarp(seed, amp, freq, xs, ys, x, y); - - seed++; - amp *= mGain; - freq *= mLacunarity; - } - } - - template - void DomainWarpFractalIndependent(FNfloat& x, FNfloat& y, FNfloat& z) - { - FNfloat xs = x; - FNfloat ys = y; - FNfloat zs = z; - TransformDomainWarpCoordinate(xs, ys, zs); - - int seed = mSeed; - float amp = mDomainWarpAmp * mFractalBounding; - float freq = mFrequency; - - for (int i = 0; i < mOctaves; i++) - { - DoSingleDomainWarp(seed, amp, freq, xs, ys, zs, x, y, z); - - seed++; - amp *= mGain; - freq *= mLacunarity; - } - } - - - // Domain Warp Basic Grid - - template - void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr) - { - FNfloat xf = x * frequency; - FNfloat yf = y * frequency; - - int x0 = FastFloor(xf); - int y0 = FastFloor(yf); - - float xs = InterpHermite((float)(xf - x0)); - float ys = InterpHermite((float)(yf - y0)); - - x0 *= PrimeX; - y0 *= PrimeY; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - - int hash0 = Hash(seed, x0, y0) & (255 << 1); - int hash1 = Hash(seed, x1, y0) & (255 << 1); - - float lx0x = Lerp(Lookup::RandVecs2D[hash0], Lookup::RandVecs2D[hash1], xs); - float ly0x = Lerp(Lookup::RandVecs2D[hash0 | 1], Lookup::RandVecs2D[hash1 | 1], xs); - - hash0 = Hash(seed, x0, y1) & (255 << 1); - hash1 = Hash(seed, x1, y1) & (255 << 1); - - float lx1x = Lerp(Lookup::RandVecs2D[hash0], Lookup::RandVecs2D[hash1], xs); - float ly1x = Lerp(Lookup::RandVecs2D[hash0 | 1], Lookup::RandVecs2D[hash1 | 1], xs); - - xr += Lerp(lx0x, lx1x, ys) * warpAmp; - yr += Lerp(ly0x, ly1x, ys) * warpAmp; - } - - template - void SingleDomainWarpBasicGrid(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr) - { - FNfloat xf = x * frequency; - FNfloat yf = y * frequency; - FNfloat zf = z * frequency; - - int x0 = FastFloor(xf); - int y0 = FastFloor(yf); - int z0 = FastFloor(zf); - - float xs = InterpHermite((float)(xf - x0)); - float ys = InterpHermite((float)(yf - y0)); - float zs = InterpHermite((float)(zf - z0)); - - x0 *= PrimeX; - y0 *= PrimeY; - z0 *= PrimeZ; - int x1 = x0 + PrimeX; - int y1 = y0 + PrimeY; - int z1 = z0 + PrimeZ; - - int hash0 = Hash(seed, x0, y0, z0) & (255 << 2); - int hash1 = Hash(seed, x1, y0, z0) & (255 << 2); - - float lx0x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); - float ly0x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); - float lz0x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); - - hash0 = Hash(seed, x0, y1, z0) & (255 << 2); - hash1 = Hash(seed, x1, y1, z0) & (255 << 2); - - float lx1x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); - float ly1x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); - float lz1x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); - - float lx0y = Lerp(lx0x, lx1x, ys); - float ly0y = Lerp(ly0x, ly1x, ys); - float lz0y = Lerp(lz0x, lz1x, ys); - - hash0 = Hash(seed, x0, y0, z1) & (255 << 2); - hash1 = Hash(seed, x1, y0, z1) & (255 << 2); - - lx0x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); - ly0x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); - lz0x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); - - hash0 = Hash(seed, x0, y1, z1) & (255 << 2); - hash1 = Hash(seed, x1, y1, z1) & (255 << 2); - - lx1x = Lerp(Lookup::RandVecs3D[hash0], Lookup::RandVecs3D[hash1], xs); - ly1x = Lerp(Lookup::RandVecs3D[hash0 | 1], Lookup::RandVecs3D[hash1 | 1], xs); - lz1x = Lerp(Lookup::RandVecs3D[hash0 | 2], Lookup::RandVecs3D[hash1 | 2], xs); - - xr += Lerp(lx0y, Lerp(lx0x, lx1x, ys), zs) * warpAmp; - yr += Lerp(ly0y, Lerp(ly0x, ly1x, ys), zs) * warpAmp; - zr += Lerp(lz0y, Lerp(lz0x, lz1x, ys), zs) * warpAmp; - } - - - // Domain Warp Simplex/OpenSimplex2 - - template - void SingleDomainWarpSimplexGradient(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat& xr, FNfloat& yr, bool outGradOnly) - { - const float SQRT3 = 1.7320508075688772935274463415059f; - const float G2 = (3 - SQRT3) / 6; - - x *= frequency; - y *= frequency; - - /* - * --- Skew moved to TransformNoiseCoordinate method --- - * const FNfloat F2 = 0.5f * (SQRT3 - 1); - * FNfloat s = (x + y) * F2; - * x += s; y += s; - */ - - int i = FastFloor(x); - int j = FastFloor(y); - float xi = (float)(x - i); - float yi = (float)(y - j); - - float t = (xi + yi) * G2; - float x0 = (float)(xi - t); - float y0 = (float)(yi - t); - - i *= PrimeX; - j *= PrimeY; - - float vx, vy; - vx = vy = 0; - - float a = 0.5f - x0 * x0 - y0 * y0; - if (a > 0) - { - float aaaa = (a * a) * (a * a); - float xo, yo; - if (outGradOnly) - GradCoordOut(seed, i, j, xo, yo); - else - GradCoordDual(seed, i, j, x0, y0, xo, yo); - vx += aaaa * xo; - vy += aaaa * yo; - } - - float c = (float)(2 * (1 - 2 * G2) * (1 / G2 - 2)) * t + ((float)(-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a); - if (c > 0) - { - float x2 = x0 + (2 * (float)G2 - 1); - float y2 = y0 + (2 * (float)G2 - 1); - float cccc = (c * c) * (c * c); - float xo, yo; - if (outGradOnly) - GradCoordOut(seed, i + PrimeX, j + PrimeY, xo, yo); - else - GradCoordDual(seed, i + PrimeX, j + PrimeY, x2, y2, xo, yo); - vx += cccc * xo; - vy += cccc * yo; - } - - if (y0 > x0) - { - float x1 = x0 + (float)G2; - float y1 = y0 + ((float)G2 - 1); - float b = 0.5f - x1 * x1 - y1 * y1; - if (b > 0) - { - float bbbb = (b * b) * (b * b); - float xo, yo; - if (outGradOnly) - GradCoordOut(seed, i, j + PrimeY, xo, yo); - else - GradCoordDual(seed, i, j + PrimeY, x1, y1, xo, yo); - vx += bbbb * xo; - vy += bbbb * yo; - } - } - else - { - float x1 = x0 + ((float)G2 - 1); - float y1 = y0 + (float)G2; - float b = 0.5f - x1 * x1 - y1 * y1; - if (b > 0) - { - float bbbb = (b * b) * (b * b); - float xo, yo; - if (outGradOnly) - GradCoordOut(seed, i + PrimeX, j, xo, yo); - else - GradCoordDual(seed, i + PrimeX, j, x1, y1, xo, yo); - vx += bbbb * xo; - vy += bbbb * yo; - } - } - - xr += vx * warpAmp; - yr += vy * warpAmp; - } - - template - void SingleDomainWarpOpenSimplex2Gradient(int seed, float warpAmp, float frequency, FNfloat x, FNfloat y, FNfloat z, FNfloat& xr, FNfloat& yr, FNfloat& zr, bool outGradOnly) - { - x *= frequency; - y *= frequency; - z *= frequency; - - /* - * --- Rotation moved to TransformDomainWarpCoordinate method --- - * const FNfloat R3 = (FNfloat)(2.0 / 3.0); - * FNfloat r = (x + y + z) * R3; // Rotation, not skew - * x = r - x; y = r - y; z = r - z; - */ - - int i = FastRound(x); - int j = FastRound(y); - int k = FastRound(z); - float x0 = (float)x - i; - float y0 = (float)y - j; - float z0 = (float)z - k; - - int xNSign = (int)(-x0 - 1.0f) | 1; - int yNSign = (int)(-y0 - 1.0f) | 1; - int zNSign = (int)(-z0 - 1.0f) | 1; - - float ax0 = xNSign * -x0; - float ay0 = yNSign * -y0; - float az0 = zNSign * -z0; - - i *= PrimeX; - j *= PrimeY; - k *= PrimeZ; - - float vx, vy, vz; - vx = vy = vz = 0; - - float a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0); - for (int l = 0; l < 2; l++) - { - if (a > 0) - { - float aaaa = (a * a) * (a * a); - float xo, yo, zo; - if (outGradOnly) - GradCoordOut(seed, i, j, k, xo, yo, zo); - else - GradCoordDual(seed, i, j, k, x0, y0, z0, xo, yo, zo); - vx += aaaa * xo; - vy += aaaa * yo; - vz += aaaa * zo; - } - - float b = a + 1; - int i1 = i; - int j1 = j; - int k1 = k; - float x1 = x0; - float y1 = y0; - float z1 = z0; - - if (ax0 >= ay0 && ax0 >= az0) - { - x1 += xNSign; - b -= xNSign * 2 * x1; - i1 -= xNSign * PrimeX; - } - else if (ay0 > ax0 && ay0 >= az0) - { - y1 += yNSign; - b -= yNSign * 2 * y1; - j1 -= yNSign * PrimeY; - } - else - { - z1 += zNSign; - b -= zNSign * 2 * z1; - k1 -= zNSign * PrimeZ; - } - - if (b > 0) - { - float bbbb = (b * b) * (b * b); - float xo, yo, zo; - if (outGradOnly) - GradCoordOut(seed, i1, j1, k1, xo, yo, zo); - else - GradCoordDual(seed, i1, j1, k1, x1, y1, z1, xo, yo, zo); - vx += bbbb * xo; - vy += bbbb * yo; - vz += bbbb * zo; - } - - if (l == 1) break; - - ax0 = 0.5f - ax0; - ay0 = 0.5f - ay0; - az0 = 0.5f - az0; - - x0 = xNSign * ax0; - y0 = yNSign * ay0; - z0 = zNSign * az0; - - a += (0.75f - ax0) - (ay0 + az0); - - i += (xNSign >> 1) & PrimeX; - j += (yNSign >> 1) & PrimeY; - k += (zNSign >> 1) & PrimeZ; - - xNSign = -xNSign; - yNSign = -yNSign; - zNSign = -zNSign; - - seed += 1293373; - } - - xr += vx * warpAmp; - yr += vy * warpAmp; - zr += vz * warpAmp; - } -}; - -template <> -struct FastNoiseLite::Arguments_must_be_floating_point_values {}; -template <> -struct FastNoiseLite::Arguments_must_be_floating_point_values {}; -template <> -struct FastNoiseLite::Arguments_must_be_floating_point_values {}; - -template -const T FastNoiseLite::Lookup::Gradients2D[] = -{ - 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, - 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, - 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, - -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, - -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, - -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, - 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, - 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, - 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, - -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, - -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, - -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, - 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, - 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, - 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, - -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, - -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, - -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, - 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, - 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, - 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, - -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, - -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, - -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, - 0.130526192220052f, 0.99144486137381f, 0.38268343236509f, 0.923879532511287f, 0.608761429008721f, 0.793353340291235f, 0.793353340291235f, 0.608761429008721f, - 0.923879532511287f, 0.38268343236509f, 0.99144486137381f, 0.130526192220051f, 0.99144486137381f, -0.130526192220051f, 0.923879532511287f, -0.38268343236509f, - 0.793353340291235f, -0.60876142900872f, 0.608761429008721f, -0.793353340291235f, 0.38268343236509f, -0.923879532511287f, 0.130526192220052f, -0.99144486137381f, - -0.130526192220052f, -0.99144486137381f, -0.38268343236509f, -0.923879532511287f, -0.608761429008721f, -0.793353340291235f, -0.793353340291235f, -0.608761429008721f, - -0.923879532511287f, -0.38268343236509f, -0.99144486137381f, -0.130526192220052f, -0.99144486137381f, 0.130526192220051f, -0.923879532511287f, 0.38268343236509f, - -0.793353340291235f, 0.608761429008721f, -0.608761429008721f, 0.793353340291235f, -0.38268343236509f, 0.923879532511287f, -0.130526192220052f, 0.99144486137381f, - 0.38268343236509f, 0.923879532511287f, 0.923879532511287f, 0.38268343236509f, 0.923879532511287f, -0.38268343236509f, 0.38268343236509f, -0.923879532511287f, - -0.38268343236509f, -0.923879532511287f, -0.923879532511287f, -0.38268343236509f, -0.923879532511287f, 0.38268343236509f, -0.38268343236509f, 0.923879532511287f, -}; - -template -const T FastNoiseLite::Lookup::RandVecs2D[] = -{ - -0.2700222198f, -0.9628540911f, 0.3863092627f, -0.9223693152f, 0.04444859006f, -0.999011673f, -0.5992523158f, -0.8005602176f, -0.7819280288f, 0.6233687174f, 0.9464672271f, 0.3227999196f, -0.6514146797f, -0.7587218957f, 0.9378472289f, 0.347048376f, - -0.8497875957f, -0.5271252623f, -0.879042592f, 0.4767432447f, -0.892300288f, -0.4514423508f, -0.379844434f, -0.9250503802f, -0.9951650832f, 0.0982163789f, 0.7724397808f, -0.6350880136f, 0.7573283322f, -0.6530343002f, -0.9928004525f, -0.119780055f, - -0.0532665713f, 0.9985803285f, 0.9754253726f, -0.2203300762f, -0.7665018163f, 0.6422421394f, 0.991636706f, 0.1290606184f, -0.994696838f, 0.1028503788f, -0.5379205513f, -0.84299554f, 0.5022815471f, -0.8647041387f, 0.4559821461f, -0.8899889226f, - -0.8659131224f, -0.5001944266f, 0.0879458407f, -0.9961252577f, -0.5051684983f, 0.8630207346f, 0.7753185226f, -0.6315704146f, -0.6921944612f, 0.7217110418f, -0.5191659449f, -0.8546734591f, 0.8978622882f, -0.4402764035f, -0.1706774107f, 0.9853269617f, - -0.9353430106f, -0.3537420705f, -0.9992404798f, 0.03896746794f, -0.2882064021f, -0.9575683108f, -0.9663811329f, 0.2571137995f, -0.8759714238f, -0.4823630009f, -0.8303123018f, -0.5572983775f, 0.05110133755f, -0.9986934731f, -0.8558373281f, -0.5172450752f, - 0.09887025282f, 0.9951003332f, 0.9189016087f, 0.3944867976f, -0.2439375892f, -0.9697909324f, -0.8121409387f, -0.5834613061f, -0.9910431363f, 0.1335421355f, 0.8492423985f, -0.5280031709f, -0.9717838994f, -0.2358729591f, 0.9949457207f, 0.1004142068f, - 0.6241065508f, -0.7813392434f, 0.662910307f, 0.7486988212f, -0.7197418176f, 0.6942418282f, -0.8143370775f, -0.5803922158f, 0.104521054f, -0.9945226741f, -0.1065926113f, -0.9943027784f, 0.445799684f, -0.8951327509f, 0.105547406f, 0.9944142724f, - -0.992790267f, 0.1198644477f, -0.8334366408f, 0.552615025f, 0.9115561563f, -0.4111755999f, 0.8285544909f, -0.5599084351f, 0.7217097654f, -0.6921957921f, 0.4940492677f, -0.8694339084f, -0.3652321272f, -0.9309164803f, -0.9696606758f, 0.2444548501f, - 0.08925509731f, -0.996008799f, 0.5354071276f, -0.8445941083f, -0.1053576186f, 0.9944343981f, -0.9890284586f, 0.1477251101f, 0.004856104961f, 0.9999882091f, 0.9885598478f, 0.1508291331f, 0.9286129562f, -0.3710498316f, -0.5832393863f, -0.8123003252f, - 0.3015207509f, 0.9534596146f, -0.9575110528f, 0.2883965738f, 0.9715802154f, -0.2367105511f, 0.229981792f, 0.9731949318f, 0.955763816f, -0.2941352207f, 0.740956116f, 0.6715534485f, -0.9971513787f, -0.07542630764f, 0.6905710663f, -0.7232645452f, - -0.290713703f, -0.9568100872f, 0.5912777791f, -0.8064679708f, -0.9454592212f, -0.325740481f, 0.6664455681f, 0.74555369f, 0.6236134912f, 0.7817328275f, 0.9126993851f, -0.4086316587f, -0.8191762011f, 0.5735419353f, -0.8812745759f, -0.4726046147f, - 0.9953313627f, 0.09651672651f, 0.9855650846f, -0.1692969699f, -0.8495980887f, 0.5274306472f, 0.6174853946f, -0.7865823463f, 0.8508156371f, 0.52546432f, 0.9985032451f, -0.05469249926f, 0.1971371563f, -0.9803759185f, 0.6607855748f, -0.7505747292f, - -0.03097494063f, 0.9995201614f, -0.6731660801f, 0.739491331f, -0.7195018362f, -0.6944905383f, 0.9727511689f, 0.2318515979f, 0.9997059088f, -0.0242506907f, 0.4421787429f, -0.8969269532f, 0.9981350961f, -0.061043673f, -0.9173660799f, -0.3980445648f, - -0.8150056635f, -0.5794529907f, -0.8789331304f, 0.4769450202f, 0.0158605829f, 0.999874213f, -0.8095464474f, 0.5870558317f, -0.9165898907f, -0.3998286786f, -0.8023542565f, 0.5968480938f, -0.5176737917f, 0.8555780767f, -0.8154407307f, -0.5788405779f, - 0.4022010347f, -0.9155513791f, -0.9052556868f, -0.4248672045f, 0.7317445619f, 0.6815789728f, -0.5647632201f, -0.8252529947f, -0.8403276335f, -0.5420788397f, -0.9314281527f, 0.363925262f, 0.5238198472f, 0.8518290719f, 0.7432803869f, -0.6689800195f, - -0.985371561f, -0.1704197369f, 0.4601468731f, 0.88784281f, 0.825855404f, 0.5638819483f, 0.6182366099f, 0.7859920446f, 0.8331502863f, -0.553046653f, 0.1500307506f, 0.9886813308f, -0.662330369f, -0.7492119075f, -0.668598664f, 0.743623444f, - 0.7025606278f, 0.7116238924f, -0.5419389763f, -0.8404178401f, -0.3388616456f, 0.9408362159f, 0.8331530315f, 0.5530425174f, -0.2989720662f, -0.9542618632f, 0.2638522993f, 0.9645630949f, 0.124108739f, -0.9922686234f, -0.7282649308f, -0.6852956957f, - 0.6962500149f, 0.7177993569f, -0.9183535368f, 0.3957610156f, -0.6326102274f, -0.7744703352f, -0.9331891859f, -0.359385508f, -0.1153779357f, -0.9933216659f, 0.9514974788f, -0.3076565421f, -0.08987977445f, -0.9959526224f, 0.6678496916f, 0.7442961705f, - 0.7952400393f, -0.6062947138f, -0.6462007402f, -0.7631674805f, -0.2733598753f, 0.9619118351f, 0.9669590226f, -0.254931851f, -0.9792894595f, 0.2024651934f, -0.5369502995f, -0.8436138784f, -0.270036471f, -0.9628500944f, -0.6400277131f, 0.7683518247f, - -0.7854537493f, -0.6189203566f, 0.06005905383f, -0.9981948257f, -0.02455770378f, 0.9996984141f, -0.65983623f, 0.751409442f, -0.6253894466f, -0.7803127835f, -0.6210408851f, -0.7837781695f, 0.8348888491f, 0.5504185768f, -0.1592275245f, 0.9872419133f, - 0.8367622488f, 0.5475663786f, -0.8675753916f, -0.4973056806f, -0.2022662628f, -0.9793305667f, 0.9399189937f, 0.3413975472f, 0.9877404807f, -0.1561049093f, -0.9034455656f, 0.4287028224f, 0.1269804218f, -0.9919052235f, -0.3819600854f, 0.924178821f, - 0.9754625894f, 0.2201652486f, -0.3204015856f, -0.9472818081f, -0.9874760884f, 0.1577687387f, 0.02535348474f, -0.9996785487f, 0.4835130794f, -0.8753371362f, -0.2850799925f, -0.9585037287f, -0.06805516006f, -0.99768156f, -0.7885244045f, -0.6150034663f, - 0.3185392127f, -0.9479096845f, 0.8880043089f, 0.4598351306f, 0.6476921488f, -0.7619021462f, 0.9820241299f, 0.1887554194f, 0.9357275128f, -0.3527237187f, -0.8894895414f, 0.4569555293f, 0.7922791302f, 0.6101588153f, 0.7483818261f, 0.6632681526f, - -0.7288929755f, -0.6846276581f, 0.8729032783f, -0.4878932944f, 0.8288345784f, 0.5594937369f, 0.08074567077f, 0.9967347374f, 0.9799148216f, -0.1994165048f, -0.580730673f, -0.8140957471f, -0.4700049791f, -0.8826637636f, 0.2409492979f, 0.9705377045f, - 0.9437816757f, -0.3305694308f, -0.8927998638f, -0.4504535528f, -0.8069622304f, 0.5906030467f, 0.06258973166f, 0.9980393407f, -0.9312597469f, 0.3643559849f, 0.5777449785f, 0.8162173362f, -0.3360095855f, -0.941858566f, 0.697932075f, -0.7161639607f, - -0.002008157227f, -0.9999979837f, -0.1827294312f, -0.9831632392f, -0.6523911722f, 0.7578824173f, -0.4302626911f, -0.9027037258f, -0.9985126289f, -0.05452091251f, -0.01028102172f, -0.9999471489f, -0.4946071129f, 0.8691166802f, -0.2999350194f, 0.9539596344f, - 0.8165471961f, 0.5772786819f, 0.2697460475f, 0.962931498f, -0.7306287391f, -0.6827749597f, -0.7590952064f, -0.6509796216f, -0.907053853f, 0.4210146171f, -0.5104861064f, -0.8598860013f, 0.8613350597f, 0.5080373165f, 0.5007881595f, -0.8655698812f, - -0.654158152f, 0.7563577938f, -0.8382755311f, -0.545246856f, 0.6940070834f, 0.7199681717f, 0.06950936031f, 0.9975812994f, 0.1702942185f, -0.9853932612f, 0.2695973274f, 0.9629731466f, 0.5519612192f, -0.8338697815f, 0.225657487f, -0.9742067022f, - 0.4215262855f, -0.9068161835f, 0.4881873305f, -0.8727388672f, -0.3683854996f, -0.9296731273f, -0.9825390578f, 0.1860564427f, 0.81256471f, 0.5828709909f, 0.3196460933f, -0.9475370046f, 0.9570913859f, 0.2897862643f, -0.6876655497f, -0.7260276109f, - -0.9988770922f, -0.047376731f, -0.1250179027f, 0.992154486f, -0.8280133617f, 0.560708367f, 0.9324863769f, -0.3612051451f, 0.6394653183f, 0.7688199442f, -0.01623847064f, -0.9998681473f, -0.9955014666f, -0.09474613458f, -0.81453315f, 0.580117012f, - 0.4037327978f, -0.9148769469f, 0.9944263371f, 0.1054336766f, -0.1624711654f, 0.9867132919f, -0.9949487814f, -0.100383875f, -0.6995302564f, 0.7146029809f, 0.5263414922f, -0.85027327f, -0.5395221479f, 0.841971408f, 0.6579370318f, 0.7530729462f, - 0.01426758847f, -0.9998982128f, -0.6734383991f, 0.7392433447f, 0.639412098f, -0.7688642071f, 0.9211571421f, 0.3891908523f, -0.146637214f, -0.9891903394f, -0.782318098f, 0.6228791163f, -0.5039610839f, -0.8637263605f, -0.7743120191f, -0.6328039957f, -}; - -template -const T FastNoiseLite::Lookup::Gradients3D[] = -{ - 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, - 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, - 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, - 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, - 0, 1, 1, 0, 0,-1, 1, 0, 0, 1,-1, 0, 0,-1,-1, 0, - 1, 0, 1, 0, -1, 0, 1, 0, 1, 0,-1, 0, -1, 0,-1, 0, - 1, 1, 0, 0, -1, 1, 0, 0, 1,-1, 0, 0, -1,-1, 0, 0, - 1, 1, 0, 0, 0,-1, 1, 0, -1, 1, 0, 0, 0,-1,-1, 0 -}; - -template -const T FastNoiseLite::Lookup::RandVecs3D[] = -{ - -0.7292736885f, -0.6618439697f, 0.1735581948f, 0, 0.790292081f, -0.5480887466f, -0.2739291014f, 0, 0.7217578935f, 0.6226212466f, -0.3023380997f, 0, 0.565683137f, -0.8208298145f, -0.0790000257f, 0, 0.760049034f, -0.5555979497f, -0.3370999617f, 0, 0.3713945616f, 0.5011264475f, 0.7816254623f, 0, -0.1277062463f, -0.4254438999f, -0.8959289049f, 0, -0.2881560924f, -0.5815838982f, 0.7607405838f, 0, - 0.5849561111f, -0.662820239f, -0.4674352136f, 0, 0.3307171178f, 0.0391653737f, 0.94291689f, 0, 0.8712121778f, -0.4113374369f, -0.2679381538f, 0, 0.580981015f, 0.7021915846f, 0.4115677815f, 0, 0.503756873f, 0.6330056931f, -0.5878203852f, 0, 0.4493712205f, 0.601390195f, 0.6606022552f, 0, -0.6878403724f, 0.09018890807f, -0.7202371714f, 0, -0.5958956522f, -0.6469350577f, 0.475797649f, 0, - -0.5127052122f, 0.1946921978f, -0.8361987284f, 0, -0.9911507142f, -0.05410276466f, -0.1212153153f, 0, -0.2149721042f, 0.9720882117f, -0.09397607749f, 0, -0.7518650936f, -0.5428057603f, 0.3742469607f, 0, 0.5237068895f, 0.8516377189f, -0.02107817834f, 0, 0.6333504779f, 0.1926167129f, -0.7495104896f, 0, -0.06788241606f, 0.3998305789f, 0.9140719259f, 0, -0.5538628599f, -0.4729896695f, -0.6852128902f, 0, - -0.7261455366f, -0.5911990757f, 0.3509933228f, 0, -0.9229274737f, -0.1782808786f, 0.3412049336f, 0, -0.6968815002f, 0.6511274338f, 0.3006480328f, 0, 0.9608044783f, -0.2098363234f, -0.1811724921f, 0, 0.06817146062f, -0.9743405129f, 0.2145069156f, 0, -0.3577285196f, -0.6697087264f, -0.6507845481f, 0, -0.1868621131f, 0.7648617052f, -0.6164974636f, 0, -0.6541697588f, 0.3967914832f, 0.6439087246f, 0, - 0.6993340405f, -0.6164538506f, 0.3618239211f, 0, -0.1546665739f, 0.6291283928f, 0.7617583057f, 0, -0.6841612949f, -0.2580482182f, -0.6821542638f, 0, 0.5383980957f, 0.4258654885f, 0.7271630328f, 0, -0.5026987823f, -0.7939832935f, -0.3418836993f, 0, 0.3202971715f, 0.2834415347f, 0.9039195862f, 0, 0.8683227101f, -0.0003762656404f, -0.4959995258f, 0, 0.791120031f, -0.08511045745f, 0.6057105799f, 0, - -0.04011016052f, -0.4397248749f, 0.8972364289f, 0, 0.9145119872f, 0.3579346169f, -0.1885487608f, 0, -0.9612039066f, -0.2756484276f, 0.01024666929f, 0, 0.6510361721f, -0.2877799159f, -0.7023778346f, 0, -0.2041786351f, 0.7365237271f, 0.644859585f, 0, -0.7718263711f, 0.3790626912f, 0.5104855816f, 0, -0.3060082741f, -0.7692987727f, 0.5608371729f, 0, 0.454007341f, -0.5024843065f, 0.7357899537f, 0, - 0.4816795475f, 0.6021208291f, -0.6367380315f, 0, 0.6961980369f, -0.3222197429f, 0.641469197f, 0, -0.6532160499f, -0.6781148932f, 0.3368515753f, 0, 0.5089301236f, -0.6154662304f, -0.6018234363f, 0, -0.1635919754f, -0.9133604627f, -0.372840892f, 0, 0.52408019f, -0.8437664109f, 0.1157505864f, 0, 0.5902587356f, 0.4983817807f, -0.6349883666f, 0, 0.5863227872f, 0.494764745f, 0.6414307729f, 0, - 0.6779335087f, 0.2341345225f, 0.6968408593f, 0, 0.7177054546f, -0.6858979348f, 0.120178631f, 0, -0.5328819713f, -0.5205125012f, 0.6671608058f, 0, -0.8654874251f, -0.0700727088f, -0.4960053754f, 0, -0.2861810166f, 0.7952089234f, 0.5345495242f, 0, -0.04849529634f, 0.9810836427f, -0.1874115585f, 0, -0.6358521667f, 0.6058348682f, 0.4781800233f, 0, 0.6254794696f, -0.2861619734f, 0.7258696564f, 0, - -0.2585259868f, 0.5061949264f, -0.8227581726f, 0, 0.02136306781f, 0.5064016808f, -0.8620330371f, 0, 0.200111773f, 0.8599263484f, 0.4695550591f, 0, 0.4743561372f, 0.6014985084f, -0.6427953014f, 0, 0.6622993731f, -0.5202474575f, -0.5391679918f, 0, 0.08084972818f, -0.6532720452f, 0.7527940996f, 0, -0.6893687501f, 0.0592860349f, 0.7219805347f, 0, -0.1121887082f, -0.9673185067f, 0.2273952515f, 0, - 0.7344116094f, 0.5979668656f, -0.3210532909f, 0, 0.5789393465f, -0.2488849713f, 0.7764570201f, 0, 0.6988182827f, 0.3557169806f, -0.6205791146f, 0, -0.8636845529f, -0.2748771249f, -0.4224826141f, 0, -0.4247027957f, -0.4640880967f, 0.777335046f, 0, 0.5257722489f, -0.8427017621f, 0.1158329937f, 0, 0.9343830603f, 0.316302472f, -0.1639543925f, 0, -0.1016836419f, -0.8057303073f, -0.5834887393f, 0, - -0.6529238969f, 0.50602126f, -0.5635892736f, 0, -0.2465286165f, -0.9668205684f, -0.06694497494f, 0, -0.9776897119f, -0.2099250524f, -0.007368825344f, 0, 0.7736893337f, 0.5734244712f, 0.2694238123f, 0, -0.6095087895f, 0.4995678998f, 0.6155736747f, 0, 0.5794535482f, 0.7434546771f, 0.3339292269f, 0, -0.8226211154f, 0.08142581855f, 0.5627293636f, 0, -0.510385483f, 0.4703667658f, 0.7199039967f, 0, - -0.5764971849f, -0.07231656274f, -0.8138926898f, 0, 0.7250628871f, 0.3949971505f, -0.5641463116f, 0, -0.1525424005f, 0.4860840828f, -0.8604958341f, 0, -0.5550976208f, -0.4957820792f, 0.667882296f, 0, -0.1883614327f, 0.9145869398f, 0.357841725f, 0, 0.7625556724f, -0.5414408243f, -0.3540489801f, 0, -0.5870231946f, -0.3226498013f, -0.7424963803f, 0, 0.3051124198f, 0.2262544068f, -0.9250488391f, 0, - 0.6379576059f, 0.577242424f, -0.5097070502f, 0, -0.5966775796f, 0.1454852398f, -0.7891830656f, 0, -0.658330573f, 0.6555487542f, -0.3699414651f, 0, 0.7434892426f, 0.2351084581f, 0.6260573129f, 0, 0.5562114096f, 0.8264360377f, -0.0873632843f, 0, -0.3028940016f, -0.8251527185f, 0.4768419182f, 0, 0.1129343818f, -0.985888439f, -0.1235710781f, 0, 0.5937652891f, -0.5896813806f, 0.5474656618f, 0, - 0.6757964092f, -0.5835758614f, -0.4502648413f, 0, 0.7242302609f, -0.1152719764f, 0.6798550586f, 0, -0.9511914166f, 0.0753623979f, -0.2992580792f, 0, 0.2539470961f, -0.1886339355f, 0.9486454084f, 0, 0.571433621f, -0.1679450851f, -0.8032795685f, 0, -0.06778234979f, 0.3978269256f, 0.9149531629f, 0, 0.6074972649f, 0.733060024f, -0.3058922593f, 0, -0.5435478392f, 0.1675822484f, 0.8224791405f, 0, - -0.5876678086f, -0.3380045064f, -0.7351186982f, 0, -0.7967562402f, 0.04097822706f, -0.6029098428f, 0, -0.1996350917f, 0.8706294745f, 0.4496111079f, 0, -0.02787660336f, -0.9106232682f, -0.4122962022f, 0, -0.7797625996f, -0.6257634692f, 0.01975775581f, 0, -0.5211232846f, 0.7401644346f, -0.4249554471f, 0, 0.8575424857f, 0.4053272873f, -0.3167501783f, 0, 0.1045223322f, 0.8390195772f, -0.5339674439f, 0, - 0.3501822831f, 0.9242524096f, -0.1520850155f, 0, 0.1987849858f, 0.07647613266f, 0.9770547224f, 0, 0.7845996363f, 0.6066256811f, -0.1280964233f, 0, 0.09006737436f, -0.9750989929f, -0.2026569073f, 0, -0.8274343547f, -0.542299559f, 0.1458203587f, 0, -0.3485797732f, -0.415802277f, 0.840000362f, 0, -0.2471778936f, -0.7304819962f, -0.6366310879f, 0, -0.3700154943f, 0.8577948156f, 0.3567584454f, 0, - 0.5913394901f, -0.548311967f, -0.5913303597f, 0, 0.1204873514f, -0.7626472379f, -0.6354935001f, 0, 0.616959265f, 0.03079647928f, 0.7863922953f, 0, 0.1258156836f, -0.6640829889f, -0.7369967419f, 0, -0.6477565124f, -0.1740147258f, -0.7417077429f, 0, 0.6217889313f, -0.7804430448f, -0.06547655076f, 0, 0.6589943422f, -0.6096987708f, 0.4404473475f, 0, -0.2689837504f, -0.6732403169f, -0.6887635427f, 0, - -0.3849775103f, 0.5676542638f, 0.7277093879f, 0, 0.5754444408f, 0.8110471154f, -0.1051963504f, 0, 0.9141593684f, 0.3832947817f, 0.131900567f, 0, -0.107925319f, 0.9245493968f, 0.3654593525f, 0, 0.377977089f, 0.3043148782f, 0.8743716458f, 0, -0.2142885215f, -0.8259286236f, 0.5214617324f, 0, 0.5802544474f, 0.4148098596f, -0.7008834116f, 0, -0.1982660881f, 0.8567161266f, -0.4761596756f, 0, - -0.03381553704f, 0.3773180787f, -0.9254661404f, 0, -0.6867922841f, -0.6656597827f, 0.2919133642f, 0, 0.7731742607f, -0.2875793547f, -0.5652430251f, 0, -0.09655941928f, 0.9193708367f, -0.3813575004f, 0, 0.2715702457f, -0.9577909544f, -0.09426605581f, 0, 0.2451015704f, -0.6917998565f, -0.6792188003f, 0, 0.977700782f, -0.1753855374f, 0.1155036542f, 0, -0.5224739938f, 0.8521606816f, 0.02903615945f, 0, - -0.7734880599f, -0.5261292347f, 0.3534179531f, 0, -0.7134492443f, -0.269547243f, 0.6467878011f, 0, 0.1644037271f, 0.5105846203f, -0.8439637196f, 0, 0.6494635788f, 0.05585611296f, 0.7583384168f, 0, -0.4711970882f, 0.5017280509f, -0.7254255765f, 0, -0.6335764307f, -0.2381686273f, -0.7361091029f, 0, -0.9021533097f, -0.270947803f, -0.3357181763f, 0, -0.3793711033f, 0.872258117f, 0.3086152025f, 0, - -0.6855598966f, -0.3250143309f, 0.6514394162f, 0, 0.2900942212f, -0.7799057743f, -0.5546100667f, 0, -0.2098319339f, 0.85037073f, 0.4825351604f, 0, -0.4592603758f, 0.6598504336f, -0.5947077538f, 0, 0.8715945488f, 0.09616365406f, -0.4807031248f, 0, -0.6776666319f, 0.7118504878f, -0.1844907016f, 0, 0.7044377633f, 0.312427597f, 0.637304036f, 0, -0.7052318886f, -0.2401093292f, -0.6670798253f, 0, - 0.081921007f, -0.7207336136f, -0.6883545647f, 0, -0.6993680906f, -0.5875763221f, -0.4069869034f, 0, -0.1281454481f, 0.6419895885f, 0.7559286424f, 0, -0.6337388239f, -0.6785471501f, -0.3714146849f, 0, 0.5565051903f, -0.2168887573f, -0.8020356851f, 0, -0.5791554484f, 0.7244372011f, -0.3738578718f, 0, 0.1175779076f, -0.7096451073f, 0.6946792478f, 0, -0.6134619607f, 0.1323631078f, 0.7785527795f, 0, - 0.6984635305f, -0.02980516237f, -0.715024719f, 0, 0.8318082963f, -0.3930171956f, 0.3919597455f, 0, 0.1469576422f, 0.05541651717f, -0.9875892167f, 0, 0.708868575f, -0.2690503865f, 0.6520101478f, 0, 0.2726053183f, 0.67369766f, -0.68688995f, 0, -0.6591295371f, 0.3035458599f, -0.6880466294f, 0, 0.4815131379f, -0.7528270071f, 0.4487723203f, 0, 0.9430009463f, 0.1675647412f, -0.2875261255f, 0, - 0.434802957f, 0.7695304522f, -0.4677277752f, 0, 0.3931996188f, 0.594473625f, 0.7014236729f, 0, 0.7254336655f, -0.603925654f, 0.3301814672f, 0, 0.7590235227f, -0.6506083235f, 0.02433313207f, 0, -0.8552768592f, -0.3430042733f, 0.3883935666f, 0, -0.6139746835f, 0.6981725247f, 0.3682257648f, 0, -0.7465905486f, -0.5752009504f, 0.3342849376f, 0, 0.5730065677f, 0.810555537f, -0.1210916791f, 0, - -0.9225877367f, -0.3475211012f, -0.167514036f, 0, -0.7105816789f, -0.4719692027f, -0.5218416899f, 0, -0.08564609717f, 0.3583001386f, 0.929669703f, 0, -0.8279697606f, -0.2043157126f, 0.5222271202f, 0, 0.427944023f, 0.278165994f, 0.8599346446f, 0, 0.5399079671f, -0.7857120652f, -0.3019204161f, 0, 0.5678404253f, -0.5495413974f, -0.6128307303f, 0, -0.9896071041f, 0.1365639107f, -0.04503418428f, 0, - -0.6154342638f, -0.6440875597f, 0.4543037336f, 0, 0.1074204368f, -0.7946340692f, 0.5975094525f, 0, -0.3595449969f, -0.8885529948f, 0.28495784f, 0, -0.2180405296f, 0.1529888965f, 0.9638738118f, 0, -0.7277432317f, -0.6164050508f, -0.3007234646f, 0, 0.7249729114f, -0.00669719484f, 0.6887448187f, 0, -0.5553659455f, -0.5336586252f, 0.6377908264f, 0, 0.5137558015f, 0.7976208196f, -0.3160000073f, 0, - -0.3794024848f, 0.9245608561f, -0.03522751494f, 0, 0.8229248658f, 0.2745365933f, -0.4974176556f, 0, -0.5404114394f, 0.6091141441f, 0.5804613989f, 0, 0.8036581901f, -0.2703029469f, 0.5301601931f, 0, 0.6044318879f, 0.6832968393f, 0.4095943388f, 0, 0.06389988817f, 0.9658208605f, -0.2512108074f, 0, 0.1087113286f, 0.7402471173f, -0.6634877936f, 0, -0.713427712f, -0.6926784018f, 0.1059128479f, 0, - 0.6458897819f, -0.5724548511f, -0.5050958653f, 0, -0.6553931414f, 0.7381471625f, 0.159995615f, 0, 0.3910961323f, 0.9188871375f, -0.05186755998f, 0, -0.4879022471f, -0.5904376907f, 0.6429111375f, 0, 0.6014790094f, 0.7707441366f, -0.2101820095f, 0, -0.5677173047f, 0.7511360995f, 0.3368851762f, 0, 0.7858573506f, 0.226674665f, 0.5753666838f, 0, -0.4520345543f, -0.604222686f, -0.6561857263f, 0, - 0.002272116345f, 0.4132844051f, -0.9105991643f, 0, -0.5815751419f, -0.5162925989f, 0.6286591339f, 0, -0.03703704785f, 0.8273785755f, 0.5604221175f, 0, -0.5119692504f, 0.7953543429f, -0.3244980058f, 0, -0.2682417366f, -0.9572290247f, -0.1084387619f, 0, -0.2322482736f, -0.9679131102f, -0.09594243324f, 0, 0.3554328906f, -0.8881505545f, 0.2913006227f, 0, 0.7346520519f, -0.4371373164f, 0.5188422971f, 0, - 0.9985120116f, 0.04659011161f, -0.02833944577f, 0, -0.3727687496f, -0.9082481361f, 0.1900757285f, 0, 0.91737377f, -0.3483642108f, 0.1925298489f, 0, 0.2714911074f, 0.4147529736f, -0.8684886582f, 0, 0.5131763485f, -0.7116334161f, 0.4798207128f, 0, -0.8737353606f, 0.18886992f, -0.4482350644f, 0, 0.8460043821f, -0.3725217914f, 0.3814499973f, 0, 0.8978727456f, -0.1780209141f, -0.4026575304f, 0, - 0.2178065647f, -0.9698322841f, -0.1094789531f, 0, -0.1518031304f, -0.7788918132f, -0.6085091231f, 0, -0.2600384876f, -0.4755398075f, -0.8403819825f, 0, 0.572313509f, -0.7474340931f, -0.3373418503f, 0, -0.7174141009f, 0.1699017182f, -0.6756111411f, 0, -0.684180784f, 0.02145707593f, -0.7289967412f, 0, -0.2007447902f, 0.06555605789f, -0.9774476623f, 0, -0.1148803697f, -0.8044887315f, 0.5827524187f, 0, - -0.7870349638f, 0.03447489231f, 0.6159443543f, 0, -0.2015596421f, 0.6859872284f, 0.6991389226f, 0, -0.08581082512f, -0.10920836f, -0.9903080513f, 0, 0.5532693395f, 0.7325250401f, -0.396610771f, 0, -0.1842489331f, -0.9777375055f, -0.1004076743f, 0, 0.0775473789f, -0.9111505856f, 0.4047110257f, 0, 0.1399838409f, 0.7601631212f, -0.6344734459f, 0, 0.4484419361f, -0.845289248f, 0.2904925424f, 0 -}; - -#endif diff --git a/Release/include/ostd/vendor/TermColor.hpp b/Release/include/ostd/vendor/TermColor.hpp deleted file mode 100644 index 861ab83..0000000 --- a/Release/include/ostd/vendor/TermColor.hpp +++ /dev/null @@ -1,911 +0,0 @@ -//! -//! termcolor -//! ~~~~~~~~~ -//! -//! termcolor is a header-only c++ library for printing colored messages -//! to the terminal. Written just for fun with a help of the Force. -//! -//! :copyright: (c) 2013 by Ihor Kalnytskyi -//! :license: BSD, see termcolor-LICENSEfile for details -//! - -#ifndef TERMCOLOR_HPP_ -#define TERMCOLOR_HPP_ - -#include -#include - -// Detect target's platform and set some macros in order to wrap platform -// specific code this library depends on. -#if defined(_WIN32) || defined(_WIN64) -# define TERMCOLOR_TARGET_WINDOWS -#elif defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__)) -# define TERMCOLOR_TARGET_POSIX -#endif - -// If implementation has not been explicitly set, try to choose one based on -// target platform. -#if !defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) && !defined(TERMCOLOR_USE_WINDOWS_API) && !defined(TERMCOLOR_USE_NOOP) -# if defined(TERMCOLOR_TARGET_POSIX) -# define TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES -# define TERMCOLOR_AUTODETECTED_IMPLEMENTATION -# elif defined(TERMCOLOR_TARGET_WINDOWS) -# define TERMCOLOR_USE_WINDOWS_API -# define TERMCOLOR_AUTODETECTED_IMPLEMENTATION -# endif -#endif - -// These headers provide isatty()/fileno() functions, which are used for -// testing whether a standard stream refers to the terminal. -#if defined(TERMCOLOR_TARGET_POSIX) -# include -#elif defined(TERMCOLOR_TARGET_WINDOWS) -# include -# include -#endif - - -namespace termcolor -{ - // Forward declaration of the `_internal` namespace. - // All comments are below. - namespace _internal - { - inline int colorize_index(); - inline FILE* get_standard_stream(const std::ostream& stream); - inline bool is_colorized(std::ostream& stream); - inline bool is_atty(const std::ostream& stream); - - #if defined(TERMCOLOR_TARGET_WINDOWS) - inline void win_change_attributes(std::ostream& stream, int foreground, int background=-1); - #endif - } - - inline - std::ostream& colorize(std::ostream& stream) - { - stream.iword(_internal::colorize_index()) = 1L; - return stream; - } - - inline - std::ostream& nocolorize(std::ostream& stream) - { - stream.iword(_internal::colorize_index()) = 0L; - return stream; - } - - inline - std::ostream& reset(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[00m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, -1); - #endif - } - return stream; - } - - inline - std::ostream& bold(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[1m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& dark(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[2m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& italic(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[3m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& underline(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[4m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, COMMON_LVB_UNDERSCORE); - #endif - } - return stream; - } - - inline - std::ostream& blink(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[5m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& reverse(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[7m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& concealed(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[8m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& crossed(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[9m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - template inline - std::ostream& color(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - char command[12]; - std::snprintf(command, sizeof(command), "\033[38;5;%dm", code); - stream << command; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - template inline - std::ostream& on_color(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - char command[12]; - std::snprintf(command, sizeof(command), "\033[48;5;%dm", code); - stream << command; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - template inline - std::ostream& color(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - char command[20]; - std::snprintf(command, sizeof(command), "\033[38;2;%d;%d;%dm", r, g, b); - stream << command; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - template inline - std::ostream& on_color(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - char command[20]; - std::snprintf(command, sizeof(command), "\033[48;2;%d;%d;%dm", r, g, b); - stream << command; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - #endif - } - return stream; - } - - inline - std::ostream& grey(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[30m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - 0 // grey (black) - ); - #endif - } - return stream; - } - - inline - std::ostream& red(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[31m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& green(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[32m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_GREEN - ); - #endif - } - return stream; - } - - inline - std::ostream& yellow(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[33m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_GREEN | FOREGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& blue(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[34m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE - ); - #endif - } - return stream; - } - - inline - std::ostream& magenta(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[35m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& cyan(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[36m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_GREEN - ); - #endif - } - return stream; - } - - inline - std::ostream& white(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[37m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED - ); - #endif - } - return stream; - } - - - inline - std::ostream& bright_grey(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[90m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - 0 | FOREGROUND_INTENSITY // grey (black) - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_red(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[91m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_RED | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_green(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[92m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_GREEN | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_yellow(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[93m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_blue(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[94m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_magenta(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[95m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_cyan(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[96m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& bright_white(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[97m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, - FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY - ); - #endif - } - return stream; - } - - - inline - std::ostream& on_grey(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[40m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - 0 // grey (black) - ); - #endif - } - return stream; - } - - inline - std::ostream& on_red(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[41m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& on_green(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[42m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN - ); - #endif - } - return stream; - } - - inline - std::ostream& on_yellow(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[43m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& on_blue(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[44m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_BLUE - ); - #endif - } - return stream; - } - - inline - std::ostream& on_magenta(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[45m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_BLUE | BACKGROUND_RED - ); - #endif - } - return stream; - } - - inline - std::ostream& on_cyan(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[46m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_BLUE - ); - #endif - } - return stream; - } - - inline - std::ostream& on_white(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[47m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED - ); - #endif - } - - return stream; - } - - - inline - std::ostream& on_bright_grey(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[100m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - 0 | BACKGROUND_INTENSITY // grey (black) - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_red(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[101m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_RED | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_green(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[102m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_yellow(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[103m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_blue(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[104m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_BLUE | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_magenta(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[105m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_cyan(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[106m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY - ); - #endif - } - return stream; - } - - inline - std::ostream& on_bright_white(std::ostream& stream) - { - if (_internal::is_colorized(stream)) - { - #if defined(TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES) - stream << "\033[107m"; - #elif defined(TERMCOLOR_USE_WINDOWS_API) - _internal::win_change_attributes(stream, -1, - BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_RED | BACKGROUND_INTENSITY - ); - #endif - } - - return stream; - } - - - - //! Since C++ hasn't a way to hide something in the header from - //! the outer access, I have to introduce this namespace which - //! is used for internal purpose and should't be access from - //! the user code. - namespace _internal - { - // An index to be used to access a private storage of I/O streams. See - // colorize / nocolorize I/O manipulators for details. Due to the fact - // that static variables ain't shared between translation units, inline - // function with local static variable is used to do the trick and share - // the variable value between translation units. - inline int colorize_index() - { - static int colorize_index = std::ios_base::xalloc(); - return colorize_index; - } - - //! Since C++ hasn't a true way to extract stream handler - //! from the a given `std::ostream` object, I have to write - //! this kind of hack. - inline - FILE* get_standard_stream(const std::ostream& stream) - { - if (&stream == &std::cout) - return stdout; - else if ((&stream == &std::cerr) || (&stream == &std::clog)) - return stderr; - - return nullptr; - } - - // Say whether a given stream should be colorized or not. It's always - // true for ATTY streams and may be true for streams marked with - // colorize flag. - inline - bool is_colorized(std::ostream& stream) - { - return is_atty(stream) || static_cast(stream.iword(colorize_index())); - } - - //! Test whether a given `std::ostream` object refers to - //! a terminal. - inline - bool is_atty(const std::ostream& stream) - { - FILE* std_stream = get_standard_stream(stream); - - // Unfortunately, fileno() ends with segmentation fault - // if invalid file descriptor is passed. So we need to - // handle this case gracefully and assume it's not a tty - // if standard stream is not detected, and 0 is returned. - if (!std_stream) - return false; - - #if defined(TERMCOLOR_TARGET_POSIX) - return ::isatty(fileno(std_stream)); - #elif defined(TERMCOLOR_TARGET_WINDOWS) - return ::_isatty(_fileno(std_stream)); - #else - return false; - #endif - } - - #if defined(TERMCOLOR_TARGET_WINDOWS) - //! Change Windows Terminal colors attribute. If some - //! parameter is `-1` then attribute won't changed. - inline void win_change_attributes(std::ostream& stream, int foreground, int background) - { - // yeah, i know.. it's ugly, it's windows. - static WORD defaultAttributes = 0; - - // Windows doesn't have ANSI escape sequences and so we use special - // API to change Terminal output color. That means we can't - // manipulate colors by means of "std::stringstream" and hence - // should do nothing in this case. - if (!_internal::is_atty(stream)) - return; - - // get terminal handle - HANDLE hTerminal = INVALID_HANDLE_VALUE; - if (&stream == &std::cout) - hTerminal = GetStdHandle(STD_OUTPUT_HANDLE); - else if (&stream == &std::cerr) - hTerminal = GetStdHandle(STD_ERROR_HANDLE); - - // save default terminal attributes if it unsaved - if (!defaultAttributes) - { - CONSOLE_SCREEN_BUFFER_INFO info; - if (!GetConsoleScreenBufferInfo(hTerminal, &info)) - return; - defaultAttributes = info.wAttributes; - } - - // restore all default settings - if (foreground == -1 && background == -1) - { - SetConsoleTextAttribute(hTerminal, defaultAttributes); - return; - } - - // get current settings - CONSOLE_SCREEN_BUFFER_INFO info; - if (!GetConsoleScreenBufferInfo(hTerminal, &info)) - return; - - if (foreground != -1) - { - info.wAttributes &= ~(info.wAttributes & 0x0F); - info.wAttributes |= static_cast(foreground); - } - - if (background != -1) - { - info.wAttributes &= ~(info.wAttributes & 0xF0); - info.wAttributes |= static_cast(background); - } - - SetConsoleTextAttribute(hTerminal, info.wAttributes); - } - #endif // TERMCOLOR_TARGET_WINDOWS - - } // namespace _internal - -} // namespace termcolor - - -#undef TERMCOLOR_TARGET_POSIX -#undef TERMCOLOR_TARGET_WINDOWS - -#if defined(TERMCOLOR_AUTODETECTED_IMPLEMENTATION) -# undef TERMCOLOR_USE_ANSI_ESCAPE_SEQUENCES -# undef TERMCOLOR_USE_WINDOWS_API -#endif - -#endif // TERMCOLOR_HPP_ diff --git a/Release/licences/FastNoiseLite-LICENSE.txt b/Release/licences/FastNoiseLite-LICENSE.txt deleted file mode 100644 index dd6df2c..0000000 --- a/Release/licences/FastNoiseLite-LICENSE.txt +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright(c) 2020 Jordan Peck (jordan.me2@gmail.com) -Copyright(c) 2020 Contributors - -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. \ No newline at end of file diff --git a/Release/licences/termcolor-LICENSE b/Release/licences/termcolor-LICENSE deleted file mode 100644 index e2a9f53..0000000 --- a/Release/licences/termcolor-LICENSE +++ /dev/null @@ -1,31 +0,0 @@ -Copyright (c) 2013, Ihor Kalnytskyi. -All rights reserved. - -Redistribution and use in source and binary forms of the software as well -as documentation, with or without modification, are permitted provided -that the following conditions are met: - -* Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above - copyright notice, this list of conditions and the following - disclaimer in the documentation and/or other materials provided - with the distribution. - -* The names of the contributors may not be used to endorse or - promote products derived from this software without specific - prior written permission. - -THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND -CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT -NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER -OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, -EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH -DAMAGE.