130 lines
No EOL
4.4 KiB
C++
130 lines
No EOL
4.4 KiB
C++
/*
|
|
Crafter®.Graphics
|
|
Copyright (C) 2026 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:RenderingElement2DBase;
|
|
import Crafter.Asset;
|
|
import Crafter.Math;
|
|
import std;
|
|
import :Transform2D;
|
|
|
|
export namespace Crafter {
|
|
enum class TextAlignment {
|
|
Left,
|
|
Center,
|
|
Right
|
|
};
|
|
|
|
enum class TextOverflowMode {
|
|
Clip,
|
|
Wrap
|
|
};
|
|
|
|
enum class TextScaleMode {
|
|
None,
|
|
Font,
|
|
Element,
|
|
Buffer
|
|
};
|
|
|
|
template<std::uint8_t Alignment = 0>
|
|
struct RenderElement2DScalingOwning {
|
|
std::vector<Vector<std::uint8_t, 4, Alignment>> scalingBuffer;
|
|
std::uint32_t bufferWidth;
|
|
std::uint32_t bufferHeight;
|
|
RenderElement2DScalingOwning() = default;
|
|
RenderElement2DScalingOwning(std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(bufferWidth*bufferHeight), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
|
|
|
}
|
|
};
|
|
|
|
template<std::uint8_t Alignment = 0>
|
|
struct RenderElement2DScalingNonOwning {
|
|
Vector<std::uint8_t, 4, Alignment>* scalingBuffer;
|
|
std::uint32_t bufferWidth;
|
|
std::uint32_t bufferHeight;
|
|
RenderElement2DScalingNonOwning() = default;
|
|
RenderElement2DScalingNonOwning(Vector<std::uint8_t, 4, Alignment>* scalingBuffer, std::uint32_t bufferWidth, std::uint32_t bufferHeight) : scalingBuffer(scalingBuffer), bufferWidth(bufferWidth), bufferHeight(bufferHeight) {
|
|
|
|
}
|
|
};
|
|
|
|
struct RenderElement2DRotating {
|
|
float rotation;
|
|
RenderElement2DRotating() = default;
|
|
RenderElement2DRotating(float rotation) : rotation(rotation) {
|
|
|
|
}
|
|
};
|
|
|
|
|
|
struct EmptyScalingBase {};
|
|
struct EmptyRotatingBase {};
|
|
|
|
template<bool Scaling, bool Owning, std::uint8_t Alignment = 0>
|
|
using ScalingBase =
|
|
std::conditional_t<
|
|
Scaling,
|
|
std::conditional_t<Owning,
|
|
RenderElement2DScalingOwning<Alignment>,
|
|
RenderElement2DScalingNonOwning<Alignment>>,
|
|
EmptyScalingBase
|
|
>;
|
|
|
|
template<bool Rotating>
|
|
using RotatingBase =
|
|
std::conditional_t<
|
|
Rotating,
|
|
RenderElement2DRotating,
|
|
EmptyRotatingBase
|
|
>;
|
|
|
|
template<typename T, std::uint8_t Frames = 1>
|
|
struct RenderingElement2DBase : Transform2D {
|
|
ScaleData2D oldScale[Frames];
|
|
bool redraw[Frames];
|
|
std::vector<Vector<T, 4, 4>> buffer;
|
|
OpaqueType opaque;
|
|
RenderingElement2DBase(Anchor2D anchor) : Transform2D(anchor) {
|
|
for(std::uint8_t i = 0; i < Frames; i++) {
|
|
this->scaled.size.x = 0;
|
|
}
|
|
}
|
|
RenderingElement2DBase(Anchor2D anchor, OpaqueType opaque) : Transform2D(anchor), opaque(opaque) {
|
|
for(std::uint8_t i = 0; i < Frames; i++) {
|
|
this->scaled.size.x = 0;
|
|
}
|
|
}
|
|
void Redraw() {
|
|
for(std::uint8_t i = 0; i < Frames; i++) {
|
|
redraw[i] = true;
|
|
}
|
|
}
|
|
void CopyNearestNeighbor(Vector<std::uint8_t, 4>* dst, std::uint16_t dstSizeX, std::uint16_t dstScaledSizeX, std::uint16_t dstScaledSizeY, std::uint16_t offsetX, std::uint16_t offsetY) {
|
|
for (std::uint16_t y = 0; y < dstScaledSizeY; y++) {
|
|
std::uint16_t srcY = y * scaled.size.y / dstScaledSizeY;
|
|
std::uint16_t dstY = y + offsetY;
|
|
for (std::uint16_t x = 0; x < dstScaledSizeX; x++) {
|
|
std::uint16_t srcX = x * scaled.size.x / dstScaledSizeX;
|
|
std::uint16_t dstX = x + offsetX;
|
|
dst[dstY * dstSizeX + dstX] = buffer[srcY * this->scaled.size.x + srcX];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
} |