the great text and type rewrite
This commit is contained in:
parent
a220e40d13
commit
d0cc3ad16a
15 changed files with 628 additions and 318 deletions
|
|
@ -21,53 +21,65 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
export module Crafter.Graphics:Types;
|
||||
import std;
|
||||
|
||||
namespace Crafter {
|
||||
export struct MousePoint {
|
||||
std::int_fast32_t x;
|
||||
std::int_fast32_t y;
|
||||
export namespace Crafter {
|
||||
struct MousePoint {
|
||||
std::uint32_t x;
|
||||
std::uint32_t y;
|
||||
};
|
||||
|
||||
struct MouseDelta {
|
||||
std::int64_t x;
|
||||
std::int64_t y;
|
||||
};
|
||||
|
||||
export struct MouseMoveEvent {
|
||||
struct MouseMoveEvent {
|
||||
MousePoint lastMousePos;
|
||||
MousePoint currentMousePos;
|
||||
MousePoint mouseDelta;
|
||||
MouseDelta mouseDelta;
|
||||
};
|
||||
|
||||
export struct ScaleData {
|
||||
std::int_fast32_t x;
|
||||
std::int_fast32_t y;
|
||||
std::int_fast32_t width;
|
||||
std::int_fast32_t height;
|
||||
struct ScaleData {
|
||||
std::int32_t x;
|
||||
std::int32_t y;
|
||||
std::int32_t width;
|
||||
std::int32_t height;
|
||||
};
|
||||
|
||||
export struct ClipRect {
|
||||
std::int_fast32_t left;
|
||||
std::int_fast32_t right;
|
||||
std::int_fast32_t top;
|
||||
std::int_fast32_t bottom;
|
||||
struct ScaleDataBoundless {
|
||||
std::uint32_t x;
|
||||
std::uint32_t y;
|
||||
std::uint32_t width;
|
||||
std::uint32_t height;
|
||||
};
|
||||
|
||||
struct ClipRect {
|
||||
std::int32_t left;
|
||||
std::int32_t right;
|
||||
std::int32_t top;
|
||||
std::int32_t bottom;
|
||||
};
|
||||
|
||||
export struct __attribute__((packed)) Pixel_BU8_GU8_RU8_AU8 {
|
||||
struct __attribute__((packed)) Pixel_BU8_GU8_RU8_AU8 {
|
||||
std::uint8_t b;
|
||||
std::uint8_t g;
|
||||
std::uint8_t r;
|
||||
std::uint8_t a;
|
||||
};
|
||||
|
||||
export struct __attribute__((packed)) Pixel_RU8_GU8_BU8_AU8 {
|
||||
struct __attribute__((packed)) Pixel_RU8_GU8_BU8_AU8 {
|
||||
std::uint8_t r;
|
||||
std::uint8_t g;
|
||||
std::uint8_t b;
|
||||
std::uint8_t a;
|
||||
};
|
||||
|
||||
export struct __attribute__((packed)) Vertex {
|
||||
struct __attribute__((packed)) Vertex {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float w;
|
||||
};
|
||||
export struct __attribute__((packed)) VertexUV {
|
||||
struct __attribute__((packed)) VertexUV {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
|
|
@ -79,7 +91,7 @@ namespace Crafter {
|
|||
float pad[2];
|
||||
};
|
||||
|
||||
export struct __attribute__((packed)) VertexRGBA {
|
||||
struct __attribute__((packed)) VertexRGBA {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
|
|
@ -91,7 +103,7 @@ namespace Crafter {
|
|||
float a;
|
||||
};
|
||||
|
||||
export struct __attribute__((packed)) HeightRGBA {
|
||||
struct __attribute__((packed)) HeightRGBA {
|
||||
float height;
|
||||
|
||||
float pad[3];
|
||||
|
|
@ -102,97 +114,190 @@ namespace Crafter {
|
|||
float a;
|
||||
};
|
||||
|
||||
export struct FrameTime {
|
||||
struct FrameTime {
|
||||
std::chrono::time_point<std::chrono::high_resolution_clock> now;
|
||||
std::chrono::duration<double> delta;
|
||||
};
|
||||
|
||||
export enum class OpaqueType {
|
||||
enum class OpaqueType {
|
||||
FullyOpaque, // All pixels have A of 255
|
||||
SemiOpaque, // All pixels have A of 0 or 255 (no blending needed)
|
||||
Transparent // Color blending is used
|
||||
};
|
||||
|
||||
export constexpr std::int_fast32_t BOUND = 9;
|
||||
export constexpr std::int_fast32_t SCALE = std::numeric_limits<std::int_fast32_t>::max() / BOUND;
|
||||
export constexpr double SCALEDOUBLE = static_cast<double>(std::numeric_limits<std::int_fast32_t>::max()) / BOUND;
|
||||
export constexpr double SCALEDOUBLEU = static_cast<double>(std::numeric_limits<std::uint_fast32_t>::max()) / BOUND;
|
||||
|
||||
export constexpr std::int_fast32_t SCALEBOUNDLESS = std::numeric_limits<std::int_fast32_t>::max();
|
||||
export constexpr double SCALEDOUBLEBOUNDLESS = static_cast<double>(std::numeric_limits<std::int_fast32_t>::max());
|
||||
constexpr std::int8_t BOUND8 = 9;
|
||||
constexpr std::int8_t SCALE8 = std::numeric_limits<std::int8_t>::max() / BOUND8;
|
||||
constexpr std::uint8_t SCALEBOUNDLESS8 = std::numeric_limits<std::uint8_t>::max();
|
||||
|
||||
export constexpr std::int_fast32_t SCALEBOUNDLESSU = std::numeric_limits<std::uint_fast32_t>::max();
|
||||
export constexpr double SCALEDOUBLEBOUNDLESSU = static_cast<double>(std::numeric_limits<std::uint_fast32_t>::max());
|
||||
constexpr double SCALEDOUBLE8 = static_cast<double>(std::numeric_limits<std::int8_t>::max() / BOUND8);
|
||||
constexpr double SCALEBOUNDLESSDOUBLE8 = static_cast<double>(std::numeric_limits<std::uint8_t>::max());
|
||||
|
||||
export constexpr std::int_fast32_t FractionalToMapped(double f) {
|
||||
return std::int_fast32_t(f * SCALEDOUBLE);
|
||||
constexpr std::int16_t BOUND16 = 9;
|
||||
constexpr std::int16_t SCALE16 = std::numeric_limits<std::int16_t>::max() / BOUND16;
|
||||
constexpr std::uint16_t SCALEBOUNDLESS16 = std::numeric_limits<std::uint16_t>::max();
|
||||
|
||||
constexpr double SCALEDOUBLE16 = static_cast<double>(std::numeric_limits<std::int16_t>::max() / BOUND16);
|
||||
constexpr double SCALEBOUNDLESSDOUBLE16 = static_cast<double>(std::numeric_limits<std::uint16_t>::max());
|
||||
|
||||
constexpr std::int32_t BOUND32 = 9;
|
||||
constexpr std::int32_t SCALE32 = std::numeric_limits<std::int32_t>::max() / BOUND32;
|
||||
constexpr std::uint32_t SCALEBOUNDLESS32 = std::numeric_limits<std::uint32_t>::max();
|
||||
|
||||
constexpr double SCALEDOUBLE32 = static_cast<double>(std::numeric_limits<std::int32_t>::max() / BOUND32);
|
||||
constexpr double SCALEBOUNDLESSDOUBLE32 = static_cast<double>(std::numeric_limits<std::uint32_t>::max());
|
||||
|
||||
constexpr std::int64_t BOUND64 = 9;
|
||||
constexpr std::int64_t SCALE64 = std::numeric_limits<std::int64_t>::max() / BOUND64;
|
||||
constexpr std::uint64_t SCALEBOUNDLESS64 = std::numeric_limits<std::uint64_t>::max();
|
||||
|
||||
constexpr double SCALEDOUBLE64 = static_cast<double>(std::numeric_limits<std::int64_t>::max() / BOUND64);
|
||||
constexpr double SCALEBOUNDLESSDOUBLE64 = static_cast<double>(std::numeric_limits<std::uint64_t>::max());
|
||||
|
||||
template <typename T>
|
||||
constexpr T FractionalToMapped(double f) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::int8_t> || std::is_same_v<T, std::uint8_t>) {
|
||||
return T(f * SCALEDOUBLE8);
|
||||
} else if constexpr (std::is_same_v<T, std::int16_t> || std::is_same_v<T, std::uint16_t>) {
|
||||
return T(f * SCALEDOUBLE16);
|
||||
} else if constexpr (std::is_same_v<T, std::int32_t> || std::is_same_v<T, std::uint32_t>) {
|
||||
return T(f * SCALEDOUBLE32);
|
||||
} else {
|
||||
return T(f * SCALEDOUBLE64);
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::uint_fast32_t FractionalToMappedU(double f) {
|
||||
return std::uint_fast32_t(f * SCALEDOUBLEU);
|
||||
template <typename T>
|
||||
constexpr T FractionalToMappedBoundless(double f) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t>) {
|
||||
return T(f * SCALEBOUNDLESSDOUBLE8);
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return T(f * SCALEBOUNDLESSDOUBLE16);
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return T(f * SCALEBOUNDLESSDOUBLE32);
|
||||
} else {
|
||||
return T(f * SCALEBOUNDLESSDOUBLE64);
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr double MappedToFractional(std::int_fast32_t mapped) {
|
||||
return static_cast<double>(mapped) / SCALEDOUBLE;
|
||||
template <typename T>
|
||||
constexpr double MappedToFractional(T mapped) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::int8_t> || std::is_same_v<T, std::uint8_t>) {
|
||||
return mapped / SCALEDOUBLE8;
|
||||
} else if constexpr (std::is_same_v<T, std::int16_t> || std::is_same_v<T, std::uint16_t>) {
|
||||
return mapped / SCALEDOUBLE16;
|
||||
} else if constexpr (std::is_same_v<T, std::int32_t> || std::is_same_v<T, std::uint32_t>) {
|
||||
return mapped / SCALEDOUBLE32;
|
||||
} else {
|
||||
return mapped / SCALEDOUBLE64;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t MappedToPixel(std::int_fast32_t mapped, std::int_fast32_t width) {
|
||||
return mapped / (SCALE / width);
|
||||
template <typename T>
|
||||
constexpr double MappedToFractionalBoundless(T mapped) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t>) {
|
||||
return mapped / SCALEBOUNDLESSDOUBLE8;
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return mapped / SCALEBOUNDLESSDOUBLE16;
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return mapped / SCALEBOUNDLESSDOUBLE32;
|
||||
} else {
|
||||
return mapped / SCALEBOUNDLESSDOUBLE64;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t PixelToMapped(std::int_fast32_t pixel, std::int_fast32_t width) {
|
||||
return pixel * (SCALE / width);
|
||||
template <typename T, typename T2>
|
||||
constexpr T MappedToAbsolute(T mapped, T2 absolute) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::int8_t> || std::is_same_v<T, std::uint8_t>) {
|
||||
return static_cast<std::int16_t>(mapped) * absolute / SCALE8;
|
||||
} else if constexpr (std::is_same_v<T, std::int16_t> || std::is_same_v<T, std::uint16_t>) {
|
||||
return static_cast<std::int32_t>(mapped) * absolute / SCALE16;
|
||||
} else if constexpr (std::is_same_v<T, std::int32_t> || std::is_same_v<T, std::uint32_t>) {
|
||||
return static_cast<std::int64_t>(mapped) * absolute / SCALE32;
|
||||
} else {
|
||||
return static_cast<__int128>(mapped) * absolute / SCALE64;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t RelativeToAbsolute(std::int_fast32_t relative, std::int_fast32_t full) {
|
||||
return static_cast<std::int_fast32_t>(
|
||||
(static_cast<__int128>(relative) * full) / SCALE
|
||||
);
|
||||
template <typename T, typename T2>
|
||||
constexpr T MappedToAbsoluteBoundless(T mapped, T2 absolute) requires(std::is_integral_v<T>) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t>) {
|
||||
return static_cast<std::uint16_t>(mapped) * absolute / SCALEBOUNDLESS8;
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return static_cast<std::uint32_t>(mapped) * absolute / SCALEBOUNDLESS16;
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return static_cast<std::uint64_t>(mapped) * absolute / SCALEBOUNDLESS32;
|
||||
} else {
|
||||
return static_cast<unsigned __int128>(mapped) * absolute / SCALEBOUNDLESS64;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t AbsoluteToRelative(std::int_fast32_t absolute, std::int_fast32_t relative) {
|
||||
return static_cast<std::int_fast32_t>(
|
||||
(static_cast<__int128>(absolute) * SCALE) / relative
|
||||
);
|
||||
// template <typename T, typename T2>
|
||||
// constexpr T PixelToMappedBoundless(T pixel, T2 screen) requires(std::is_integral_v<T>) {
|
||||
// if constexpr (std::is_same_v<T, std::uint8_t>) {
|
||||
// return (static_cast<std::uint16_t>(relative) * SCALE8) / (static_cast<std::uint16_t>(absolute) * SCALE8);
|
||||
// } else if constexpr (std::is_same_v<T, std::uint16_t>) {
|
||||
// return (static_cast<std::uint32_t>(relative) * SCALE16) / (static_cast<std::uint32_t>(absolute) * SCALE16);
|
||||
// } else if constexpr (std::is_same_v<T, std::uint32_t>) {
|
||||
// return (static_cast<std::uint64_t>(relative) * SCALE32) / (static_cast<std::uint64_t>(absolute) * SCALE32);
|
||||
// } else {
|
||||
// return (static_cast<unsigned __int128>(relative) * SCALE32) / (static_cast<unsigned __int128>(absolute) * SCALE32);
|
||||
// }
|
||||
// }
|
||||
|
||||
template <typename T, typename T2>
|
||||
constexpr T AbsoluteToMapped(T absolute, T2 mapped) {
|
||||
if constexpr (std::is_same_v<T, std::int8_t> || std::is_same_v<T, std::uint8_t>) {
|
||||
return static_cast<std::int16_t>(absolute) * SCALE8 / mapped;
|
||||
} else if constexpr (std::is_same_v<T, std::int16_t> || std::is_same_v<T, std::uint16_t> ) {
|
||||
return static_cast<std::int32_t>(absolute) * SCALE16 / mapped;
|
||||
} else if constexpr (std::is_same_v<T, std::int32_t>|| std::is_same_v<T, std::uint32_t>) {
|
||||
return static_cast<std::int64_t>(absolute) * SCALE32 / mapped;
|
||||
} else {
|
||||
return static_cast<__int128>(absolute) * SCALE64 / mapped;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t BoundToBoundless(std::int_fast32_t bound) {
|
||||
return bound * BOUND;
|
||||
template <typename T, typename T2>
|
||||
constexpr T AbsoluteToMappedBoundless(T absolute, T2 mapped) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t> ) {
|
||||
return static_cast<std::uint16_t>(absolute) * SCALEBOUNDLESS8 / mapped;
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return static_cast<std::uint32_t>(absolute) * SCALEBOUNDLESS16 / mapped;
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return static_cast<std::uint64_t>(absolute) * SCALEBOUNDLESS32 / mapped;
|
||||
} else {
|
||||
return static_cast<unsigned __int128>(absolute) * SCALEBOUNDLESS64 / mapped;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr T BoundToBoundless(T mapped) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t>) {
|
||||
return mapped * BOUND8 * 2;
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return mapped * BOUND16 * 2;
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return mapped * BOUND32 * 2;
|
||||
} else {
|
||||
return mapped * BOUND64 * 2;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t BoundToBoundlessU(std::int_fast32_t bound) {
|
||||
return static_cast<std::uint_fast32_t>((bound*2)) * BOUND;
|
||||
template <typename T>
|
||||
constexpr T BoundlessToBound(T mapped) {
|
||||
if constexpr (std::is_same_v<T, std::uint8_t> || std::is_same_v<T, std::int8_t> ) {
|
||||
return mapped / 2;
|
||||
} else if constexpr (std::is_same_v<T, std::uint16_t> || std::is_same_v<T, std::int16_t>) {
|
||||
return mapped / 2;
|
||||
} else if constexpr (std::is_same_v<T, std::uint32_t> || std::is_same_v<T, std::int32_t>) {
|
||||
return mapped / 2;
|
||||
} else {
|
||||
return mapped / 2;
|
||||
}
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t BoundlessToBound(std::int_fast32_t bound) {
|
||||
return bound / BOUND;
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t BoundlessUToBound(std::uint_fast32_t bound) {
|
||||
return static_cast<std::int_fast32_t>(bound / 2) / BOUND;
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t FractionalToMappedBoundless(double f) {
|
||||
return std::int_fast32_t(f * SCALEDOUBLEBOUNDLESS);
|
||||
}
|
||||
|
||||
export constexpr std::uint_fast32_t FractionalToMappedBoundlessU(double f) {
|
||||
return std::uint_fast32_t(f * SCALEDOUBLEBOUNDLESSU);
|
||||
}
|
||||
|
||||
export constexpr double MappedToFractionalBoundless(std::int_fast32_t mapped) {
|
||||
return static_cast<double>(mapped) / SCALEDOUBLEBOUNDLESS;
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t MappedToPixelBoundless(std::int_fast32_t mapped, std::int_fast32_t width) {
|
||||
return mapped / (SCALEBOUNDLESS / width);
|
||||
}
|
||||
|
||||
export constexpr std::int_fast32_t PixelToMappedBoundless(std::int_fast32_t pixel, std::int_fast32_t width) {
|
||||
return pixel * (SCALEBOUNDLESS / width);
|
||||
}
|
||||
|
||||
export enum class CrafterKeys {
|
||||
enum class CrafterKeys {
|
||||
// Alphabetic keys
|
||||
A, B, C, D, E, F, G, H, I, J, K, L, M,
|
||||
N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue