171 lines
3.1 KiB
C++
171 lines
3.1 KiB
C++
// =============================================
|
|
// Aster: constants.h
|
|
// Copyright (c) 2020-2024 Anish Bhobe
|
|
// =============================================
|
|
|
|
#pragma once
|
|
|
|
#include <vulkan/vulkan_core.h>
|
|
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtx/quaternion.hpp>
|
|
|
|
using c8 = char;
|
|
using u8 = uint8_t;
|
|
using u16 = uint16_t;
|
|
using u32 = uint32_t;
|
|
using u64 = uint64_t;
|
|
using i8 = int8_t;
|
|
using i16 = int16_t;
|
|
using i32 = int32_t;
|
|
using i64 = int64_t;
|
|
using f32 = float;
|
|
using f64 = double;
|
|
using f128 = long double;
|
|
using b8 = bool;
|
|
using b32 = u32;
|
|
using usize = size_t;
|
|
using uptr = uintptr_t;
|
|
using cstr = const char *;
|
|
|
|
namespace ansi_color
|
|
{
|
|
constexpr auto Black = "\u001b[30m";
|
|
constexpr auto Red = "\u001b[31m";
|
|
constexpr auto Green = "\u001b[32m";
|
|
constexpr auto Yellow = "\u001b[33m";
|
|
constexpr auto Blue = "\u001b[34m";
|
|
constexpr auto Magenta = "\u001b[35m";
|
|
constexpr auto Cyan = "\u001b[36m";
|
|
constexpr auto White = "\u001b[37m";
|
|
constexpr auto Reset = "\u001b[0m";
|
|
} // namespace ansi_color
|
|
|
|
template <typename TType, typename TFrom>
|
|
constexpr auto
|
|
Cast(TFrom &&in)
|
|
{
|
|
return static_cast<TType>(std::forward<TFrom>(in));
|
|
}
|
|
|
|
template <typename TType, typename TFrom>
|
|
constexpr auto
|
|
Recast(TFrom &&in)
|
|
{
|
|
return reinterpret_cast<TType>(std::forward<TFrom>(in));
|
|
}
|
|
|
|
constexpr f32
|
|
operator""_deg(long double degrees)
|
|
{
|
|
return glm::radians<f32>(Cast<f32>(degrees));
|
|
}
|
|
|
|
constexpr f32
|
|
operator""_deg(unsigned long long int degrees)
|
|
{
|
|
return glm::radians<f32>(Cast<f32>(degrees));
|
|
}
|
|
|
|
constexpr f32
|
|
operator""_rad(long double rads)
|
|
{
|
|
return Cast<f32>(rads);
|
|
}
|
|
|
|
constexpr f32
|
|
operator""_rad(unsigned long long int rads)
|
|
{
|
|
return Cast<f32>(rads);
|
|
}
|
|
|
|
using glm::ivec2;
|
|
using glm::ivec3;
|
|
using glm::ivec4;
|
|
using glm::quat;
|
|
using glm::vec2;
|
|
using glm::vec3;
|
|
using glm::vec4;
|
|
|
|
using glm::mat2;
|
|
using glm::mat3;
|
|
using glm::mat4;
|
|
|
|
constexpr auto *PROJECT_NAME = "Aster";
|
|
|
|
struct Version
|
|
{
|
|
u8 m_Major;
|
|
u8 m_Minor;
|
|
u8 m_Patch;
|
|
|
|
[[nodiscard]] u32
|
|
GetVkVersion() const
|
|
{
|
|
return VK_MAKE_API_VERSION(0, m_Major, m_Minor, m_Patch);
|
|
}
|
|
};
|
|
|
|
constexpr Version VERSION = {
|
|
.m_Major = 0,
|
|
.m_Minor = 1,
|
|
.m_Patch = 0,
|
|
};
|
|
|
|
constexpr u32
|
|
Kilobyte(const u32 in)
|
|
{
|
|
return in * 1024;
|
|
}
|
|
|
|
constexpr usize
|
|
Kilobyte(const usize in)
|
|
{
|
|
return in * 1024;
|
|
}
|
|
|
|
constexpr u32
|
|
Megabyte(const u32 in)
|
|
{
|
|
return in * 1024 * 1024;
|
|
}
|
|
|
|
constexpr usize
|
|
Megabyte(const usize in)
|
|
{
|
|
return in * 1024 * 1024;
|
|
}
|
|
|
|
constexpr usize
|
|
Gigabyte(const usize in)
|
|
{
|
|
return in * 1024 * 1024 * 1024;
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr T MaxValue = std::numeric_limits<T>::max();
|
|
|
|
template <typename T>
|
|
constexpr T MinValue = std::numeric_limits<T>::min();
|
|
|
|
template <typename T>
|
|
constexpr T LowestValue = std::numeric_limits<T>::lowest();
|
|
|
|
template <typename T>
|
|
constexpr T ErrEpsilon = std::numeric_limits<T>::epsilon();
|
|
|
|
template <typename T>
|
|
constexpr T PositiveInf = std::numeric_limits<T>::infinity();
|
|
|
|
template <typename T>
|
|
constexpr T NegativeInf = -std::numeric_limits<T>::infinity();
|
|
|
|
template <typename T>
|
|
constexpr T Qnan = std::numeric_limits<T>::quiet_NaN();
|
|
|
|
template <typename T>
|
|
constexpr T Snan = std::numeric_limits<T>::signalling_NaN();
|