Better build script
This commit is contained in:
parent
35b9466060
commit
925d3dc5df
31 changed files with 6557 additions and 5 deletions
3
.gitignore
vendored
3
.gitignore
vendored
|
|
@ -1,5 +1,2 @@
|
|||
bin
|
||||
Debug
|
||||
Build
|
||||
tools/win-release-tools
|
||||
win-release
|
||||
|
|
@ -62,7 +62,7 @@ target_include_directories(${OMNIA_STD_LIB} PUBLIC ${INCLUDE_DIRS})
|
|||
add_compile_options(-O3 -m32 -MMD -MP -Wall -ggdb -fsanitize=address)
|
||||
if (UNIX)
|
||||
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath='$ORIGIN'")
|
||||
target_link_libraries(${OMNIA_STD_LIB} PUBLIC tinfo)
|
||||
target_link_libraries(${OMNIA_STD_LIB} PUBLIC tinfo boost_regex)
|
||||
endif (UNIX)
|
||||
#-----------------------------------------------------------------------------------------
|
||||
|
||||
|
|
|
|||
71
Release/include/ostd/BaseObject.hpp
Normal file
71
Release/include/ostd/BaseObject.hpp
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
#ifndef __BASE_OBJECT_HPP__
|
||||
#define __BASE_OBJECT_HPP__
|
||||
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
#include <ostd/String.hpp>
|
||||
|
||||
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 StringEditor& tn) { m_typeName = tn.str(); }
|
||||
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
|
||||
914
Release/include/ostd/Bitfields.hpp
Normal file
914
Release/include/ostd/Bitfields.hpp
Normal file
|
|
@ -0,0 +1,914 @@
|
|||
#ifndef __BITFIELDS_HPP__
|
||||
#define __BITFIELDS_HPP__
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#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
|
||||
62
Release/include/ostd/Color.hpp
Normal file
62
Release/include/ostd/Color.hpp
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
#ifndef __COLOR_HPP__
|
||||
#define __COLOR_HPP__
|
||||
|
||||
#include <cstdint>
|
||||
#include <ostd/Types.hpp>
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <ostd/String.hpp>
|
||||
|
||||
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 StringEditor& 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 StringEditor& color_string);
|
||||
Color& set(const FloatCol& normalized_color);
|
||||
|
||||
StringEditor hexString(bool include_alpha = false, StringEditor prefix = "0x") const;
|
||||
StringEditor 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
|
||||
92
Release/include/ostd/Console.hpp
Normal file
92
Release/include/ostd/Console.hpp
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
#pragma once
|
||||
|
||||
#include <ostd/Utils.hpp>
|
||||
#include <ostd/Geometry.hpp>
|
||||
#include <ostd/IOHandlers.hpp>
|
||||
|
||||
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 StringEditor& color) override;
|
||||
OutputHandlerBase& fg(const ConsoleColors::tConsoleColor& color) override;
|
||||
OutputHandlerBase& fg(const StringEditor& color) override;
|
||||
|
||||
OutputHandlerBase& pChar(char c) override;
|
||||
OutputHandlerBase& pStyled(const StringEditor& 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 StringEditor& 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<tRichChar> m_buffer;
|
||||
std::vector<tRichChar> m_secondBuffer;
|
||||
bool m_validBuffer { false };
|
||||
|
||||
tRichChar m_emptyChar {
|
||||
{ { 0, 0, 0, 255 }, "Black", false },
|
||||
{ { 0, 0, 0, 255 }, "Black", true },
|
||||
' '
|
||||
};
|
||||
|
||||
};
|
||||
}
|
||||
84
Release/include/ostd/Defines.hpp
Normal file
84
Release/include/ostd/Defines.hpp
Normal file
|
|
@ -0,0 +1,84 @@
|
|||
#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<type>
|
||||
#define sh_ptr(type) std::shared_ptr<type>
|
||||
#define new_un(type) std::make_unique<type>
|
||||
#define un_ptr(type) std::unique_ptr<type>
|
||||
|
||||
#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
|
||||
36
Release/include/ostd/Errors.hpp
Normal file
36
Release/include/ostd/Errors.hpp
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
#ifndef __ERRORS_HPP__
|
||||
#define __ERRORS_HPP__
|
||||
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <ostd/Utils.hpp>
|
||||
#include <ostd/Types.hpp>
|
||||
|
||||
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
|
||||
42
Release/include/ostd/File.hpp
Normal file
42
Release/include/ostd/File.hpp
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
#ifndef __FILE_HPP__
|
||||
#define __FILE_HPP__
|
||||
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <ostd/Types.hpp>
|
||||
#include <filesystem>
|
||||
#include <vector>
|
||||
|
||||
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<String> 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
|
||||
358
Release/include/ostd/Geometry.hpp
Normal file
358
Release/include/ostd/Geometry.hpp
Normal file
|
|
@ -0,0 +1,358 @@
|
|||
#ifndef __GEOMETRY_HPP__
|
||||
#define __GEOMETRY_HPP__
|
||||
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <ostd/Types.hpp>
|
||||
|
||||
namespace ostd
|
||||
{
|
||||
class OutputHandlerBase;
|
||||
template<class T>
|
||||
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<T>& op2 ) const { return (x == op2.x && y == op2.y); }
|
||||
inline bool operator!=(const Point<T>& op2 ) const { return (x != op2.x || y != op2.y); }
|
||||
|
||||
template <class T2> inline Point(Point<T2> copy)
|
||||
{
|
||||
x = (T2)(copy.x);
|
||||
y = (T2)(copy.y);
|
||||
}
|
||||
};
|
||||
|
||||
typedef Point<float> FPoint;
|
||||
typedef Point<double> DPoint;
|
||||
typedef Point<uint32_t> UIPoint;
|
||||
typedef Point<uint64_t> UI64Point;
|
||||
typedef Point<float> UI16Point;
|
||||
typedef Point<uint8_t> UI8Point;
|
||||
typedef Point<int32_t> IPoint;
|
||||
typedef Point<int64_t> I64Point;
|
||||
typedef Point<int16_t> I16Point;
|
||||
typedef Point<int8_t> 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
|
||||
332
Release/include/ostd/IOHandlers.hpp
Normal file
332
Release/include/ostd/IOHandlers.hpp
Normal file
|
|
@ -0,0 +1,332 @@
|
|||
#pragma once
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
#include <ostd/Geometry.hpp>
|
||||
#include <ostd/String.hpp>
|
||||
#include <ostd/TextStyleParser.hpp>
|
||||
|
||||
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 StringEditor& name, bool background = false) {
|
||||
StringEditor edit = name;
|
||||
edit.toLower().trim();
|
||||
if (edit.str() == Red.name) return (background ? OnRed : Red);
|
||||
if (edit.str() == BrightRed.name) return (background ? OnBrightRed : BrightRed);
|
||||
if (edit.str() == Green.name) return (background ? OnGreen : Green);
|
||||
if (edit.str() == BrightGreen.name) return (background ? OnBrightGreen : BrightGreen);
|
||||
if (edit.str() == Blue.name) return (background ? OnBlue : Blue);
|
||||
if (edit.str() == BrightBlue.name) return (background ? OnBrightBlue : BrightBlue);
|
||||
if (edit.str() == Magenta.name) return (background ? OnMagenta : Magenta);
|
||||
if (edit.str() == BrightMagenta.name) return (background ? OnBrightMagenta : BrightMagenta);
|
||||
if (edit.str() == Cyan.name) return (background ? OnCyan : Cyan);
|
||||
if (edit.str() == BrightCyan.name) return (background ? OnBrightCyan : BrightCyan);
|
||||
if (edit.str() == Yellow.name) return (background ? OnYellow : Yellow);
|
||||
if (edit.str() == BrightYellow.name) return (background ? OnBrightYellow : BrightYellow);
|
||||
if (edit.str() == Black.name) return (background ? OnBlack : Black);
|
||||
if (edit.str() == Gray.name) return (background ? OnGray : Gray);
|
||||
if (edit.str() == BrightGray.name) return (background ? OnBrightGray : BrightGray);
|
||||
if (edit.str() == White.name) return (background ? OnWhite : White);
|
||||
return (background ? OnBlack : Black);
|
||||
}
|
||||
inline static bool isConsoleColor(const StringEditor& name) {
|
||||
StringEditor edit = name;
|
||||
edit.toLower().trim();
|
||||
if (edit.str() == Red.name) return true;
|
||||
if (edit.str() == BrightRed.name) return true;
|
||||
if (edit.str() == Green.name) return true;
|
||||
if (edit.str() == BrightGreen.name) return true;
|
||||
if (edit.str() == Blue.name) return true;
|
||||
if (edit.str() == BrightBlue.name) return true;
|
||||
if (edit.str() == Magenta.name) return true;
|
||||
if (edit.str() == BrightMagenta.name) return true;
|
||||
if (edit.str() == Cyan.name) return true;
|
||||
if (edit.str() == BrightCyan.name) return true;
|
||||
if (edit.str() == Yellow.name) return true;
|
||||
if (edit.str() == BrightYellow.name) return true;
|
||||
if (edit.str() == Black.name) return true;
|
||||
if (edit.str() == Gray.name) return true;
|
||||
if (edit.str() == BrightGray.name) return true;
|
||||
if (edit.str() == 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 StringEditor& 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 StringEditor& color) { return *this; }
|
||||
|
||||
inline virtual OutputHandlerBase& pChar(char c) { return *this; }
|
||||
inline virtual OutputHandlerBase& pStyled(const StringEditor& 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 StringEditor& 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 StringEditor& color) override;
|
||||
OutputHandlerBase& fg(const ConsoleColors::tConsoleColor& color) override;
|
||||
OutputHandlerBase& fg(const StringEditor& color) override;
|
||||
|
||||
OutputHandlerBase& pChar(char c) override;
|
||||
OutputHandlerBase& pStyled(const StringEditor& 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 StringEditor& 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;
|
||||
};
|
||||
}
|
||||
}
|
||||
65
Release/include/ostd/Logger.hpp
Normal file
65
Release/include/ostd/Logger.hpp
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
#ifndef __LOGGER_HPP__
|
||||
#define __LOGGER_HPP__
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
|
||||
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
|
||||
36
Release/include/ostd/Logic.hpp
Normal file
36
Release/include/ostd/Logic.hpp
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
#ifndef __LOGIC_HPP__
|
||||
#define __LOGIC_HPP__
|
||||
|
||||
#include <map>
|
||||
#include <ostd/Types.hpp>
|
||||
|
||||
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
|
||||
83
Release/include/ostd/PathFinder.hpp
Normal file
83
Release/include/ostd/PathFinder.hpp
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
#ifndef __PATH_FINDER_HPP__
|
||||
#define __PATH_FINDER_HPP__
|
||||
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
#include <deque>
|
||||
#include <cstdint>
|
||||
|
||||
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<KeyNode> 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<KeyNode> findPath(void);
|
||||
|
||||
private:
|
||||
float heuristics(KeyNode n);
|
||||
|
||||
private:
|
||||
std::unordered_map<KeyNode, float, KeyNode::hashFunc> gscores;
|
||||
std::unordered_map<KeyNode, KeyNode, KeyNode::hashFunc> pathMap;
|
||||
std::unordered_map<KeyNode, bool, KeyNode::hashFunc> obstacle;
|
||||
OpenSet openSet;
|
||||
|
||||
KeyNode __start;
|
||||
KeyNode __goal;
|
||||
eHeuristicType __ht;
|
||||
|
||||
int32_t m_width;
|
||||
int32_t m_height;
|
||||
|
||||
bool m_initialized;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
47
Release/include/ostd/QuadTree.hpp
Normal file
47
Release/include/ostd/QuadTree.hpp
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
#ifndef __QUAD_TREE_HPP__
|
||||
#define __QUAD_TREE_HPP__
|
||||
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <ostd/Geometry.hpp>
|
||||
#include <ostd/Defines.hpp>
|
||||
#include <vector>
|
||||
#include <memory>
|
||||
|
||||
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<tElement*>& 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
|
||||
81
Release/include/ostd/Random.hpp
Normal file
81
Release/include/ostd/Random.hpp
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
#ifndef __RANDOM_HPP__
|
||||
#define __RANDOM_HPP__
|
||||
|
||||
#include <random>
|
||||
#include <climits>
|
||||
#include <ostd/Geometry.hpp>
|
||||
#include <ostd/vendor/FastNoiseLite.hpp>
|
||||
|
||||
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 <typename T>
|
||||
inline T& getFromStdVec(std::vector<T>& list)
|
||||
{
|
||||
uint64_t index = static_cast<uint64_t>(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 <typename T>
|
||||
inline static T& getFromStdVec(std::vector<T>& list) { return Random::s_gen.getFromStdVec<T>(list); }
|
||||
|
||||
private:
|
||||
inline static RandomGenerator s_gen;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
76
Release/include/ostd/Serial.hpp
Normal file
76
Release/include/ostd/Serial.hpp
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
#ifndef __SERIAL_HPP__
|
||||
#define __SERIAL_HPP__
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
#include <ostd/Bitfields.hpp>
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <unordered_map>
|
||||
|
||||
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
|
||||
106
Release/include/ostd/Signals.hpp
Normal file
106
Release/include/ostd/Signals.hpp
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
#ifndef __SIGNALS_HPP__
|
||||
#define __SIGNALS_HPP__
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
#include <ostd/BaseObject.hpp>
|
||||
#include <vector>
|
||||
#include <unordered_map>
|
||||
|
||||
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<tSignalObjPair> m_customRecievers;
|
||||
inline static std::vector<tDelegateSignal> m_delegatedSignals;
|
||||
|
||||
/** Builtin signal recievers lists **/
|
||||
inline static std::vector<tSignalObjPair> m_mousePressedRecievers;
|
||||
inline static std::vector<tSignalObjPair> m_mouseReleasedRecievers;
|
||||
inline static std::vector<tSignalObjPair> m_keyPressedRecievers;
|
||||
inline static std::vector<tSignalObjPair> m_keyReleasedRecievers;
|
||||
inline static std::vector<tSignalObjPair> m_mouseMovedRecievers;
|
||||
inline static std::vector<tSignalObjPair> m_windowResizedRecievers;
|
||||
inline static std::vector<tSignalObjPair> 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
|
||||
39
Release/include/ostd/SineWave.hpp
Normal file
39
Release/include/ostd/SineWave.hpp
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
#ifndef __SINE_WAVE_HPP__
|
||||
#define __SINE_WAVE_HPP__
|
||||
|
||||
#include <vector>
|
||||
#include <cmath>
|
||||
|
||||
#include <ostd/Defines.hpp>
|
||||
|
||||
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<SineWave> waves;
|
||||
std::vector<AdditiveWave> additiveWaves;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
107
Release/include/ostd/String.hpp
Normal file
107
Release/include/ostd/String.hpp
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
#pragma once
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
|
||||
namespace ostd
|
||||
{
|
||||
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<String> 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<String> 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;
|
||||
};
|
||||
}
|
||||
120
Release/include/ostd/TextStyleParser.hpp
Normal file
120
Release/include/ostd/TextStyleParser.hpp
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
#pragma once
|
||||
|
||||
#include <ostd/Color.hpp>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace ostd
|
||||
{
|
||||
class StringEditor;
|
||||
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<tColor> backgroundColors;
|
||||
std::vector<tColor> 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 StringEditor& styledString);
|
||||
static tStyledString parse(const StringEditor& styledString, tColor defaultBackgorundColor, tColor defaultForegroundColor);
|
||||
|
||||
static tColor convertColor(const StringEditor& 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 StringEditor& rawString) { setRawString(rawString); }
|
||||
inline String getRawString(void) const { return m_rawString; }
|
||||
Regex& setRawString(const StringEditor& rawString);
|
||||
|
||||
Regex& fg(const StringEditor& regex, const StringEditor& foreground_color, bool case_insensitive = false);
|
||||
Regex& bg(const StringEditor& regex, const StringEditor& background_color, bool case_insensitive = false);
|
||||
Regex& col(const StringEditor& regex, const StringEditor& foreground_color, const StringEditor& 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;
|
||||
}
|
||||
64
Release/include/ostd/Types.hpp
Normal file
64
Release/include/ostd/Types.hpp
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#ifndef __TYPES_HPP__
|
||||
#define __TYPES_HPP__
|
||||
|
||||
#include <string>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace ostd
|
||||
{
|
||||
typedef std::string 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 uint32_t TextureAtlasIndex;
|
||||
typedef uint32_t ResourceID;
|
||||
|
||||
typedef uint32_t WidgetID;
|
||||
|
||||
typedef uint32_t LayerID;
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
struct TextureID
|
||||
{
|
||||
ResourceID texture { 0 };
|
||||
TextureAtlasIndex tile { 0 };
|
||||
};
|
||||
|
||||
typedef std::vector<Byte> ByteStream;
|
||||
}
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
173
Release/include/ostd/Utils.hpp
Normal file
173
Release/include/ostd/Utils.hpp
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
#ifndef __DATATYPES__HPP__
|
||||
#define __DATATYPES__HPP__
|
||||
|
||||
#include <ostd/Types.hpp>
|
||||
#include <ostd/TextStyleParser.hpp>
|
||||
|
||||
#include <filesystem>
|
||||
|
||||
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 <Utils.cpp>
|
||||
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<String>& 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 <FileSystem.cpp>
|
||||
static std::vector<std::filesystem::path> listFilesInDirectory(const String& directoryPath);
|
||||
static std::vector<std::filesystem::path> listDirectoriesInDirectory(const String& directoryPath);
|
||||
static std::vector<std::filesystem::path> listDirectory(const String& directoryPath);
|
||||
static std::vector<std::filesystem::path> listFilesInDirectoryRecursive(const String& directoryPath);
|
||||
static std::vector<std::filesystem::path> listDirectoriesInDirectoryRecursive(const String& directoryPath);
|
||||
static std::vector<std::filesystem::path> listDirectoryRecursive(const String& directoryPath);
|
||||
|
||||
//Implemented in <ShuntingYard.cpp>
|
||||
static int32_t solveIntegerExpression(const String& expr);
|
||||
|
||||
//Implemented in <Console.cpp>
|
||||
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
|
||||
2586
Release/include/ostd/vendor/FastNoiseLite.hpp
vendored
Normal file
2586
Release/include/ostd/vendor/FastNoiseLite.hpp
vendored
Normal file
File diff suppressed because it is too large
Load diff
911
Release/include/ostd/vendor/TermColor.hpp
vendored
Normal file
911
Release/include/ostd/vendor/TermColor.hpp
vendored
Normal file
|
|
@ -0,0 +1,911 @@
|
|||
//!
|
||||
//! 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 <iostream>
|
||||
#include <cstdio>
|
||||
|
||||
// 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 <unistd.h>
|
||||
#elif defined(TERMCOLOR_TARGET_WINDOWS)
|
||||
# include <io.h>
|
||||
# include <windows.h>
|
||||
#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 <uint8_t code> 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 <uint8_t code> 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 <uint8_t r, uint8_t g, uint8_t b> 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 <uint8_t r, uint8_t g, uint8_t b> 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<bool>(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<WORD>(foreground);
|
||||
}
|
||||
|
||||
if (background != -1)
|
||||
{
|
||||
info.wAttributes &= ~(info.wAttributes & 0xF0);
|
||||
info.wAttributes |= static_cast<WORD>(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_
|
||||
BIN
Release/lib/libostd.so
Normal file
BIN
Release/lib/libostd.so
Normal file
Binary file not shown.
22
Release/licences/FastNoiseLite-LICENSE.txt
Normal file
22
Release/licences/FastNoiseLite-LICENSE.txt
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
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.
|
||||
31
Release/licences/termcolor-LICENSE
Normal file
31
Release/licences/termcolor-LICENSE
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
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.
|
||||
2
build.nr
2
build.nr
|
|
@ -1 +1 @@
|
|||
1796
|
||||
1802
|
||||
|
|
|
|||
2
compile
2
compile
|
|
@ -1,6 +1,7 @@
|
|||
#!/bin/bash
|
||||
|
||||
rm -r bin
|
||||
rm -r Release
|
||||
|
||||
if [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
|
||||
cmake -B bin -S ./
|
||||
|
|
@ -31,6 +32,7 @@ elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then
|
|||
mkdir -p ./Release/lib
|
||||
|
||||
cp ./bin/libostd.dll ./Release/lib
|
||||
cp ./bin/libostd.dll.a ./Release/lib
|
||||
|
||||
cp C:/msys64/ucrt64/bin/libgcc_s_seh-1.dll ./Release/lib
|
||||
cp C:/msys64/ucrt64/bin/libstdc++-6.dll ./Release/lib
|
||||
|
|
|
|||
15
temp_install.sh
Normal file
15
temp_install.sh
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
#!/bin/bash
|
||||
|
||||
if [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
|
||||
sudo rm -r /usr/include/ostd
|
||||
sudo rm -r /usr/lib/libostd.so
|
||||
sudo cp -r ./Release/include/ostd /usr/include/
|
||||
sudo cp -r ./Release/lib/libostd.so /usr/lib/
|
||||
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then
|
||||
rm -r C:/msys64/ucrt64/include/ostd
|
||||
rm -r C:/msys64/ucrt64/bin/libostd.dll
|
||||
rm -r C:/msys64/ucrt64/lib/libostd.dll.a
|
||||
cp -r ./Release/include/ostd C:/msys64/ucrt64/include/
|
||||
cp -r ./Release/lib/libostd.dll C:/msys64/ucrt64/bin/
|
||||
cp -r ./Release/lib/libostd.dll.a C:/msys64/ucrt64/lib/
|
||||
fi
|
||||
Loading…
Reference in a new issue