the great text and type rewrite
This commit is contained in:
parent
a220e40d13
commit
d0cc3ad16a
15 changed files with 628 additions and 318 deletions
|
|
@ -25,13 +25,13 @@ import :Types;
|
|||
export namespace Crafter {
|
||||
class GridElement : public Transform {
|
||||
public:
|
||||
std::uint_fast32_t columns;
|
||||
std::uint_fast32_t rows;
|
||||
std::int_fast32_t spacingX;
|
||||
std::int_fast32_t spacingY;
|
||||
std::int_fast32_t paddingX;
|
||||
std::int_fast32_t paddingY;
|
||||
GridElement(std::uint_fast32_t columns, std::uint_fast32_t rows, std::int_fast32_t spacingX, std::int_fast32_t spacingY, std::int_fast32_t paddingX, std::int_fast32_t paddingY, Anchor anchor);
|
||||
std::uint32_t columns;
|
||||
std::uint32_t rows;
|
||||
std::int32_t spacingX;
|
||||
std::int32_t spacingY;
|
||||
std::int32_t paddingX;
|
||||
std::int32_t paddingY;
|
||||
GridElement(std::uint32_t columns, std::uint32_t rows, std::int32_t spacingX, std::int32_t spacingY, std::int32_t paddingX, std::int32_t paddingY, Anchor anchor);
|
||||
void UpdatePositionScaled(Window& window);
|
||||
void UpdatePosition(Window& window) override;
|
||||
void UpdatePosition(Window& window, Transform& parent) override;
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ export namespace Crafter {
|
|||
Event<MousePoint> onMouseLeftHold;
|
||||
Event<MousePoint> onMouseRightRelease;
|
||||
Event<MousePoint> onMouseLeftRelease;
|
||||
ScaleDataBoundless mouseScaled;
|
||||
|
||||
MouseElement();
|
||||
MouseElement(WindowMouse& window);
|
||||
|
|
|
|||
|
|
@ -20,41 +20,61 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|||
module;
|
||||
#define STB_IMAGE_IMPLEMENTATION
|
||||
#include "../lib/stb_image.h"
|
||||
#include "../lib/stb_truetype.h"
|
||||
export module Crafter.Graphics:RenderingElement;
|
||||
import std;
|
||||
import :Transform;
|
||||
import :Font;
|
||||
import :Types;
|
||||
import :Image;
|
||||
import :Window;
|
||||
|
||||
export namespace Crafter {
|
||||
enum class TextAlignment {
|
||||
Left,
|
||||
Center,
|
||||
Right
|
||||
};
|
||||
|
||||
enum class TextOverflowMode {
|
||||
Clip,
|
||||
Wrap
|
||||
};
|
||||
|
||||
enum class TextScaleMode {
|
||||
None,
|
||||
Font,
|
||||
Element,
|
||||
Buffer
|
||||
};
|
||||
|
||||
struct RenderElementScalingOwning {
|
||||
std::vector<Pixel_BU8_GU8_RU8_AU8> scalingBuffer;
|
||||
std::uint_fast32_t bufferWidth;
|
||||
std::uint_fast32_t bufferHeight;
|
||||
std::uint32_t bufferWidth;
|
||||
std::uint32_t bufferHeight;
|
||||
bool bufferUpdated = true;
|
||||
RenderElementScalingOwning() = default;
|
||||
RenderElementScalingOwning(std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight) : scalingBuffer(bufferWidth*bufferHeight), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
||||
RenderElementScalingOwning(std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(bufferWidth*bufferHeight), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
struct RenderElementScalingNonOwning {
|
||||
Pixel_BU8_GU8_RU8_AU8* scalingBuffer;
|
||||
std::uint_fast32_t bufferWidth;
|
||||
std::uint_fast32_t bufferHeight;
|
||||
std::uint32_t bufferWidth;
|
||||
std::uint32_t bufferHeight;
|
||||
bool bufferUpdated = true;
|
||||
RenderElementScalingNonOwning() = default;
|
||||
RenderElementScalingNonOwning(Pixel_BU8_GU8_RU8_AU8* scalingBuffer, std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight) : scalingBuffer(scalingBuffer), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
||||
RenderElementScalingNonOwning(Pixel_BU8_GU8_RU8_AU8* scalingBuffer, std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(scalingBuffer), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
struct RenderElementRotating {
|
||||
std::uint_fast32_t rotation;
|
||||
std::uint32_t rotation;
|
||||
bool rotationUpdated = true;
|
||||
RenderElementRotating() = default;
|
||||
RenderElementRotating(std::uint_fast32_t rotation) : rotation(rotation) {
|
||||
RenderElementRotating(std::uint32_t rotation) : rotation(rotation) {
|
||||
|
||||
}
|
||||
};
|
||||
|
|
@ -100,49 +120,49 @@ export namespace Crafter {
|
|||
RenderingElement(Anchor anchor, OpaqueType opaque) : RenderingElementBase(anchor, opaque) {
|
||||
|
||||
}
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint_fast32_t rotation) requires(Rotating) : RenderingElementBase(anchor, opaque), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint32_t rotation) requires(Rotating) : RenderingElementBase(anchor, opaque), RotatingBase<Rotating>(rotation) {
|
||||
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath) : RenderingElementBase(anchor) {
|
||||
LoadImage(imagePath);
|
||||
}
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath, std::uint_fast32_t rotation) requires(Rotating) : RenderingElementBase(anchor), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath, std::uint32_t rotation) requires(Rotating) : RenderingElementBase(anchor), RotatingBase<Rotating>(rotation) {
|
||||
LoadImage(imagePath);
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath, OpaqueType opaque) : RenderingElementBase(anchor, opaque) {
|
||||
LoadImageNoOpaqueCheck(imagePath);
|
||||
}
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath, OpaqueType opaque, std::uint_fast32_t rotation) requires(Rotating) : RenderingElementBase(anchor, opaque), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, const std::string_view imagePath, OpaqueType opaque, std::uint32_t rotation) requires(Rotating) : RenderingElementBase(anchor, opaque), RotatingBase<Rotating>(rotation) {
|
||||
LoadImageNoOpaqueCheck(imagePath);
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight, Pixel_BU8_GU8_RU8_AU8* scalingBuffer) requires(Scaling && !Owning) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight, scalingBuffer) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint32_t bufferWidth, std::uint32_t bufferHeight, Pixel_BU8_GU8_RU8_AU8* scalingBuffer) requires(Scaling && !Owning) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight, scalingBuffer) {
|
||||
|
||||
}
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight, Pixel_BU8_GU8_RU8_AU8* scalingBuffer, std::uint_fast32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight, scalingBuffer), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint32_t bufferWidth, std::uint32_t bufferHeight, Pixel_BU8_GU8_RU8_AU8* scalingBuffer, std::uint32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight, scalingBuffer), RotatingBase<Rotating>(rotation) {
|
||||
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, Image& image) requires(Scaling && !Owning) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height) {
|
||||
|
||||
}
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, Image& image, std::uint_fast32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, Image& image, std::uint32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height), RotatingBase<Rotating>(rotation) {
|
||||
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, Image& image) requires(Scaling && !Owning) : RenderingElementBase(anchor, image.opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height) {
|
||||
|
||||
}
|
||||
RenderingElement(Anchor anchor, Image& image, std::uint_fast32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, image.opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height), RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, Image& image, std::uint32_t rotation) requires(Scaling && !Owning && Rotating) : RenderingElementBase(anchor, image.opaque), ScalingBase<Scaling, Owning>(image.buffer.data(), image.width, image.height), RotatingBase<Rotating>(rotation) {
|
||||
|
||||
}
|
||||
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight) requires(Owning) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint32_t bufferWidth, std::uint32_t bufferHeight) requires(Owning) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight) {
|
||||
|
||||
}
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint_fast32_t bufferWidth, std::uint_fast32_t bufferHeight, std::uint_fast32_t rotation) requires(Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight) , RotatingBase<Rotating>(rotation) {
|
||||
RenderingElement(Anchor anchor, OpaqueType opaque, std::uint32_t bufferWidth, std::uint32_t bufferHeight, std::uint32_t rotation) requires(Owning && Rotating) : RenderingElementBase(anchor, opaque), ScalingBase<Scaling, Owning>(bufferWidth, bufferHeight) , RotatingBase<Rotating>(rotation) {
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -150,20 +170,20 @@ export namespace Crafter {
|
|||
RenderingElement& operator=(RenderingElement&) = delete;
|
||||
|
||||
void ScaleNearestNeighbor() requires(Scaling) {
|
||||
for (std::uint_fast32_t y = 0; y < scaled.height; y++) {
|
||||
std::uint_fast32_t srcY = y * ScalingBase<true, Owning>::bufferHeight / scaled.height;
|
||||
for (std::uint_fast32_t x = 0; x < scaled.width; x++) {
|
||||
std::uint_fast32_t srcX = x * ScalingBase<true, Owning>::bufferWidth / scaled.width;
|
||||
for (std::uint32_t y = 0; y < scaled.height; y++) {
|
||||
std::uint32_t srcY = y * ScalingBase<true, Owning>::bufferHeight / scaled.height;
|
||||
for (std::uint32_t x = 0; x < scaled.width; x++) {
|
||||
std::uint32_t srcX = x * ScalingBase<true, Owning>::bufferWidth / scaled.width;
|
||||
buffer[y * scaled.width + x] = ScalingBase<true, Owning>::scalingBuffer[srcY * ScalingBase<true, Owning>::bufferWidth + srcX];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ScaleRotating() requires(Scaling) {
|
||||
const double rad = (static_cast<double>(RotatingBase<true>::rotation) / static_cast<double>(std::numeric_limits<std::uint_fast32_t>::max())) * 2.0 * std::numbers::pi;
|
||||
const double rad = (static_cast<double>(RotatingBase<true>::rotation) / static_cast<double>(std::numeric_limits<std::uint32_t>::max())) * 2.0 * std::numbers::pi;
|
||||
|
||||
const std::uint_fast32_t dstWidth = scaled.width;
|
||||
const std::uint_fast32_t dstHeight = scaled.height;
|
||||
const std::uint32_t dstWidth = scaled.width;
|
||||
const std::uint32_t dstHeight = scaled.height;
|
||||
|
||||
const double c2 = std::abs(std::cos(rad));
|
||||
const double s2 = std::abs(std::sin(rad));
|
||||
|
|
@ -171,8 +191,8 @@ export namespace Crafter {
|
|||
const double rotatedWidth = dstWidth * c2 + dstHeight * s2;
|
||||
const double rotatedHeight = dstWidth * s2 + dstHeight * c2;
|
||||
|
||||
const std::uint_fast32_t diffX = static_cast<std::uint_fast32_t>(std::ceil((rotatedWidth - dstWidth) * 0.5));
|
||||
const std::uint_fast32_t diffY = static_cast<std::uint_fast32_t>(std::ceil((rotatedHeight - dstHeight) * 0.5));
|
||||
const std::uint32_t diffX = static_cast<std::uint32_t>(std::ceil((rotatedWidth - dstWidth) * 0.5));
|
||||
const std::uint32_t diffY = static_cast<std::uint32_t>(std::ceil((rotatedHeight - dstHeight) * 0.5));
|
||||
|
||||
scaled.width += diffX + diffX;
|
||||
scaled.height += diffY + diffY;
|
||||
|
|
@ -198,8 +218,8 @@ export namespace Crafter {
|
|||
const double scaleX = static_cast<double>(ScalingBase<true, Owning>::bufferWidth) / dstWidth;
|
||||
const double scaleY = static_cast<double>(ScalingBase<true, Owning>::bufferHeight) / dstHeight;
|
||||
|
||||
for (std::uint_fast32_t yB = 0; yB < scaled.height; ++yB) {
|
||||
for (std::uint_fast32_t xB = 0; xB < scaled.width; ++xB) {
|
||||
for (std::uint32_t yB = 0; yB < scaled.height; ++yB) {
|
||||
for (std::uint32_t xB = 0; xB < scaled.width; ++xB) {
|
||||
|
||||
// ---- Destination pixel relative to center ----
|
||||
const double dx = (static_cast<double>(xB) - dstCx) * scaleX;
|
||||
|
|
@ -210,8 +230,8 @@ export namespace Crafter {
|
|||
const double sy = (s * dx + c * dy) + srcCy;
|
||||
|
||||
// ---- Nearest neighbour sampling ----
|
||||
const std::int_fast32_t srcX = static_cast<std::int_fast32_t>(std::round(sx));
|
||||
const std::int_fast32_t srcY = static_cast<std::int_fast32_t>(std::round(sy));
|
||||
const std::int32_t srcX = static_cast<std::int32_t>(std::round(sx));
|
||||
const std::int32_t srcY = static_cast<std::int32_t>(std::round(sy));
|
||||
|
||||
if (srcX >= 0 && srcX < ScalingBase<true, Owning>::bufferWidth && srcY >= 0 && srcY < ScalingBase<true, Owning>::bufferHeight) {
|
||||
buffer[yB * scaled.width + xB] = ScalingBase<true, Owning>::scalingBuffer[srcY * ScalingBase<true, Owning>::bufferWidth + srcX];
|
||||
|
|
@ -308,9 +328,9 @@ export namespace Crafter {
|
|||
opaque = OpaqueType::FullyOpaque;
|
||||
|
||||
if constexpr(Scaling) {
|
||||
for(std::uint_fast32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint_fast32_t y = 0; y < ySize; y++) {
|
||||
std::uint_fast32_t idx = (x*ySize+y)*4;
|
||||
for(std::uint32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint32_t y = 0; y < ySize; y++) {
|
||||
std::uint32_t idx = (x*ySize+y)*4;
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].r = bgData[idx];
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].g = bgData[idx+1];
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].b = bgData[idx+2];
|
||||
|
|
@ -318,10 +338,10 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
|
||||
for(std::uint_fast32_t i = 0; i < xSize*ySize; i++) {
|
||||
for(std::uint32_t i = 0; i < xSize*ySize; i++) {
|
||||
if(ScalingBase<true, Owning>::scalingBuffer[i].a != 255) {
|
||||
opaque = OpaqueType::SemiOpaque;
|
||||
for(std::uint_fast32_t i2 = 0; i2 < xSize*ySize; i2++) {
|
||||
for(std::uint32_t i2 = 0; i2 < xSize*ySize; i2++) {
|
||||
if(ScalingBase<true, Owning>::scalingBuffer[i2].a != 0 && ScalingBase<true, Owning>::scalingBuffer[i2].a != 255) {
|
||||
opaque = OpaqueType::Transparent;
|
||||
return;
|
||||
|
|
@ -331,9 +351,9 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
for(std::uint_fast32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint_fast32_t y = 0; y < ySize; y++) {
|
||||
std::uint_fast32_t idx = (x*ySize+y)*4;
|
||||
for(std::uint32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint32_t y = 0; y < ySize; y++) {
|
||||
std::uint32_t idx = (x*ySize+y)*4;
|
||||
buffer[x*ySize+y].r = bgData[idx];
|
||||
buffer[x*ySize+y].g = bgData[idx+1];
|
||||
buffer[x*ySize+y].b = bgData[idx+2];
|
||||
|
|
@ -341,10 +361,10 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
|
||||
for(std::uint_fast32_t i = 0; i < xSize*ySize; i++) {
|
||||
for(std::uint32_t i = 0; i < xSize*ySize; i++) {
|
||||
if(buffer[i].a != 255) {
|
||||
opaque = OpaqueType::SemiOpaque;
|
||||
for(std::uint_fast32_t i2 = 0; i2 < xSize*ySize; i2++) {
|
||||
for(std::uint32_t i2 = 0; i2 < xSize*ySize; i2++) {
|
||||
if(buffer[i2].a != 0 && buffer[i2].a != 255) {
|
||||
opaque = OpaqueType::Transparent;
|
||||
return;
|
||||
|
|
@ -375,9 +395,9 @@ export namespace Crafter {
|
|||
|
||||
|
||||
if constexpr(Scaling) {
|
||||
for(std::uint_fast32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint_fast32_t y = 0; y < ySize; y++) {
|
||||
std::uint_fast32_t idx = (x*ySize+y)*4;
|
||||
for(std::uint32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint32_t y = 0; y < ySize; y++) {
|
||||
std::uint32_t idx = (x*ySize+y)*4;
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].r = bgData[idx];
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].g = bgData[idx+1];
|
||||
ScalingBase<true, Owning>::scalingBuffer[x*ySize+y].b = bgData[idx+2];
|
||||
|
|
@ -385,9 +405,9 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
} else {
|
||||
for(std::uint_fast32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint_fast32_t y = 0; y < ySize; y++) {
|
||||
std::uint_fast32_t idx = (x*ySize+y)*4;
|
||||
for(std::uint32_t x = 0; x < xSize; x++) {
|
||||
for(std::uint32_t y = 0; y < ySize; y++) {
|
||||
std::uint32_t idx = (x*ySize+y)*4;
|
||||
buffer[x*ySize+y].r = bgData[idx];
|
||||
buffer[x*ySize+y].g = bgData[idx+1];
|
||||
buffer[x*ySize+y].b = bgData[idx+2];
|
||||
|
|
@ -396,5 +416,238 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
}
|
||||
std::vector<std::string_view> ResizeText(Window& window, const std::string_view text, float size, Font& font, TextOverflowMode overflowMode = TextOverflowMode::Clip, TextScaleMode scaleMode = TextScaleMode::None, Transform* parent = nullptr) {
|
||||
float scale = stbtt_ScaleForPixelHeight(&font.font, size);
|
||||
int baseline = (int)(font.ascent * scale);
|
||||
|
||||
std::vector<std::string_view> lines;
|
||||
std::string_view remaining = text;
|
||||
|
||||
std::uint32_t lineHeight = (font.ascent - font.descent) * scale;
|
||||
|
||||
if(overflowMode == TextOverflowMode::Clip) {
|
||||
while (!remaining.empty()) {
|
||||
// Find next newline or end of string
|
||||
auto newlinePos = remaining.find('\n');
|
||||
if (newlinePos != std::string_view::npos) {
|
||||
lines.emplace_back(remaining.substr(0, newlinePos));
|
||||
remaining = remaining.substr(newlinePos + 1);
|
||||
} else {
|
||||
lines.emplace_back(remaining);
|
||||
break;
|
||||
}
|
||||
}
|
||||
std::uint32_t maxWidth = 0;
|
||||
|
||||
for(const std::string_view line: lines) {
|
||||
std::uint32_t lineWidth = 0;
|
||||
for (const char c : line) {
|
||||
int advance, lsb;
|
||||
stbtt_GetCodepointHMetrics(&font.font, c, &advance, &lsb);
|
||||
lineWidth += (int)(advance * scale);
|
||||
}
|
||||
if(lineWidth > maxWidth) {
|
||||
maxWidth = lineWidth;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if(scaleMode == TextScaleMode::Element) {
|
||||
std::int32_t logicalPerPixelY = anchor.height / scaled.height;
|
||||
std::int32_t oldHeight = anchor.height;
|
||||
std::int32_t logicalPerPixelX = anchor.width / scaled.width;
|
||||
std::int32_t oldwidth = anchor.width;
|
||||
anchor.height = lineHeight * logicalPerPixelY;
|
||||
anchor.width = maxWidth * logicalPerPixelX;
|
||||
if(oldHeight != anchor.height || oldwidth != anchor.width) {
|
||||
if(parent) {
|
||||
UpdatePosition(window, *parent);
|
||||
} else {
|
||||
UpdatePosition(window);
|
||||
}
|
||||
}
|
||||
} else if(scaleMode == TextScaleMode::Font) {
|
||||
//todo
|
||||
} else if(scaleMode == TextScaleMode::Buffer) {
|
||||
if constexpr(Scaling && Owning) {
|
||||
std::uint32_t neededHeight = lines.size() * lineHeight;
|
||||
if(neededHeight != ScalingBase<true, true>::bufferHeight || maxWidth != ScalingBase<true, true>::bufferWidth) {
|
||||
ScalingBase<true, true>::bufferHeight = neededHeight;
|
||||
ScalingBase<true, true>::bufferWidth = maxWidth;
|
||||
ScalingBase<true, true>::bufferUpdated = true;
|
||||
ScalingBase<true, Owning>::scalingBuffer.resize(neededHeight*maxWidth);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if constexpr(Scaling) {
|
||||
lines.resize(ScalingBase<true, Owning>::bufferHeight / lines.size());
|
||||
} else {
|
||||
lines.resize(scaled.height / lines.size());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
while (!remaining.empty()) {
|
||||
std::string_view line;
|
||||
auto newlinePos = remaining.find('\n');
|
||||
if (newlinePos != std::string_view::npos) {
|
||||
line = remaining.substr(0, newlinePos);
|
||||
remaining = remaining.substr(newlinePos + 1);
|
||||
} else {
|
||||
line = remaining;
|
||||
remaining = "";
|
||||
}
|
||||
|
||||
std::uint32_t lineWidth = 0;
|
||||
std::size_t lastWrapPos = 0; // position of last space that can be used to wrap
|
||||
std::size_t startPos = 0;
|
||||
|
||||
for (std::size_t i = 0; i < line.size(); ++i) {
|
||||
char c = line[i];
|
||||
|
||||
// get width of this character
|
||||
int advance, lsb;
|
||||
stbtt_GetCodepointHMetrics(&font.font, c, &advance, &lsb);
|
||||
lineWidth += (std::uint32_t)(advance * scale);
|
||||
|
||||
// remember last space for wrapping
|
||||
if (c == ' ') {
|
||||
lastWrapPos = i;
|
||||
}
|
||||
|
||||
// if line exceeds width, wrap
|
||||
if (lineWidth > scaled.width) {
|
||||
std::size_t wrapPos;
|
||||
if (lastWrapPos > startPos) {
|
||||
wrapPos = lastWrapPos; // wrap at last space
|
||||
} else {
|
||||
wrapPos = i; // no space, hard wrap
|
||||
}
|
||||
|
||||
// push the line up to wrapPos
|
||||
lines.push_back(line.substr(startPos, wrapPos - startPos));
|
||||
|
||||
// skip any spaces at the beginning of next line
|
||||
startPos = wrapPos;
|
||||
while (startPos < line.size() && line[startPos] == ' ') {
|
||||
++startPos;
|
||||
}
|
||||
|
||||
// reset width and i
|
||||
lineWidth = 0;
|
||||
i = startPos - 1; // -1 because loop will increment i
|
||||
}
|
||||
}
|
||||
|
||||
// add the remaining part of the line
|
||||
if (startPos < line.size()) {
|
||||
lines.push_back(line.substr(startPos));
|
||||
}
|
||||
}
|
||||
|
||||
if(scaleMode == TextScaleMode::Element) {
|
||||
std::int32_t logicalPerPixelY = anchor.height / scaled.height;
|
||||
std::int32_t oldHeight = anchor.height;
|
||||
anchor.height = lineHeight * logicalPerPixelY;
|
||||
if(oldHeight != anchor.height) {
|
||||
if(parent) {
|
||||
UpdatePosition(window, *parent);
|
||||
} else {
|
||||
UpdatePosition(window);
|
||||
}
|
||||
}
|
||||
} else if(scaleMode == TextScaleMode::Font) {
|
||||
//todo
|
||||
} else if(scaleMode == TextScaleMode::Buffer) {
|
||||
if constexpr(Scaling && Owning) {
|
||||
std::uint32_t neededHeight = lines.size() * lineHeight;
|
||||
if(neededHeight != ScalingBase<true, true>::bufferHeight) {
|
||||
ScalingBase<true, true>::bufferHeight = neededHeight;
|
||||
ScalingBase<true, true>::bufferUpdated = true;
|
||||
ScalingBase<true, Owning>::scalingBuffer.resize(neededHeight*ScalingBase<true, true>::bufferWidth);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if constexpr(Scaling) {
|
||||
lines.resize(ScalingBase<true, Owning>::bufferHeight / lines.size());
|
||||
} else {
|
||||
lines.resize(scaled.height / lines.size());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return lines;
|
||||
}
|
||||
void RenderText(Window& window, std::span<const std::string_view> lines, float size, Pixel_BU8_GU8_RU8_AU8 color, Font& font, TextAlignment alignment = TextAlignment::Left, std::uint32_t offsetX = 0, std::uint32_t offsetY = 0) {
|
||||
float scale = stbtt_ScaleForPixelHeight(&font.font, size);
|
||||
int baseline = (int)(font.ascent * scale);
|
||||
std::uint32_t lineHeight = (font.ascent - font.descent) * scale;
|
||||
std::uint32_t currentY = baseline;
|
||||
for(std::string_view line : lines) {
|
||||
|
||||
std::uint32_t lineWidth = 0;
|
||||
for (const char c : line) {
|
||||
int advance, lsb;
|
||||
stbtt_GetCodepointHMetrics(&font.font, c, &advance, &lsb);
|
||||
lineWidth += (int)(advance * scale);
|
||||
}
|
||||
|
||||
std::uint32_t startX = 0;
|
||||
switch (alignment) {
|
||||
case TextAlignment::Left:
|
||||
startX = 0;
|
||||
break;
|
||||
case TextAlignment::Center:
|
||||
startX = (scaled.width - lineWidth) / 2;
|
||||
break;
|
||||
case TextAlignment::Right:
|
||||
startX = scaled.width - lineWidth;
|
||||
break;
|
||||
}
|
||||
std::uint32_t x = startX;
|
||||
|
||||
for (std::size_t i = 0; i < line.size(); ++i) {
|
||||
int codepoint = line[i];
|
||||
|
||||
int ax;
|
||||
int lsb;
|
||||
stbtt_GetCodepointHMetrics(&font.font, codepoint, &ax, &lsb);
|
||||
|
||||
int c_x1, c_y1, c_x2, c_y2;
|
||||
stbtt_GetCodepointBitmapBox(&font.font, codepoint, scale, scale, &c_x1, &c_y1, &c_x2, &c_y2);
|
||||
|
||||
int w = c_x2 - c_x1;
|
||||
int h = c_y2 - c_y1;
|
||||
|
||||
std::vector<unsigned char> bitmap(w * h);
|
||||
stbtt_MakeCodepointBitmap(&font.font, bitmap.data(), w, h, w, scale, scale, codepoint);
|
||||
|
||||
// Only render characters that fit within the scaled bounds
|
||||
for (int j = 0; j < h; j++) {
|
||||
for (int i = 0; i < w; i++) {
|
||||
int bufferX = x + i + c_x1 + offsetX;
|
||||
int bufferY = currentY + j + c_y1 + offsetY;
|
||||
|
||||
// Only draw pixels that are within our scaled buffer bounds
|
||||
if constexpr(Scaling) {
|
||||
if (bufferX >= 0 && bufferX < ScalingBase<true, Owning>::bufferWidth && bufferY >= 0 && bufferY < ScalingBase<true, Owning>::bufferHeight) {
|
||||
ScalingBase<true, Owning>::scalingBuffer[bufferY * ScalingBase<true, Owning>::bufferWidth + bufferX] = {color.r, color.g, color.b, bitmap[j * w + i]};
|
||||
}
|
||||
} else {
|
||||
if (bufferX >= 0 && bufferX < (int)scaled.width && bufferY >= 0 && bufferY < (int)scaled.height) {
|
||||
buffer[bufferY * scaled.width + bufferX] = {color.r, color.g, color.b, bitmap[j * w + i]};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
x += (int)(ax * scale);
|
||||
|
||||
if (i + 1 < line.size()) {
|
||||
x += (int)stbtt_GetCodepointKernAdvance(&font.font, codepoint, line[i+1]);
|
||||
}
|
||||
}
|
||||
currentY += lineHeight;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
/*
|
||||
Crafter®.Graphics
|
||||
Copyright (C) 2025 Catcrafts®
|
||||
catcrafts.net
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License version 3.0 as published by the Free Software Foundation;
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
|
||||
export module Crafter.Graphics:TextElement;
|
||||
import std;
|
||||
import :RenderingElement;
|
||||
import :Types;
|
||||
import :Font;
|
||||
|
||||
export namespace Crafter {
|
||||
enum class TextAlignment {
|
||||
Left,
|
||||
Center,
|
||||
Right
|
||||
};
|
||||
|
||||
enum class VerticalTextAlignment {
|
||||
Top,
|
||||
Middle,
|
||||
Bottom
|
||||
};
|
||||
|
||||
enum class TextOverflowMode {
|
||||
Clip, // Clip text that overflows
|
||||
Wrap // Wrap text to multiple lines
|
||||
};
|
||||
|
||||
class TextElement : public RenderingElement<false, false, false> {
|
||||
private:
|
||||
void RenderWrappedLine(const std::string_view line, float scale, int baseline, std::uint_fast32_t startY, Pixel_BU8_GU8_RU8_AU8 color, Font& font, TextAlignment alignment);
|
||||
public:
|
||||
TextElement(Anchor anchor);
|
||||
void RenderText(Window& window, const std::string_view text, float size, Pixel_BU8_GU8_RU8_AU8 pixel, Font& font, TextAlignment alignment = TextAlignment::Left, VerticalTextAlignment verticalAlignment = VerticalTextAlignment::Top, TextOverflowMode overflowMode = TextOverflowMode::Clip);
|
||||
};
|
||||
}
|
||||
|
|
@ -24,16 +24,16 @@ import :Types;
|
|||
export namespace Crafter {
|
||||
class Window;
|
||||
struct Anchor {
|
||||
std::int_fast32_t x;
|
||||
std::int_fast32_t y;
|
||||
std::uint_fast32_t width;
|
||||
std::uint_fast32_t height;
|
||||
std::int_fast32_t offsetX;
|
||||
std::int_fast32_t offsetY;
|
||||
std::int_fast32_t z;
|
||||
std::int32_t x;
|
||||
std::int32_t y;
|
||||
std::uint32_t width;
|
||||
std::uint32_t height;
|
||||
std::int32_t offsetX;
|
||||
std::int32_t offsetY;
|
||||
std::int32_t z;
|
||||
bool maintainAspectRatio;
|
||||
Anchor() = default;
|
||||
Anchor(std::int_fast32_t x, std::int_fast32_t y, std::uint_fast32_t width, std::uint_fast32_t height, std::int_fast32_t offsetX, std::int_fast32_t offsetY, std::int_fast32_t z, bool maintainAspectRatio = false);
|
||||
Anchor(std::int32_t x, std::int32_t y, std::uint32_t width, std::uint32_t height, std::int32_t offsetX, std::int32_t offsetY, std::int32_t z, bool maintainAspectRatio = false);
|
||||
};
|
||||
class Transform {
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -47,10 +47,11 @@ import Crafter.Event;
|
|||
|
||||
export namespace Crafter {
|
||||
class Transform;
|
||||
class MouseElement;
|
||||
class Window {
|
||||
public:
|
||||
std::int_fast32_t width;
|
||||
std::int_fast32_t height;
|
||||
std::int32_t width;
|
||||
std::int32_t height;
|
||||
std::chrono::time_point<std::chrono::high_resolution_clock> lastFrameBegin;
|
||||
std::vector<Transform*> elements;
|
||||
Event<void> onClose;
|
||||
|
|
@ -61,7 +62,7 @@ export namespace Crafter {
|
|||
float scale;
|
||||
|
||||
Window() = default;
|
||||
Window(std::int_fast32_t width, std::int_fast32_t height);
|
||||
Window(std::int32_t width, std::int32_t height);
|
||||
Window(Window&) = delete;
|
||||
Window(Window&&) = delete;
|
||||
virtual ~Window() = default;
|
||||
|
|
@ -72,13 +73,13 @@ export namespace Crafter {
|
|||
virtual void StopUpdate() = 0;
|
||||
void ScaleElement(Transform& element, Transform& parent);
|
||||
void ScaleElement(Transform& element);
|
||||
void ScaleMouse(Transform& element, Transform& parent);
|
||||
void ScaleMouse(Transform& element);
|
||||
void ScaleMouse(MouseElement& element, Transform& parent);
|
||||
void ScaleMouse(MouseElement& element);
|
||||
#ifdef CRAFTER_TIMING
|
||||
std::chrono::nanoseconds totalUpdate;
|
||||
std::vector<std::pair<const EventListener<FrameTime>*, std::chrono::nanoseconds>> updateTimings;
|
||||
std::chrono::nanoseconds totalRender;
|
||||
std::vector<std::tuple<const Transform*, std::uint_fast32_t, std::uint_fast32_t, std::chrono::nanoseconds>> renderTimings;
|
||||
std::vector<std::tuple<const Transform*, std::uint32_t, std::uint32_t, std::chrono::nanoseconds>> renderTimings;
|
||||
std::chrono::nanoseconds vblank;
|
||||
std::chrono::nanoseconds totalFrame;
|
||||
std::chrono::time_point<std::chrono::high_resolution_clock> frameEnd;
|
||||
|
|
@ -110,10 +111,10 @@ export namespace Crafter {
|
|||
Event<MouseMoveEvent> onMouseMove;
|
||||
Event<MouseMoveEvent> onMouseEnter;
|
||||
Event<MouseMoveEvent> onMouseLeave;
|
||||
Event<std::uint_fast32_t> onMouseScroll;
|
||||
Event<std::uint32_t> onMouseScroll;
|
||||
MousePoint currentMousePos;
|
||||
MousePoint lastMousePos;
|
||||
MousePoint mouseDelta;
|
||||
MouseDelta mouseDelta;
|
||||
bool mouseLeftHeld = false;
|
||||
bool mouseRightHeld = false;
|
||||
std::vector<MouseElement*> mouseElements;
|
||||
|
|
@ -129,11 +130,11 @@ export namespace Crafter {
|
|||
class WindowFramebuffer : public Window {
|
||||
public:
|
||||
WindowFramebuffer() = default;
|
||||
WindowFramebuffer(std::uint_fast32_t width, std::uint_fast32_t height);
|
||||
virtual void Resize(std::uint_fast32_t width, std::uint_fast32_t height) = 0;
|
||||
WindowFramebuffer(std::uint32_t width, std::uint32_t height);
|
||||
virtual void Resize(std::uint32_t width, std::uint32_t height) = 0;
|
||||
virtual void Write(Pixel_BU8_GU8_RU8_AU8* pixels) = 0;
|
||||
virtual void Write(std::uint_fast32_t x, std::uint_fast32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) = 0;
|
||||
virtual Pixel_BU8_GU8_RU8_AU8 Read(std::uint_fast32_t x, std::uint_fast32_t y) const = 0;
|
||||
virtual void Write(std::uint32_t x, std::uint32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) = 0;
|
||||
virtual Pixel_BU8_GU8_RU8_AU8 Read(std::uint32_t x, std::uint32_t y) const = 0;
|
||||
virtual const Pixel_BU8_GU8_RU8_AU8* Read() const = 0;
|
||||
virtual Pixel_BU8_GU8_RU8_AU8* Get() = 0;
|
||||
virtual void Store() = 0;
|
||||
|
|
@ -144,8 +145,8 @@ export namespace Crafter {
|
|||
class WindowWayland final : public WindowKeyboard, public WindowMouse, public WindowFramebuffer, public WindowTitle {
|
||||
public:
|
||||
Pixel_BU8_GU8_RU8_AU8* framebuffer = nullptr;
|
||||
WindowWayland(std::uint_fast32_t width, std::uint_fast32_t height);
|
||||
WindowWayland(std::uint_fast32_t width, std::uint_fast32_t height, const std::string_view title);
|
||||
WindowWayland(std::uint32_t width, std::uint32_t height);
|
||||
WindowWayland(std::uint32_t width, std::uint32_t height, const std::string_view title);
|
||||
~WindowWayland();
|
||||
bool configured = false;
|
||||
wl_shm* shm = nullptr;
|
||||
|
|
@ -173,10 +174,10 @@ export namespace Crafter {
|
|||
void StartUpdate() override;
|
||||
void StopUpdate() override;
|
||||
void SetTitle(const std::string_view title) override;
|
||||
void Resize(std::uint_fast32_t width, std::uint_fast32_t height) override;
|
||||
void Resize(std::uint32_t width, std::uint32_t height) override;
|
||||
void Write(Pixel_BU8_GU8_RU8_AU8* pixels) override;
|
||||
void Write(std::uint_fast32_t x, std::uint_fast32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) override;
|
||||
Pixel_BU8_GU8_RU8_AU8 Read(std::uint_fast32_t x, std::uint_fast32_t y) const override;
|
||||
void Write(std::uint32_t x, std::uint32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) override;
|
||||
Pixel_BU8_GU8_RU8_AU8 Read(std::uint32_t x, std::uint32_t y) const override;
|
||||
const Pixel_BU8_GU8_RU8_AU8* Read() const override;
|
||||
Pixel_BU8_GU8_RU8_AU8* Get() override;
|
||||
void Store() override;
|
||||
|
|
|
|||
|
|
@ -24,7 +24,6 @@ export import :Window;
|
|||
export import :Transform;
|
||||
export import :RenderingElement;
|
||||
export import :MouseElement;
|
||||
export import :TextElement;
|
||||
export import :GridElement;
|
||||
export import :Types;
|
||||
export import :Font;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue