326 lines
No EOL
16 KiB
C++
326 lines
No EOL
16 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
|
|
*/
|
|
|
|
module;
|
|
#include "../lib/stb_truetype.h"
|
|
#ifdef CRAFTER_GRAPHICS_RENDERER_VULKAN
|
|
#include <vulkan/vulkan.h>
|
|
#endif
|
|
export module Crafter.Graphics:Rendertarget;
|
|
import Crafter.Math;
|
|
import Crafter.Asset;
|
|
import std;
|
|
import :Types;
|
|
import :Transform2D;
|
|
import :RenderingElement2DBase;
|
|
#ifdef CRAFTER_GRAPHICS_RENDERER_VULKAN
|
|
import :Device;
|
|
import :VulkanBuffer;
|
|
#endif
|
|
|
|
export namespace Crafter {
|
|
struct RendertargetBase {
|
|
#ifdef CRAFTER_TIMING
|
|
std::vector<std::tuple<const Transform*, std::uint32_t, std::uint32_t, std::chrono::nanoseconds>> renderTimings;
|
|
#endif
|
|
Transform2D transform;
|
|
std::uint16_t sizeX;
|
|
std::uint16_t sizeY;
|
|
RendertargetBase() = default;
|
|
RendertargetBase(std::uint16_t sizeX, std::uint16_t sizeY) : sizeX(sizeX), sizeY(sizeY), transform({0, 0, 1, 1, 0, 0, 0}){
|
|
transform.scaled.size.x = sizeX;
|
|
transform.scaled.size.y = sizeY;
|
|
transform.scaled.position.x = 0;
|
|
transform.scaled.position.y = 0;
|
|
}
|
|
};
|
|
|
|
#ifdef CRAFTER_GRAPHICS_RENDERER_VULKAN
|
|
struct RenderingElement2DVulkanBase;
|
|
|
|
struct __attribute__((packed)) RenderingElement2DVulkanTransformInfo {
|
|
ScaleData2D scaled; // 0 - 8 bytes
|
|
std::uint16_t bufferX; // 8 - 2 bytes
|
|
std::uint16_t bufferY; // 10 - 2 bytes
|
|
//12 bytes total;
|
|
};
|
|
|
|
|
|
struct DescriptorHeapVulkan;
|
|
struct RendertargetVulkan : RendertargetBase {
|
|
std::uint8_t frame;
|
|
std::vector<RenderingElement2DVulkanBase*> elements;
|
|
VulkanBuffer<RenderingElement2DVulkanTransformInfo, true> transformBuffer[3];
|
|
|
|
RendertargetVulkan() = default;
|
|
RendertargetVulkan(std::uint16_t sizeX, std::uint16_t sizeY);
|
|
void UpdateElements();
|
|
void CreateBuffer(std::uint8_t frame);
|
|
void ReorderBuffer(std::uint8_t frame);
|
|
void WriteDescriptors(std::span<VkResourceDescriptorInfoEXT> infos, std::span<VkHostAddressRangeEXT> ranges, std::uint16_t start, std::uint32_t bufferOffset, DescriptorHeapVulkan& descriptorHeap);
|
|
void SetOrderResursive(Transform2D* elementTransform);
|
|
};
|
|
#endif
|
|
|
|
template<typename T, std::uint8_t Channels, std::uint8_t Alignment, std::uint8_t Frames>
|
|
struct Rendertarget : RendertargetBase {
|
|
Vector<T, Channels, Alignment>* buffer[Frames];
|
|
Rendertarget() = default;
|
|
Rendertarget(std::uint16_t sizeX, std::uint16_t sizeY) : RendertargetBase(sizeX, sizeY) {
|
|
|
|
}
|
|
void RenderElement(Transform2D* elementTransform, std::uint8_t frame, std::vector<ClipRect>&& dirtyRects) {
|
|
RenderingElement2DBase<T, Frames>* element = dynamic_cast<RenderingElement2DBase<T, Frames>*>(elementTransform);
|
|
if(element) {
|
|
#ifdef CRAFTER_TIMING
|
|
auto start = std::chrono::high_resolution_clock::now();
|
|
#endif
|
|
|
|
if(element->scaled.size.x < 1 || element->scaled.size.y < 1) {
|
|
return;
|
|
}
|
|
|
|
for(ClipRect dirty : dirtyRects) {
|
|
dirty.left = std::uint16_t(std::max(element->scaled.position.x, std::int16_t(dirty.left)));
|
|
dirty.top = std::uint16_t(std::max(element->scaled.position.y,std::int16_t(dirty.top)));
|
|
dirty.right = std::min(std::uint16_t(element->scaled.position.x+element->scaled.size.x), dirty.right);
|
|
dirty.bottom = std::min(std::uint16_t(element->scaled.position.y+element->scaled.size.y), dirty.bottom);
|
|
|
|
if(dirty.right <= dirty.left || dirty.bottom <= dirty.top) {
|
|
continue;
|
|
}
|
|
|
|
const Vector<T, 4, 4>* src_buffer = element->buffer.data();
|
|
std::uint16_t src_width = element->scaled.size.x;
|
|
std::uint16_t src_height = element->scaled.size.y;
|
|
|
|
switch (element->opaque) {
|
|
case OpaqueType::FullyOpaque: {
|
|
for (std::uint16_t y = dirty.top; y < dirty.bottom; y++) {
|
|
std::uint16_t src_y = y - element->scaled.position.y;
|
|
std::uint16_t src_x = dirty.left - element->scaled.position.x;
|
|
std::memcpy(&this->buffer[frame][y * this->sizeX + dirty.left], &src_buffer[src_y * src_width + src_x], (dirty.right - dirty.left) * sizeof(Vector<T, Channels, Alignment>));
|
|
}
|
|
break;
|
|
}
|
|
case OpaqueType::SemiOpaque:
|
|
case OpaqueType::Transparent:
|
|
if constexpr(std::same_as<T, _Float16>) {
|
|
for (std::uint16_t y = dirty.top; y < dirty.bottom; y++) {
|
|
std::uint16_t src_y = y - element->scaled.position.y;
|
|
std::uint16_t pixel_width = dirty.right - dirty.left;
|
|
|
|
constexpr std::uint32_t simd_width = VectorF16<1, 1>::MaxElement / 4;
|
|
std::uint32_t rows = pixel_width / simd_width;
|
|
|
|
for (std::uint32_t x = 0; x < rows; x++) {
|
|
std::uint16_t px = dirty.left + x * simd_width;
|
|
std::uint16_t src_x = px - element->scaled.position.x;
|
|
|
|
VectorF16<4, simd_width> src(&src_buffer[src_y * src_width + src_x].v[0]);
|
|
VectorF16<4, simd_width> dst(&buffer[frame][y * this->sizeX + px].v[0]);
|
|
VectorF16<4, simd_width> oneMinusSrcA = VectorF16<4, simd_width>(1) - src.Shuffle<{{3, 3, 3, 3}}>();
|
|
VectorF16<4, simd_width> result = VectorF16<4, simd_width>::MulitplyAdd(dst, oneMinusSrcA, src);
|
|
result.Store(&buffer[frame][y * this->sizeX + px].v[0]);
|
|
}
|
|
|
|
std::uint32_t remainder = pixel_width - (rows * simd_width);
|
|
std::uint16_t remainder_start = dirty.left + rows * simd_width;
|
|
|
|
for (std::uint8_t x = 0; x < remainder; x++) {
|
|
std::uint16_t px = remainder_start + x;
|
|
std::uint16_t src_x = px - element->scaled.position.x;
|
|
|
|
Vector<T, Channels, Alignment> src = src_buffer[src_y * src_width + src_x];
|
|
Vector<T, Channels, Alignment> dst = buffer[frame][y * this->sizeX + px];
|
|
_Float16 oneMinusSrcA = (_Float16)1.0f - src.a;
|
|
|
|
buffer[frame][y * this->sizeX + px] = Vector<T, Channels, Alignment>(
|
|
src.r + dst.r * oneMinusSrcA,
|
|
src.g + dst.g * oneMinusSrcA,
|
|
src.b + dst.b * oneMinusSrcA,
|
|
src.a + dst.a * oneMinusSrcA
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
for (std::uint16_t y = dirty.top; y < dirty.bottom; y++) {
|
|
std::uint16_t src_y = y - element->scaled.position.y;
|
|
std::uint16_t src_x = dirty.left - element->scaled.position.x;
|
|
std::memcpy(&this->buffer[frame][y * this->sizeX + dirty.left], &src_buffer[src_y * src_width + src_x], (dirty.right - dirty.left) * sizeof(Vector<T, Channels, Alignment>));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#ifdef CRAFTER_TIMING
|
|
auto end = std::chrono::high_resolution_clock::now();
|
|
renderTimings.push_back({element, element->scaled.size.x, element->scaled.size.y, end-start});
|
|
#endif
|
|
}
|
|
std::sort(elementTransform->children.begin(), elementTransform->children.end(), [](Transform2D* a, Transform2D* b){ return a->anchor.z < b->anchor.z; });
|
|
for(Transform2D* child : elementTransform->children) {
|
|
this->RenderElement(child, frame, std::move(dirtyRects));
|
|
}
|
|
}
|
|
|
|
void AddOldRects(Transform2D* elementTransform, std::uint8_t frame, std::vector<ClipRect>& clipRects) {
|
|
RenderingElement2DBase<T, Frames>* element = dynamic_cast<RenderingElement2DBase<T, Frames>*>(elementTransform);
|
|
if(element) {
|
|
if(element->scaled.position.x != element->oldScale[frame].position.x || element->scaled.position.y != element->oldScale[frame].position.y || element->scaled.size.x != element->oldScale[frame].size.x || element->scaled.size.y != element->oldScale[frame].size.y || element->redraw[frame]) {
|
|
clipRects.emplace_back(std::max(element->scaled.position.x, std::int16_t(0)), std::min(std::int16_t(element->scaled.position.x + element->scaled.size.x), std::int16_t(this->sizeX)), std::max(element->scaled.position.y, std::int16_t(0)), std::min(std::int16_t(element->scaled.position.y + element->scaled.size.y), std::int16_t(this->sizeY)));
|
|
clipRects.emplace_back(std::max(element->oldScale[frame].position.x, std::int16_t(0)), std::min(std::int16_t(element->oldScale[frame].position.x + element->oldScale[frame].size.x), std::int16_t(this->sizeX)), std::max(element->oldScale[frame].position.y, std::int16_t(0)), std::min(std::int16_t(element->oldScale[frame].position.y + element->oldScale[frame].size.y), std::int16_t(this->sizeY)));
|
|
element->oldScale[frame] = element->scaled;
|
|
element->redraw[frame] = false;
|
|
} else if(element->redraw[frame]) {
|
|
clipRects.emplace_back(std::max(element->scaled.position.x, std::int16_t(0)), std::min(std::int16_t(element->scaled.position.x + element->scaled.size.x), std::int16_t(this->sizeX)), std::max(element->scaled.position.y, std::int16_t(0)), std::min(std::int16_t(element->scaled.position.y + element->scaled.size.y), std::int16_t(this->sizeY)));
|
|
element->oldScale[frame] = element->scaled;
|
|
element->redraw[frame] = false;
|
|
}
|
|
}
|
|
for(Transform2D* child : elementTransform->children) {
|
|
AddOldRects(child, frame, clipRects);
|
|
}
|
|
}
|
|
|
|
bool Render(std::uint8_t frame) {
|
|
std::sort(this->transform.children.begin(), this->transform.children.end(), [](Transform2D* a, Transform2D* b){ return a->anchor.z < b->anchor.z; });
|
|
std::vector<ClipRect> clipRects;
|
|
for(Transform2D* child : this->transform.children) {
|
|
AddOldRects(child, frame, clipRects);
|
|
}
|
|
|
|
//std::vector<ClipRect> newClip;
|
|
// for (std::uint32_t i = 0; i < dirtyRects.size(); i++) {
|
|
// ClipRect rect = dirtyRects[i];
|
|
// for (std::uint32_t i2 = i + 1; i2 < dirtyRects.size(); i2++) {
|
|
// ClipRect existing = dirtyRects[i2];
|
|
// if(rect.bottom >= existing.top && rect.top <= existing.top) {
|
|
// newClip.push_back({
|
|
// .left = rect.left,
|
|
// .right = rect.right,
|
|
// .top = rect.top,
|
|
// .bottom = existing.top,
|
|
// });
|
|
// //-| shape
|
|
// if(rect.right > existing.right) {
|
|
// newClip.push_back({
|
|
// .left = existing.right,
|
|
// .right = rect.right,
|
|
// .top = existing.top,
|
|
// .bottom = existing.bottom,
|
|
// });
|
|
// }
|
|
// //|- shape
|
|
// if(rect.left < existing.left) {
|
|
// newClip.push_back({
|
|
// .left = rect.left,
|
|
// .right = existing.left,
|
|
// .top = existing.top,
|
|
// .bottom = existing.bottom,
|
|
// });
|
|
// }
|
|
// //-| or |- shape where rect extends further down
|
|
// if(rect.bottom > existing.bottom) {
|
|
// newClip.push_back({
|
|
// .left = rect.left,
|
|
// .right = rect.right,
|
|
// .top = existing.bottom,
|
|
// .bottom = rect.bottom,
|
|
// });
|
|
// }
|
|
// goto inner;
|
|
// }
|
|
// if (rect.left <= existing.right && rect.right >= existing.left) {
|
|
// newClip.push_back({
|
|
// .left = rect.left,
|
|
// .right = existing.left,
|
|
// .top = rect.top,
|
|
// .bottom = rect.bottom,
|
|
// });
|
|
// if (rect.right > existing.right) {
|
|
// newClip.push_back({
|
|
// .left = existing.right,
|
|
// .right = rect.right,
|
|
// .top = rect.top,
|
|
// .bottom = rect.bottom,
|
|
// });
|
|
// }
|
|
// goto inner;
|
|
// }
|
|
// }
|
|
// newClip.push_back(rect);
|
|
// inner:;
|
|
// }
|
|
|
|
//dirtyRects = std::move(newClip);
|
|
|
|
// std::memset(buffer, 0, width*height*4);
|
|
|
|
// std::cout << dirtyRects.size() << std::endl;
|
|
// // Color palette
|
|
// static const std::vector<Vector<std::uint8_t, 4>> colors = {
|
|
// {255, 0, 0, 255}, // red
|
|
// { 0, 255, 0, 255}, // green
|
|
// { 0, 0, 255, 255}, // blue
|
|
// {255, 255, 0, 255}, // yellow
|
|
// {255, 0, 255, 255}, // magenta
|
|
// { 0, 255, 255, 255}, // cyan
|
|
// };
|
|
|
|
// std::size_t rectIndex = 0;
|
|
|
|
// for (const ClipRect& rect : dirtyRects) {
|
|
// const Vector<std::uint8_t, 4>& color = colors[rectIndex % colors.size()];
|
|
|
|
// std::cout << std::format(
|
|
// "ClipRect {}: [{}, {}, {}, {}] Color = RGBA({}, {}, {}, {})",
|
|
// rectIndex,
|
|
// rect.left, rect.top, rect.right, rect.bottom,
|
|
// color.r, color.g, color.b, color.a
|
|
// ) << std::endl;
|
|
|
|
// for (std::int32_t y = rect.top; y < rect.bottom; ++y) {
|
|
// for (std::int32_t x = rect.left; x < rect.right; ++x) {
|
|
// buffer[y * width + x] = color;
|
|
// }
|
|
// }
|
|
|
|
// ++rectIndex;
|
|
// }
|
|
|
|
if (!clipRects.empty()) {
|
|
for (ClipRect rect : clipRects) {
|
|
for (std::int32_t y = rect.top; y < rect.bottom; y++) {
|
|
for (std::int32_t x = rect.left; x < rect.right; x++) {
|
|
this->buffer[frame][y * this->sizeX + x] = {0, 0, 0, 0};
|
|
}
|
|
}
|
|
}
|
|
|
|
for(Transform2D* child : this->transform.children) {
|
|
RenderElement(child, frame, std::move(clipRects));
|
|
}
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
} |