Catcrafts/Crafter.Graphics
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: Catcrafts:5ff43e240c749e27b4a179f559a5d8136f901f52
Branches Tags
Catcrafts:master
..
compare: Catcrafts:475ecd149bb84e5a1d7e23276eb502ac39b8cfd7
Branches Tags
Catcrafts:master

No commits in common. "5ff43e240c749e27b4a179f559a5d8136f901f52" and "475ecd149bb84e5a1d7e23276eb502ac39b8cfd7" have entirely different histories.
5ff43e240c ... 475ecd149b

19 changed files with 888 additions and 1108 deletions
Download patch file Download diff file Expand all files Collapse all files

28
examples/HelloDrawing/main.cpp
View file

@ -3,20 +3,26 @@ import std;
using namespace Crafter; using namespace Crafter;
int main() { int main() {
constexpr std::uint_fast32_t width = 1280; Window window("HelloWindow", 1280, 720);
constexpr std::uint_fast32_t height = 720;
WindowWayland window(width, height, "Hello Drawing!"); for(std::uint_fast32_t x = 0; x < 1280; x++) {
for(std::uint_fast32_t y = 0; y < 720; y++) {
for(std::uint_fast32_t x = 0; x < width; x++) { window.framebuffer[x*720+y].r = 255;
for(std::uint_fast32_t y = 0; y < height; y++) { window.framebuffer[x*720+y].g = 0;
window.framebuffer[x*height+y].r = 255; window.framebuffer[x*720+y].b = 0;
window.framebuffer[x*height+y].g = 0; window.framebuffer[x*720+y].a = 255;
window.framebuffer[x*height+y].b = 0;
window.framebuffer[x*height+y].a = 255;
} }
} }
window.Render(); //Semi transparant version:
// for(std::uint_fast32_t x = 0; x < 1280; x++) {
// for(std::uint_fast32_t = 0; y < 720; y++) {
// window.framebuffer[x*720+y].r = 128;//alpha channel must be premultiplied
// window.framebuffer[x*720+y].g = 0;
// window.framebuffer[x*720+y].b = 0;
// window.framebuffer[x*720+y].a = 128;
// }
// }
window.StartSync(); window.StartSync();
} }

4
examples/HelloInput/README.md
View file

@ -24,8 +24,8 @@ Make sure that the window has focus.
## Highlighted Code Snippet ## Highlighted Code Snippet
```cpp ```cpp
EventListener<MousePoint> clickListener(&window.onMouseLeftClick, [&window](MousePoint point){ EventListener<MousePoint> clickListener(&window.onMouseLeftClick, [](MousePoint point){
std::cout << std::format("Clicked on X:{} Y:{}!", MappedToPixel(point.x, window.width), MappedToPixel(point.y, window.height)); std::cout << std::format("Clicked on X:{} Y:{}!", point.x, point.y);
}); });
EventListener<void> keyAListener(&window.onKeyDown['a'], [](){ EventListener<void> keyAListener(&window.onKeyDown['a'], [](){

10
examples/HelloInput/main.cpp
View file

@ -4,13 +4,15 @@ import std;
using namespace Crafter; using namespace Crafter;
int main() { int main() {
WindowWayland window(1280, 720, "Hello Input!"); // Create a Wayland window named "HelloWindow" with resolution 1280x720
// (window creation explained in HelloWindow example)
Window window("HelloWindow", 1280, 720);
// Listen for left mouse click events on the window // Listen for left mouse click events on the window
// The callback receives the MousePoint struct containing the click coordinates in float pixels from the top left corner // The callback receives the MousePoint struct containing the click coordinates in float pixels from the top left corner
EventListener<MousePoint> clickListener(&window.onMouseLeftClick, [&window](MousePoint point){ EventListener<MousePoint> clickListener(&window.onMouseLeftClick, [](MousePoint point){
// Print the coordinates where the user clicked // Print the coordinates where the user clicked
std::cout << std::format("Clicked on X:{} Y:{}!", MappedToPixel(point.x, window.width), MappedToPixel(point.y, window.height)) << std::endl; std::cout << std::format("Clicked on X:{} Y:{}!", point.x, point.y) << std::endl;
}); });
// Listen specifically for the 'a' key being pressed down // Listen specifically for the 'a' key being pressed down
@ -27,6 +29,6 @@ int main() {
std::cout << std::format("Pressed the {} key!", key) << std::endl; std::cout << std::format("Pressed the {} key!", key) << std::endl;
}); });
//Start the window event loop, unless the window is started events will not trigger. // Start the window event loop, unless the window is started events will not trigger.
window.StartSync(); window.StartSync();
} }

35
examples/HelloUI/main.cpp
View file

@ -4,31 +4,40 @@ import std;
using namespace Crafter; using namespace Crafter;
int main() { int main() {
WindowWayland window(1280, 720, "Hello Input!"); Window window("HelloWindow", 1280, 720);
UiElementBufferMouseBuffer* element = new UiElementBufferMouseBuffer( UiElement& element = window.elements.emplace_back(
0.5, //anchorX: relative position where this elements x anchor (top-left) is placed to its parent x anchor
0.5, //anchorY: relative position where this elements y anchor (top-left) is placed to its parent y anchor
2, //bufferWidth: the width of this elements pixel buffer 2, //bufferWidth: the width of this elements pixel buffer
1, //bufferHeight: the height of this elements pixel buffer 1, //bufferHeight: the height of this elements pixel buffer
FractionalToMapped(0.5), //anchorX: relative position where this elements x anchor (top-left) is placed to its parent x anchor 0.5f, //relativeSizeX: the relative x size this element should be scaled to compared to its parent
FractionalToMapped(0.5), //anchorY: relative position where this elements y anchor (top-left) is placed to its parent y anchor 0.5f, //relativeSizeY: the relative y size this element should be scaled to compared to its parent
FractionalToMapped(0.5), //relativeSizeX: the relative x size this element should be scaled to compared to its parent 0.5, //anchorOffsetX: the amount this element's anchor should be offset from the top left corner (0.5 to in the middle)
FractionalToMapped(0.5), //relativeSizeY: the relative y size this element should be scaled to compared to its parent 0.5, //anchorOffsetY: the amount this element's anchor should be offset from the top left corner (0.5 to place it in the middle)
FractionalToMapped(0.5), //anchorOffsetX: the amount this element's anchor should be offset from the top left corner (0.5 to in the middle)
FractionalToMapped(0.5), //anchorOffsetY: the amount this element's anchor should be offset from the top left corner (0.5 to place it in the middle)
0, //z: this elements Z position 0, //z: this elements Z position
false //ignoreScaling: wether this element ignores the scaling of the window, if true its size will be scaled according to the window scale false //ignoreScaling: wether this element ignores the scaling of the window, if true its size will be scaled according to the window scale
); );
window.elements.push_back(element); // UiElement& element = window.elements.emplace_back(
// 0.5,
element->UpdatePosition(window); // 0.5,
// 2,
// 1,
// uint32_t(100), //absoluteSizeX: the absolute x size in pixels this element should be scaled to
// uint32_t(100), //absoluteSizeY: the absolute x size in pixels this element should be scaled to
// 0.5,
// 0.5,
// 0,
// false
// );
EventListener<MousePoint> clickListener(&element.onMouseLeftClick, [](MousePoint point){ EventListener<MousePoint> clickListener(&element.onMouseLeftClick, [](MousePoint point){
// Print the coordinates where the user clicked relative to the element's top left corner. // Print the coordinates where the user clicked relative to the element's top left corner.
std::cout << std::format("Clicked on X:{} Y:{}!", point.x, point.y) << std::endl; std::cout << std::format("Clicked on X:{} Y:{}!", point.x, point.y) << std::endl;
}); });
element->buffer = {{255, 0, 0 ,255}, {0, 255, 0 ,255}}; element.buffer = {{255, 0, 0 ,255}, {0, 255, 0 ,255}};
window.Render(); window.scale = 1;
window.StartSync(); window.StartSync();
} }

4
examples/HelloWindow/README.md
View file

@ -2,7 +2,7 @@
## Description ## Description
This example demonstrates the minimal code needed to create a window and show it on the screen. This uses the Framebuffer and Title capability. This example demonstrates the minimal code needed to create a window and show it on the screen.
## Expected Result ## Expected Result
@ -11,7 +11,7 @@ A empty window with the title "HelloWindow" shows onscreen.
## Highlighted Code Snippet ## Highlighted Code Snippet
```cpp ```cpp
WindowWayland window(1280, 720, "Hello Window!"); WindowWaylandWayland window("HelloWindow", 1280, 720);
window.StartSync(); window.StartSync();
``` ```

14
examples/HelloWindow/main.cpp
View file

@ -3,6 +3,18 @@ import std;
using namespace Crafter; using namespace Crafter;
int main() { int main() {
WindowWayland window(1280, 720, "Hello Window!"); /*
This creates a window titled "HelloWindow" with a size of 1280x720 pixels.
The WindowWaylandWayland class is a specialized window implementation
that uses the Wayland display server protocol and renderer (hence the name "WaylandWayland").
*/
Window window("HelloWindow", 1280, 720);
/*
This starts the window’s main event loop, allowing it to respond to user input and system events.
The window will remain open and responsive until it is closed.
You can hook into various events through the event system.
This call blocks the current thread; to run the event loop asynchronously, use StartAsync instead.
*/
window.StartSync(); window.StartSync();
} }

76
implementations/Crafter.Graphics-Shm.cpp
View file

@ -1,76 +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
*/
module;
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <time.h>
module Crafter.Graphics:Shm_impl;
import :Shm;
import std;
using namespace Crafter;
void Crafter::randname(char *buf) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
long r = ts.tv_nsec;
for (int i = 0; i < 6; ++i) {
buf[i] = 'A'+(r&15)+(r&16)*2;
r >>= 5;
}
}
int Crafter::anonymous_shm_open(void) {
char name[] = "/hello-wayland-XXXXXX";
int retries = 100;
do {
randname(name + strlen(name) - 6);
--retries;
// shm_open guarantees that O_CLOEXEC is set
int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
if (fd >= 0) {
shm_unlink(name);
return fd;
}
} while (retries > 0 && errno == EEXIST);
return -1;
}
int Crafter::create_shm_file(off_t size) {
int fd = anonymous_shm_open();
if (fd < 0) {
return fd;
}
if (ftruncate(fd, size) < 0) {
close(fd);
return -1;
}
return fd;
}

105
implementations/Crafter.Graphics-UiElement.cpp
View file

@ -18,38 +18,99 @@ License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 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"
module Crafter.Graphics:UiElement_impl; module Crafter.Graphics:UiElement_impl;
import :UiElement; import :UiElement;
import :Window; import :Font;
import :Types;
import std; import std;
using namespace Crafter; using namespace Crafter;
UiElement::UiElement(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX, std::int_fast32_t anchorOffsetY, std::int_fast32_t z, bool ignoreScaling) : anchorX(anchorX), anchorY(anchorY), relativeWidth(relativeWidth), relativeHeight(relativeHeight), anchorOffsetX(anchorOffsetX), anchorOffsetY(anchorOffsetY), z(z), ignoreScaling(ignoreScaling) { UiElement::UiElement(float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX, float anchorOffsetY, float z, bool ignoreScaling) : anchorX(anchorX), anchorY(anchorY), relativeWidth(relativeWidth), relativeHeight(relativeHeight), anchorOffsetX(anchorOffsetX), anchorOffsetY(anchorOffsetY), z(z), useRelativeSize(true), ignoreScaling(ignoreScaling) {
} }
UiElementBuffer::UiElementBuffer(std::uint_fast32_t width, std::uint_fast32_t height) : width(width), height(height) { UiElement::UiElement(float anchorX, float anchorY, std::uint32_t bufferWidth, std::uint32_t bufferHeight, std::uint32_t absoluteWidth, std::uint32_t absoluteHeight, float anchorOffsetX, float anchorOffsetY, float z, bool ignoreScaling) : anchorX(anchorX), anchorY(anchorY), bufferWidth(bufferWidth), bufferHeight(bufferHeight), absoluteWidth(absoluteWidth), absoluteHeight(absoluteHeight), anchorOffsetX(anchorOffsetX), anchorOffsetY(anchorOffsetY), z(z), buffer(bufferWidth*bufferHeight), useRelativeSize(false), ignoreScaling(ignoreScaling) {
} }
// void UiElement::UpdatePosition(Window& window) { UiElement::UiElement(float anchorX, float anchorY, std::uint32_t bufferWidth, std::uint32_t bufferHeight, float relativeWidth, float relativeHeight, float anchorOffsetX, float anchorOffsetY, float z, bool ignoreScaling) : anchorX(anchorX), anchorY(anchorY), bufferWidth(bufferWidth), bufferHeight(bufferHeight), relativeWidth(relativeWidth), relativeHeight(relativeHeight), anchorOffsetX(anchorOffsetX), anchorOffsetY(anchorOffsetY), z(z), buffer(bufferWidth*bufferHeight), useRelativeSize(true), ignoreScaling(ignoreScaling) {
// // scaled.width = relativeWidth;
// // scaled.height = relativeHeight;
// // scaled.x = anchorX - (anchorOffsetX * scaled.width);
// // scaled.y = anchorY - (anchorOffsetY * scaled.height);
// // for(UiElement* child : children) {
// // UpdatePosition(*child);
// // }
// }
// void UiElement::UpdatePosition(UiElement& parent) { }
// // scaled.width = parent.scaled.width / relativeWidth;
// // scaled.height = parent.scaled.height / relativeHeight; UiElement::UiElement(const std::filesystem::path& image, float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX, float anchorOffsetY, float z, bool ignoreScaling) : anchorX(anchorX), anchorY(anchorY), relativeWidth(relativeWidth), relativeHeight(relativeHeight), anchorOffsetX(anchorOffsetX), anchorOffsetY(anchorOffsetY), z(z), useRelativeSize(true), ignoreScaling(ignoreScaling) {
// // scaled.x = (parent.scaled.width / anchorX) - (anchorOffsetX * scaled.width); std::filesystem::path abs = std::filesystem::absolute(image);
// // scaled.y = (parent.scaled.height / anchorY) - (anchorOffsetY * scaled.height); int xSize;
// // for(UiElement* child : children) { int ySize;
// // UpdatePosition(*child); unsigned char* bgData = stbi_load(abs.string().c_str(), &xSize, &ySize, nullptr, 4);
// // }
// } bufferWidth = xSize;
bufferHeight = ySize;
buffer.resize(bufferWidth*bufferHeight);
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;
buffer[x*ySize+y].r = bgData[idx];
buffer[x*ySize+y].g = bgData[idx+1];
buffer[x*ySize+y].b = bgData[idx+2];
buffer[x*ySize+y].a = bgData[idx+3];
}
}
}
TextElement::TextElement(const std::string_view text, float size, Pixel_BU8_GU8_RU8_AU8 color, const Font& font, float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX, float anchorOffsetY, float z, bool ignoreScaling) : UiElement(anchorX, anchorY, relativeWidth, relativeHeight, anchorOffsetX, anchorOffsetY, z, ignoreScaling) {
RenderText(text, size, color, font);
}
void TextElement::RenderText(const std::string_view text, float size, Pixel_BU8_GU8_RU8_AU8 color, const Font& font) {
float scale = stbtt_ScaleForPixelHeight(&font.font, size);
int baseline = (int)(font.ascent * scale);
bufferWidth = 0;
bufferHeight = (int)((font.ascent -font.descent) * scale);
for (const char c : text) {
int advance, lsb;
stbtt_GetCodepointHMetrics(&font.font, c, &advance, &lsb);
bufferWidth += (int)(advance * scale);
}
buffer.resize(bufferWidth * bufferHeight);
int x = 0;
for (std::uint_fast32_t i = 0; i < text.size(); i++) {
int codepoint = text[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);
for (int j = 0; j < h; j++) {
for (int i = 0; i < w; i++) {
int bufIndex = ((baseline + j + c_y1) * bufferWidth + (x + i + c_x1));
unsigned char val = bitmap[j * w + i];
buffer[bufIndex] = {color.r, color.g, color.b, val};
}
}
x += (int)(ax * scale);
if (i + 1 < text.size()) {
x += (int)stbtt_GetCodepointKernAdvance(&font.font, codepoint, text[i+1] * scale);
}
}
}

33
implementations/Crafter.Graphics-UiElementBufferBuffer.cpp
View file

@ -1,33 +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 as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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 Crafter.Graphics:UiElementBufferBuffer_impl;
import :UiElement;
import std;
using namespace Crafter;
UiElementBufferBuffer::UiElementBufferBuffer(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX, std::int_fast32_t anchorOffsetY, std::int_fast32_t z, bool ignoreScaling) : UiElement(anchorX, anchorY, relativeWidth, relativeHeight, anchorOffsetX, anchorOffsetY, z, ignoreScaling) {
}
UiElementBufferBuffer::UiElementBufferBuffer(std::uint_fast32_t width, std::uint_fast32_t height, std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX, std::int_fast32_t anchorOffsetY, std::int_fast32_t z, bool ignoreScaling) : UiElement(anchorX, anchorY, relativeWidth, relativeHeight, anchorOffsetX, anchorOffsetY, z, ignoreScaling), UiElementBufferBufferBase(width, height){
}

85
implementations/Crafter.Graphics-UiElementBufferBufferBase.cpp
View file

@ -1,85 +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 as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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 Crafter.Graphics:UiElementBufferBufferBase_impl;
import :UiElement;
import std;
using namespace Crafter;
UiElementBufferBufferBase::UiElementBufferBufferBase(std::uint_fast32_t width, std::uint_fast32_t height) : UiElementBuffer(width, height), buffer(width*height) {
}
void UiElementBufferBufferBase::Create(std::uint_fast32_t width, std::uint_fast32_t height) {
buffer.resize(width*height);
}
void UiElementBufferBufferBase::Resize(std::uint_fast32_t width, std::uint_fast32_t height) {
buffer.resize(width*height);
}
void UiElementBufferBufferBase::Resize(std::uint_fast32_t width, std::uint_fast32_t height, std::uint_fast32_t offsetX, std::uint_fast32_t offsetY) {
}
void UiElementBufferBufferBase::ResizeNearestNeighbour(std::uint_fast32_t width, std::uint_fast32_t height) {
}
void UiElementBufferBufferBase::ResizeBicubic(std::uint_fast32_t width, std::uint_fast32_t height) {
}
void UiElementBufferBufferBase::Destroy() {
buffer.clear();
width = 0;
height = 0;
}
void UiElementBufferBufferBase::Copy(Pixel_BU8_GU8_RU8_AU8* dst) const {
std::memcpy(dst, buffer.data(), width*height*sizeof(Pixel_BU8_GU8_RU8_AU8));
}
void UiElementBufferBufferBase::CopyNearestNeighbour(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const {
for (std::uint_fast32_t y = 0; y < dstHeight; y++) {
std::uint_fast32_t srcY = y * height / dstHeight;
for (std::uint_fast32_t x = 0; x < dstWidth; x++) {
std::uint_fast32_t srcX = x * width / dstWidth;
dst[y * dstWidth + x] = buffer[srcY * width + srcX];
}
}
}
void UiElementBufferBufferBase::CopyBicubic(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const {
}
void UiElementBufferBufferBase::Write(Pixel_BU8_GU8_RU8_AU8* pixels) {
std::memcpy(buffer.data(), pixels, width*height*sizeof(Pixel_BU8_GU8_RU8_AU8));
}
void UiElementBufferBufferBase::Write(std::uint_fast32_t x, std::uint_fast32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) {
buffer[y * width + x] = pixel;
}
Pixel_BU8_GU8_RU8_AU8 UiElementBufferBufferBase::Read(std::uint_fast32_t x, std::uint_fast32_t y) const {
return buffer[y * width + x];
}
const Pixel_BU8_GU8_RU8_AU8* UiElementBufferBufferBase::Read() const {
return buffer.data();
}
Pixel_BU8_GU8_RU8_AU8* UiElementBufferBufferBase::Get() {
return buffer.data();
}
void UiElementBufferBufferBase::Store() {
}

33
implementations/Crafter.Graphics-UiElementBufferMouseBuffer.cpp
View file

@ -1,33 +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 as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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 Crafter.Graphics:UiElementBufferMouseBuffer_impl;
import :UiElement;
import std;
using namespace Crafter;
UiElementBufferMouseBuffer::UiElementBufferMouseBuffer(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX, std::int_fast32_t anchorOffsetY, std::int_fast32_t z, bool ignoreScaling) : UiElementBufferBuffer(anchorX, anchorY, relativeWidth, relativeHeight, anchorOffsetX, anchorOffsetY, z, ignoreScaling) {
}
UiElementBufferMouseBuffer::UiElementBufferMouseBuffer(std::uint_fast32_t width, std::uint_fast32_t height, std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX, std::int_fast32_t anchorOffsetY, std::int_fast32_t z, bool ignoreScaling) : UiElementBufferBuffer(width, height, anchorX, anchorY, relativeWidth, relativeHeight, anchorOffsetX, anchorOffsetY, z, ignoreScaling) {
}

605
implementations/Crafter.Graphics-Window.cpp Normal file
View file

@ -0,0 +1,605 @@
/*
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 as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
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 <cstdint>
#include <fcntl.h>
#include <linux/input.h>
#include <unistd.h>
#include <wayland-cursor.h>
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_wayland.h>
#include <wayland-client.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-client.h>
#include <wayland-client-protocol.h>
#include <linux/input-event-codes.h>
#include <xkbcommon/xkbcommon.h>
#include "../lib/xdg-shell-client-protocol.h"
#include "../lib/wayland-xdg-decoration-unstable-v1-client-protocol.h"
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/input.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-cursor.h>
#include <xkbcommon/xkbcommon.h>
#include <vulkan/vulkan.h>
#include <vulkan/vulkan_wayland.h>
#include <wayland-client.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#include <print>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-client.h>
#include <wayland-client-protocol.h>
#include <linux/input-event-codes.h>
module Crafter.Graphics:Window_impl;
import :Window;
import std;
import Crafter.Event;
using namespace Crafter;
void randname(char *buf) {
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
long r = ts.tv_nsec;
for (int i = 0; i < 6; ++i) {
buf[i] = 'A'+(r&15)+(r&16)*2;
r >>= 5;
}
}
int anonymous_shm_open(void) {
char name[] = "/hello-wayland-XXXXXX";
int retries = 100;
do {
randname(name + strlen(name) - 6);
--retries;
// shm_open guarantees that O_CLOEXEC is set
int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
if (fd >= 0) {
shm_unlink(name);
return fd;
}
} while (retries > 0 && errno == EEXIST);
return -1;
}
int create_shm_file(off_t size) {
int fd = anonymous_shm_open();
if (fd < 0) {
return fd;
}
if (ftruncate(fd, size) < 0) {
close(fd);
return -1;
}
return fd;
}
int counter = 0;
void ScaleBitmapR8G8B8(Pixel_BU8_GU8_RU8_AU8* dst, const Pixel_BU8_GU8_RU8_AU8* src, std::uint32_t srcWidth, std::uint32_t srcHeight, std::uint32_t dstWidth, std::uint32_t dstHeight) {
for (std::uint32_t y = 0; y < dstHeight; y++) {
std::uint32_t srcY = y * srcHeight / dstHeight;
for (std::uint32_t x = 0; x < dstWidth; x++) {
std::uint32_t srcX = x * srcWidth / dstWidth;
const Pixel_BU8_GU8_RU8_AU8* srcPixel = src + (srcY * srcWidth + srcX);
Pixel_BU8_GU8_RU8_AU8* dstPixel = dst + (y * dstWidth + x);
dstPixel[0] = srcPixel[0];
}
}
}
Window::Window(std::string name, std::uint32_t width, std::uint32_t height) : name(name), width(width), height(height) {
display = wl_display_connect(NULL);
if (display == NULL) {
std::cerr << "failed to create display" << std::endl;
}
wl_registry* registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, &registry_listener, this);
if (wl_display_roundtrip(display) == -1) {
exit(EXIT_FAILURE);
}
if (shm == NULL || compositor == NULL || xdgWmBase == NULL) {
std::cerr << "no wl_shm, wl_compositor or xdg_wm_base support" << std::endl;
exit(EXIT_FAILURE);
}
surface = wl_compositor_create_surface(compositor);
xdgSurface = xdg_wm_base_get_xdg_surface(xdgWmBase, surface);
xdgToplevel = xdg_surface_get_toplevel(xdgSurface);
cb = wl_surface_frame(surface);
wl_callback_add_listener(cb, &surface_frame_listener, this);
xdg_surface_add_listener(xdgSurface, &xdg_surface_listener, this);
xdg_toplevel_add_listener(xdgToplevel, &xdg_toplevel_listener, this);
wl_surface_commit(surface);
xdg_toplevel_set_title(xdgToplevel, name.c_str());
while (wl_display_dispatch(display) != -1 && !configured) {}
wl_surface_commit(surface);
zxdg_toplevel_decoration_v1* decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(manager, xdgToplevel);
zxdg_toplevel_decoration_v1_set_mode(decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
// Create a wl_buffer, attach it to the surface and commit the surface
int stride = width * 4;
int size = stride * height;
// Allocate a shared memory file with the right size
int fd = create_shm_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n", size);
}
// Map the shared memory file
framebuffer = reinterpret_cast<Pixel_BU8_GU8_RU8_AU8*>(mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
if (framebuffer == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
}
// Create a wl_buffer from our shared memory file descriptor
wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
// Now that we've mapped the file and created the wl_buffer, we no longer
// need to keep file descriptor opened
close(fd);
if (buffer == NULL) {
exit(EXIT_FAILURE);
}
wl_surface_attach(surface, buffer, 0, 0);
wl_surface_commit(surface);
}
ScaleData Window::ScaleElement(const UiElement& element) {
ScaleData data;
if(element.ignoreScaling) {
if(element.useRelativeSize) {
data.width = element.relativeWidth*width;
data.height = element.relativeHeight*height;
} else {
data.width = element.absoluteWidth;
data.height = element.absoluteHeight;
}
} else {
if(element.useRelativeSize) {
data.width = element.relativeWidth*width*scale;
data.height = element.relativeHeight*height*scale;
} else {
data.width = element.absoluteWidth*scale;
data.height = element.absoluteHeight*scale;
}
}
data.x = (element.anchorX*width)-(element.anchorOffsetX*data.width);
data.y = (element.anchorY*height)-(element.anchorOffsetY*data.height);
return data;
}
ScaleData ScaleElement(const UiElement& element, const ScaleData& parent, const Window* window) {
ScaleData data;
if(element.ignoreScaling) {
if(element.useRelativeSize) {
data.width = element.relativeWidth*parent.width;
data.height = element.relativeHeight*parent.height;
} else {
data.width = element.absoluteWidth;
data.height = element.absoluteHeight;
}
} else {
if(element.useRelativeSize) {
data.width = element.relativeWidth*parent.width*window->scale;
data.height = element.relativeHeight*parent.height*window->scale;
} else {
data.width = element.absoluteWidth*window->scale;
data.height = element.absoluteHeight*window->scale;
}
}
data.x = ((element.anchorX*parent.width)-(element.anchorOffsetX*data.width))+parent.x;
data.y = ((element.anchorY*parent.height)-(element.anchorOffsetY*data.height))+parent.y;
return data;
}
static void xdg_wm_base_handle_ping(void* data, xdg_wm_base* xdg_wm_base, std::uint32_t serial) {
xdg_wm_base_pong(xdg_wm_base, serial);
}
xdg_wm_base_listener xdgWmBaseListener = {
.ping = xdg_wm_base_handle_ping,
};
void RenderElements(Window* window, const UiElement& parent, const ScaleData& parentScale) {
std::vector<UiElement*> drawOrder;
drawOrder.reserve(parent.children.size());
for (const std::unique_ptr<UiElement>& e : parent.children) drawOrder.push_back(e.get());
std::sort(drawOrder.begin(), drawOrder.end(), [](UiElement* a, UiElement* b){ return a->z < b->z; });
for(const UiElement* element : drawOrder) {
ScaleData data = ScaleElement(*element, parentScale, window);
std::vector<Pixel_BU8_GU8_RU8_AU8> scaled(data.width*data.height);
ScaleBitmapR8G8B8(scaled.data(), element->buffer.data(), element->bufferWidth, element->bufferHeight, data.width, data.height);
for (std::int32_t x = data.x; x - data.x < data.width; x++) {
for (std::int32_t y = data.y; y - data.y < data.height; y++) {
if (x >= 0 && x < window->width && y >= 0 && y < window->height) {
Pixel_BU8_GU8_RU8_AU8& dst = window->framebuffer[y * window->width + x];
const Pixel_BU8_GU8_RU8_AU8& src = scaled[(y - data.y) * data.width + (x - data.x)];
float srcA = src.a / 255.0f;
float dstA = dst.a / 255.0f;
float outA = srcA + dstA * (1.0f - srcA);
if (outA > 0.0f) {
dst.r = static_cast<uint8_t>((src.r * srcA + dst.r * dstA * (1.0f - srcA)) / outA);
dst.g = static_cast<uint8_t>((src.g * srcA + dst.g * dstA * (1.0f - srcA)) / outA);
dst.b = static_cast<uint8_t>((src.b * srcA + dst.b * dstA * (1.0f - srcA)) / outA);
dst.a = static_cast<uint8_t>(outA * 255);
}
}
}
}
RenderElements(window, *element, data);
}
}
void Window::wl_surface_frame_done(void* data, struct wl_callback *cb, uint32_t time)
{
wl_callback_destroy(cb);
Window* window = reinterpret_cast<Window*>(data);
cb = wl_surface_frame(window->surface);
wl_callback_add_listener(cb, &Window::surface_frame_listener, window);
std::vector<UiElement*> drawOrder;
drawOrder.reserve(window->elements.size());
for (UiElement& e : window->elements) drawOrder.push_back(&e);
std::sort(drawOrder.begin(), drawOrder.end(), [](UiElement* a, UiElement* b){ return a->z < b->z; });
for(const UiElement* element : drawOrder) {
ScaleData data = window->ScaleElement(*element);
std::vector<Pixel_BU8_GU8_RU8_AU8> scaled(data.width*data.height);
ScaleBitmapR8G8B8(scaled.data(), element->buffer.data(), element->bufferWidth, element->bufferHeight, data.width, data.height);
for (std::int32_t x = data.x; x - data.x < data.width; x++) {
for (std::int32_t y = data.y; y - data.y < data.height; y++) {
if (x >= 0 && x < window->width && y >= 0 && y < window->height) {
Pixel_BU8_GU8_RU8_AU8& dst = window->framebuffer[y * window->width + x];
const Pixel_BU8_GU8_RU8_AU8& src = scaled[(y - data.y) * data.width + (x - data.x)];
float srcA = src.a / 255.0f;
float dstA = dst.a / 255.0f;
float outA = srcA + dstA * (1.0f - srcA);
if (outA > 0.0f) {
dst.r = static_cast<uint8_t>((src.r * srcA + dst.r * dstA * (1.0f - srcA)) / outA);
dst.g = static_cast<uint8_t>((src.g * srcA + dst.g * dstA * (1.0f - srcA)) / outA);
dst.b = static_cast<uint8_t>((src.b * srcA + dst.b * dstA * (1.0f - srcA)) / outA);
dst.a = static_cast<uint8_t>(outA * 255);
}
}
}
}
RenderElements(window, *element, data);
}
wl_surface_attach(window->surface, window->buffer, 0, 0);
wl_surface_damage(window->surface, 0, 0, window->width, window->height);
wl_surface_commit(window->surface);
}
wl_callback_listener Window::surface_frame_listener = {
.done = wl_surface_frame_done,
};
void Window::pointer_handle_button(void* data, wl_pointer* pointer, std::uint32_t serial, std::uint32_t time, std::uint32_t button, std::uint32_t state) {
Window* window = reinterpret_cast<Window*>(data);
if (button == BTN_LEFT) {
if(state == WL_POINTER_BUTTON_STATE_PRESSED) {
window->mouseLeftHeld = true;
window->onMouseLeftClick.Invoke(window->currentMousePos);
for(UiElement& element : window->elements) {
ScaleData data = window->ScaleElement(element);
if(window->currentMousePos.x >= data.x && window->currentMousePos.x <= data.x+data.width && window->currentMousePos.y > data.y && window->currentMousePos.y < data.y+data.height) {
element.onMouseLeftClick.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
}
} else {
window->mouseLeftHeld = false;
window->onMouseLeftRelease.Invoke(window->currentMousePos);
for(UiElement& element : window->elements) {
ScaleData data = window->ScaleElement(element);
if(window->currentMousePos.x >= data.x && window->currentMousePos.x <= data.x+data.width && window->currentMousePos.y > data.y && window->currentMousePos.y < data.y+data.height) {
element.onMouseLeftRelease.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
}
}
} else if(button == BTN_RIGHT){
if(state == WL_POINTER_BUTTON_STATE_PRESSED) {
window->mouseRightHeld = true;
window->onMouseRightClick.Invoke(window->currentMousePos);
for(UiElement& element : window->elements) {
ScaleData data = window->ScaleElement(element);
if(window->currentMousePos.x >= data.x && window->currentMousePos.x <= data.x+data.width && window->currentMousePos.y > data.y && window->currentMousePos.y < data.y+data.height) {
element.onMouseRightClick.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
}
} else {
window->mouseRightHeld = true;
window->onMouseRightRelease.Invoke(window->currentMousePos);
for(UiElement& element : window->elements) {
ScaleData data = window->ScaleElement(element);
if(window->currentMousePos.x >= data.x && window->currentMousePos.x <= data.x+data.width && window->currentMousePos.y > data.y && window->currentMousePos.y < data.y+data.height) {
element.onMouseRightRelease.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
}
}
}
}
void Window::PointerListenerHandleMotion(void* data, wl_pointer* wl_pointer, uint time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
Window* window = reinterpret_cast<Window*>(data);
MousePoint pos = {wl_fixed_to_double(surface_x), wl_fixed_to_double(surface_y)};
window->lastMousePos = window->currentMousePos;
window->currentMousePos = pos;
window->mouseDelta = {window->currentMousePos.x-window->lastMousePos.x, window->currentMousePos.y-window->lastMousePos.y};
window->onMouseMove.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
for(UiElement& element : window->elements) {
ScaleData data = window->ScaleElement(element);
if(window->currentMousePos.x >= data.x && window->currentMousePos.x <= data.x+data.width && window->currentMousePos.y > data.y && window->currentMousePos.y < data.y+data.height) {
element.onMouseMove.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
if(!(window->lastMousePos.x >= data.x && window->lastMousePos.x <= data.x+data.width && window->lastMousePos.y > data.y && window->lastMousePos.y < data.y+data.height)) {
element.onMouseEnter.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
} else if(window->lastMousePos.x >= data.x && window->lastMousePos.x <= data.x+data.width && window->lastMousePos.y > data.y && window->lastMousePos.y < data.y+data.height) {
element.onMouseLeave.Invoke({window->currentMousePos.x-data.x, window->currentMousePos.y-data.y});
}
}
}
void Window::PointerListenerHandleEnter(void* data, wl_pointer* wl_pointer, uint serial, wl_surface* surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
Window* window = reinterpret_cast<Window*>(data);
window->onMouseEnter.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
}
void Window::PointerListenerHandleLeave(void* data, wl_pointer*, std::uint32_t, wl_surface*) {
Window* window = reinterpret_cast<Window*>(data);
window->onMouseEnter.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
}
void Window::PointerListenerHandleAxis(void*, wl_pointer*, std::uint32_t, std::uint32_t, wl_fixed_t value) {
}
wl_pointer_listener Window::pointer_listener = {
.enter = Window::PointerListenerHandleEnter,
.leave = Window::PointerListenerHandleLeave,
.motion = Window::PointerListenerHandleMotion,
.button = Window::pointer_handle_button,
.axis = Window::PointerListenerHandleAxis,
};
xkb_keymap* xkb_keymap;
xkb_context* xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
xkb_state* xkb_state;
void keyboard_keymap(void *data, wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
fprintf(stderr, "Unsupported keymap format\n");
return;
}
void *map = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
close(fd);
perror("mmap");
return;
}
xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
xkb_keymap = xkb_keymap_new_from_string(xkb_context, (const char *)map, XKB_KEYMAP_FORMAT_TEXT_V1,XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(map, size);
close(fd);
xkb_state = xkb_state_new(xkb_keymap);
}
void keyboard_enter(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface, wl_array *keys) {
}
void keyboard_leave(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface) {
}
void keyboard_key(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
if (!xkb_state) {
return;
}
Window* window = reinterpret_cast<Window*>(data);
xkb_keycode_t keycode = key + 8;
xkb_keysym_t keysym = xkb_state_key_get_one_sym(xkb_state, keycode);
char utf8[8] = {0};
int len = xkb_keysym_to_utf8(keysym, utf8, sizeof(utf8));
if (len != 0) {
char keypress = utf8[0];
if(state == WL_KEYBOARD_KEY_STATE_PRESSED) {
if(window->heldkeys[keypress]) {
window->onKeyHold[keypress].Invoke();
window->onAnyKeyHold.Invoke(keypress);
} else{
window->heldkeys[keypress] = true;
window->onKeyDown[keypress].Invoke();
window->onAnyKeyDown.Invoke(keypress);
}
} else{
window->heldkeys[keypress] = false;
window->onKeyUp[keypress].Invoke();
window->onAnyKeyUp.Invoke(keypress);
}
} else {
// // fallback for keys like Return, Escape, etc.
// char name[64];
// if (xkb_keysym_get_name(keysym, name, sizeof(name)) > 0) {
// printf("Key %s pressed (non-printable or multi-char)\n", name);
// }
}
}
void keyboard_modifiers(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
}
void keyboard_repeat_info(void *data, wl_keyboard *keyboard, int32_t rate, int32_t delay) {
}
wl_keyboard_listener Window::keyboard_listener = {
.keymap = keyboard_keymap,
.enter = keyboard_enter,
.leave = keyboard_leave,
.key = keyboard_key,
.modifiers = keyboard_modifiers,
.repeat_info = keyboard_repeat_info,
};
void Window::seat_handle_capabilities(void* data, wl_seat* seat, uint32_t capabilities) {
Window* window = reinterpret_cast<Window*>(data);
window->seat = seat;
if (capabilities & WL_SEAT_CAPABILITY_POINTER) {
wl_pointer* pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(pointer, &pointer_listener, window);
}
if (capabilities & WL_SEAT_CAPABILITY_KEYBOARD) {
wl_keyboard* keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(keyboard, &keyboard_listener, window);
}
}
wl_seat_listener Window::seat_listener = {
.capabilities = seat_handle_capabilities,
};
void Window::handle_global(void *data, wl_registry *registry, std::uint32_t name, const char *interface, std::uint32_t version) {
Window* window = reinterpret_cast<Window*>(data);
if (strcmp(interface, wl_shm_interface.name) == 0) {
window->shm = reinterpret_cast<wl_shm*>(wl_registry_bind(registry, name, &wl_shm_interface, 1));
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
wl_seat* seat = reinterpret_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 1));
wl_seat_add_listener(seat, &seat_listener, window);
} else if (compositor == NULL && strcmp(interface, wl_compositor_interface.name) == 0) {
compositor = reinterpret_cast<wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
} else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
window->xdgWmBase = reinterpret_cast<xdg_wm_base*>(wl_registry_bind(registry, name, &xdg_wm_base_interface, 1));
xdg_wm_base_add_listener(window->xdgWmBase, &xdgWmBaseListener, NULL);
} else if (strcmp(interface, zxdg_decoration_manager_v1_interface.name) == 0) {
window->manager = reinterpret_cast<zxdg_decoration_manager_v1*>(wl_registry_bind(registry, name, &zxdg_decoration_manager_v1_interface, 1));
}
}
static void handle_global_remove(void* data, wl_registry* registry, uint32_t name) {
}
wl_registry_listener Window::registry_listener = {
.global = Window::handle_global,
.global_remove = handle_global_remove,
};
static void noop5(void*, xdg_toplevel*, std::int32_t, std::int32_t, wl_array*){
}
void Window::xdg_toplevel_handle_close(void* data, xdg_toplevel*) {
Window* window = reinterpret_cast<Window*>(data);
window->onClose.Invoke();
window->open = false;
}
xdg_toplevel_listener Window::xdg_toplevel_listener = {
.configure = noop5,
.close = Window::xdg_toplevel_handle_close,
};
void Window::xdg_surface_handle_configure(void* data, xdg_surface* xdg_surface, std::uint32_t serial) {
Window* window = reinterpret_cast<Window*>(data);
// The compositor configures our surface, acknowledge the configure event
xdg_surface_ack_configure(xdg_surface, serial);
if (window->configured) {
// If this isn't the first configure event we've received, we already
// have a buffer attached, so no need to do anything. Commit the
// surface to apply the configure acknowledgement.
wl_surface_commit(window->surface);
}
window->configured = true;
}
xdg_surface_listener Window::xdg_surface_listener = {
.configure = xdg_surface_handle_configure,
};
Window::~Window() {
xdg_toplevel_destroy(xdgToplevel);
xdg_surface_destroy(xdgSurface);
wl_surface_destroy(surface);
wl_buffer_destroy(buffer);
}
void Window::StartSync() {
while (open && wl_display_dispatch(display) != -1) {
}
}

467
implementations/Crafter.Graphics-Window_wayland.cpp
View file

@ -1,467 +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
*/
module;
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/input-event-codes.h>
#include <xkbcommon/xkbcommon.h>
#include "../lib/xdg-shell-client-protocol.h"
#include "../lib/wayland-xdg-decoration-unstable-v1-client-protocol.h"
#include <string.h>
#include <linux/input.h>
#include <sys/mman.h>
#include <wayland-cursor.h>
#include <xkbcommon/xkbcommon.h>
#include <errno.h>
#include <fcntl.h>
#include <print>
#include <wayland-client.h>
#include <wayland-client-protocol.h>
module Crafter.Graphics:Window_wayland_impl;
import :Window;
import :UiElement;
import std;
import :Types;
import :Shm;
import Crafter.Event;
using namespace Crafter;
WindowFramebuffer::WindowFramebuffer(std::uint_fast32_t width, std::uint_fast32_t height) : width(width), height(height) {
}
WindowWayland::WindowWayland(std::uint_fast32_t width, std::uint_fast32_t height) : WindowFramebuffer(width, height) {
display = wl_display_connect(NULL);
if (display == NULL) {
std::cerr << "failed to create display" << std::endl;
}
wl_registry* registry = wl_display_get_registry(display);
wl_registry_add_listener(registry, &registry_listener, this);
if (wl_display_roundtrip(display) == -1) {
exit(EXIT_FAILURE);
}
if (shm == NULL || compositor == NULL || xdgWmBase == NULL) {
std::cerr << "no wl_shm, wl_compositor or xdg_wm_base support" << std::endl;
exit(EXIT_FAILURE);
}
surface = wl_compositor_create_surface(compositor);
xdgSurface = xdg_wm_base_get_xdg_surface(xdgWmBase, surface);
xdgToplevel = xdg_surface_get_toplevel(xdgSurface);
xdg_surface_add_listener(xdgSurface, &xdg_surface_listener, this);
xdg_toplevel_add_listener(xdgToplevel, &xdg_toplevel_listener, this);
wl_surface_commit(surface);
while (wl_display_dispatch(display) != -1 && !configured) {}
wl_surface_commit(surface);
zxdg_toplevel_decoration_v1* decoration = zxdg_decoration_manager_v1_get_toplevel_decoration(manager, xdgToplevel);
zxdg_toplevel_decoration_v1_set_mode(decoration, ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE);
// Create a wl_buffer, attach it to the surface and commit the surface
int stride = width * 4;
int size = stride * height;
// Allocate a shared memory file with the right size
int fd = create_shm_file(size);
if (fd < 0) {
fprintf(stderr, "creating a buffer file for %d B failed: %m\n", size);
}
// Map the shared memory file
framebuffer = reinterpret_cast<Pixel_BU8_GU8_RU8_AU8*>(mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
if (framebuffer == MAP_FAILED) {
fprintf(stderr, "mmap failed: %m\n");
close(fd);
}
// Create a wl_buffer from our shared memory file descriptor
wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);
buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_ARGB8888);
wl_shm_pool_destroy(pool);
// Now that we've mapped the file and created the wl_buffer, we no longer
// need to keep file descriptor opened
close(fd);
if (buffer == NULL) {
exit(EXIT_FAILURE);
}
wl_surface_attach(surface, buffer, 0, 0);
wl_surface_commit(surface);
}
WindowWayland::WindowWayland(std::uint_fast32_t width, std::uint_fast32_t height, const std::string_view title) : WindowWayland(width, height) {
xdg_toplevel_set_title(xdgToplevel, title.data());
}
WindowWayland::~WindowWayland() {
xdg_toplevel_destroy(xdgToplevel);
xdg_surface_destroy(xdgSurface);
wl_surface_destroy(surface);
wl_buffer_destroy(buffer);
}
void WindowWayland::StartSync() {
while (open && wl_display_dispatch(display) != -1) {
}
}
void RenderElement(UiElementBufferBuffer* element, ScaleData data , WindowWayland* window) {
std::vector<Pixel_BU8_GU8_RU8_AU8> scaled(data.width*data.height);
element->CopyNearestNeighbour(scaled.data(), data.width, data.height);
for (std::int32_t x = data.x; x - data.x < data.width; x++) {
for (std::int32_t y = data.y; y - data.y < data.height; y++) {
if (x >= 0 && x < window->width && y >= 0 && y < window->height) {
Pixel_BU8_GU8_RU8_AU8& dst = window->framebuffer[y * window->width + x];
const Pixel_BU8_GU8_RU8_AU8& src = scaled[(y - data.y) * data.width + (x - data.x)];
float srcA = src.a / 255.0f;
float dstA = dst.a / 255.0f;
float outA = srcA + dstA * (1.0f - srcA);
if (outA > 0.0f) {
dst.r = static_cast<uint8_t>((src.r * srcA + dst.r * dstA * (1.0f - srcA)) / outA);
dst.g = static_cast<uint8_t>((src.g * srcA + dst.g * dstA * (1.0f - srcA)) / outA);
dst.b = static_cast<uint8_t>((src.b * srcA + dst.b * dstA * (1.0f - srcA)) / outA);
dst.a = static_cast<uint8_t>(outA * 255);
}
}
}
}
std::sort(element->children.begin(), element->children.end(), [](UiElement* a, UiElement* b){ return a->z < b->z; });
for(UiElement* child : element->children) {
std::int32_t scaledWidth = MappedToPixel(element->relativeWidth, data.width);
std::int32_t scaledHeight = MappedToPixel(element->relativeHeight, data.height);
std::int32_t scaledX = MappedToPixel(element->anchorX, data.width) - MappedToPixel(element->anchorOffsetX, scaledWidth) - data.x;
std::int32_t scaledY = MappedToPixel(element->anchorY, data.height) - MappedToPixel(element->anchorOffsetY, scaledHeight) - data.y;
RenderElement(element, {
scaledX,
scaledY,
scaledWidth,
scaledHeight
}, window);
}
}
void WindowWayland::Render() {
std::sort(elements.begin(), elements.end(), [](UiElementBufferBuffer* a, UiElementBufferBuffer* b){ return a->z < b->z; });
for(UiElementBufferBuffer* element : elements) {
std::int32_t scaledWidth = MappedToPixel(element->relativeWidth, width);
std::int32_t scaledHeight = MappedToPixel(element->relativeHeight, height);
std::int32_t scaledX = MappedToPixel(element->anchorX, width) - MappedToPixel(element->anchorOffsetX, scaledWidth);
std::int32_t scaledY = MappedToPixel(element->anchorY, height) - MappedToPixel(element->anchorOffsetY, scaledHeight);
RenderElement(element, {
scaledX,
scaledY,
scaledWidth,
scaledHeight
}, this);
}
wl_surface_attach(surface, buffer, 0, 0);
wl_surface_damage(surface, 0, 0, width, height);
wl_surface_commit(surface);
}
void WindowWayland::StartUpdate() {
cb = wl_surface_frame(surface);
wl_callback_add_listener(cb, &wl_callback_listener, this);
updating = true;
}
void WindowWayland::StopUpdate() {
updating = false;
}
void WindowWayland::SetTitle(const std::string_view title) {
xdg_toplevel_set_title(xdgToplevel, title.data());
}
void WindowWayland::Resize(std::uint_fast32_t width, std::uint_fast32_t height) {
}
void WindowWayland::Write(Pixel_BU8_GU8_RU8_AU8* pixels) {
std::memcpy(framebuffer, pixels, width*height*sizeof(Pixel_BU8_GU8_RU8_AU8));
}
void WindowWayland::Write(std::uint_fast32_t x, std::uint_fast32_t y, Pixel_BU8_GU8_RU8_AU8 pixel) {
framebuffer[y * width + x] = pixel;
}
Pixel_BU8_GU8_RU8_AU8 WindowWayland::Read(std::uint_fast32_t x, std::uint_fast32_t y) const{
return framebuffer[y * width + x];
}
const Pixel_BU8_GU8_RU8_AU8* WindowWayland::Read() const{
return framebuffer;
}
Pixel_BU8_GU8_RU8_AU8* WindowWayland::Get() {
return framebuffer;
}
void WindowWayland::Store() {
}
void WindowWayland::xdg_wm_base_handle_ping(void* data, xdg_wm_base* xdg_wm_base, std::uint32_t serial) {
xdg_wm_base_pong(xdg_wm_base, serial);
}
void WindowWayland::wl_surface_frame_done(void* data, struct wl_callback *cb, uint32_t time)
{
wl_callback_destroy(cb);
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
if(window->updating) {
cb = wl_surface_frame(window->surface);
wl_callback_add_listener(cb, &WindowWayland::wl_callback_listener, window);
}
window->Render();
}
void WindowWayland::pointer_handle_button(void* data, wl_pointer* pointer, std::uint32_t serial, std::uint32_t time, std::uint32_t button, std::uint32_t state) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
if (button == BTN_LEFT) {
if(state == WL_POINTER_BUTTON_STATE_PRESSED) {
window->mouseLeftHeld = true;
window->onMouseLeftClick.Invoke(window->currentMousePos);
for(UiElementMouse* element : window->mouseElements) {
if(window->currentMousePos.x >= element->clickArea.x && window->currentMousePos.x <= element->clickArea.x+element->clickArea.width && window->currentMousePos.y > element->clickArea.y && window->currentMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseLeftClick.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
}
} else {
window->mouseLeftHeld = false;
window->onMouseLeftRelease.Invoke(window->currentMousePos);
for(UiElementMouse* element : window->mouseElements) {
if(window->currentMousePos.x >= element->clickArea.x && window->currentMousePos.x <= element->clickArea.x+element->clickArea.width && window->currentMousePos.y > element->clickArea.y && window->currentMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseLeftRelease.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
}
}
} else if(button == BTN_RIGHT){
if(state == WL_POINTER_BUTTON_STATE_PRESSED) {
window->mouseRightHeld = true;
window->onMouseRightClick.Invoke(window->currentMousePos);
for(UiElementMouse* element : window->mouseElements) {
if(window->currentMousePos.x >= element->clickArea.x && window->currentMousePos.x <= element->clickArea.x+element->clickArea.width && window->currentMousePos.y > element->clickArea.y && window->currentMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseRightClick.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
}
} else {
window->mouseRightHeld = true;
window->onMouseRightRelease.Invoke(window->currentMousePos);
for(UiElementMouse* element : window->mouseElements) {
if(window->currentMousePos.x >= element->clickArea.x && window->currentMousePos.x <= element->clickArea.x+element->clickArea.width && window->currentMousePos.y > element->clickArea.y && window->currentMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseRightRelease.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
}
}
}
}
void WindowWayland::PointerListenerHandleMotion(void* data, wl_pointer* wl_pointer, uint time, wl_fixed_t surface_x, wl_fixed_t surface_y) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
MousePoint pos = {PixelToMapped(wl_fixed_to_double(surface_x), window->width), PixelToMapped(wl_fixed_to_double(surface_y), window->height)};
window->lastMousePos = window->currentMousePos;
window->currentMousePos = pos;
window->mouseDelta = {window->currentMousePos.x-window->lastMousePos.x, window->currentMousePos.y-window->lastMousePos.y};
window->onMouseMove.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
for(UiElementMouse* element : window->mouseElements) {
if(window->currentMousePos.x >= element->clickArea.x && window->currentMousePos.x <= element->clickArea.x+element->clickArea.width && window->currentMousePos.y > element->clickArea.y && window->currentMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseMove.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
if(!(window->lastMousePos.x >= element->clickArea.x && window->lastMousePos.x <= element->clickArea.x+element->clickArea.width && window->lastMousePos.y > element->clickArea.y && window->lastMousePos.y < element->clickArea.y+element->clickArea.height)) {
element->onMouseEnter.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
} else if(window->lastMousePos.x >= element->clickArea.x && window->lastMousePos.x <= element->clickArea.x+element->clickArea.width && window->lastMousePos.y > element->clickArea.y && window->lastMousePos.y < element->clickArea.y+element->clickArea.height) {
element->onMouseLeave.Invoke({window->currentMousePos.x-element->clickArea.x, window->currentMousePos.y-element->clickArea.y});
}
}
}
void WindowWayland::PointerListenerHandleEnter(void* data, wl_pointer* wl_pointer, uint serial, wl_surface* surface, wl_fixed_t surface_x, wl_fixed_t surface_y) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
window->onMouseEnter.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
}
void WindowWayland::PointerListenerHandleLeave(void* data, wl_pointer*, std::uint32_t, wl_surface*) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
window->onMouseEnter.Invoke({window->lastMousePos, window->currentMousePos, window->mouseDelta});
}
void WindowWayland::PointerListenerHandleAxis(void*, wl_pointer*, std::uint32_t, std::uint32_t, wl_fixed_t value) {
}
void WindowWayland::keyboard_keymap(void *data, wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
fprintf(stderr, "Unsupported keymap format\n");
return;
}
void *map = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map == MAP_FAILED) {
close(fd);
perror("mmap");
return;
}
window->xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
window->xkb_keymap = xkb_keymap_new_from_string(window->xkb_context, (const char *)map, XKB_KEYMAP_FORMAT_TEXT_V1,XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(map, size);
close(fd);
window->xkb_state = xkb_state_new(window->xkb_keymap);
}
void WindowWayland::keyboard_enter(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface, wl_array *keys) {
}
void WindowWayland::keyboard_leave(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface) {
}
void WindowWayland::keyboard_key(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
if (!window->xkb_state) {
return;
}
xkb_keycode_t keycode = key + 8;
xkb_keysym_t keysym = xkb_state_key_get_one_sym(window->xkb_state, keycode);
char utf8[8] = {0};
int len = xkb_keysym_to_utf8(keysym, utf8, sizeof(utf8));
if (len != 0) {
char keypress = utf8[0];
if(state == WL_KEYBOARD_KEY_STATE_PRESSED) {
if(window->heldkeys[keypress]) {
window->onKeyHold[keypress].Invoke();
window->onAnyKeyHold.Invoke(keypress);
} else{
window->heldkeys[keypress] = true;
window->onKeyDown[keypress].Invoke();
window->onAnyKeyDown.Invoke(keypress);
}
} else{
window->heldkeys[keypress] = false;
window->onKeyUp[keypress].Invoke();
window->onAnyKeyUp.Invoke(keypress);
}
} else {
// // fallback for keys like Return, Escape, etc.
// char name[64];
// if (xkb_keysym_get_name(keysym, name, sizeof(name)) > 0) {
// printf("Key %s pressed (non-printable or multi-char)\n", name);
// }
}
}
void WindowWayland::keyboard_modifiers(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
}
void WindowWayland::keyboard_repeat_info(void *data, wl_keyboard *keyboard, int32_t rate, int32_t delay) {
}
void WindowWayland::seat_handle_capabilities(void* data, wl_seat* seat, uint32_t capabilities) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
window->seat = seat;
if (capabilities & WL_SEAT_CAPABILITY_POINTER) {
wl_pointer* pointer = wl_seat_get_pointer(seat);
wl_pointer_add_listener(pointer, &pointer_listener, window);
}
if (capabilities & WL_SEAT_CAPABILITY_KEYBOARD) {
wl_keyboard* keyboard = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(keyboard, &keyboard_listener, window);
}
}
void WindowWayland::handle_global(void *data, wl_registry *registry, std::uint32_t name, const char *interface, std::uint32_t version) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
if (strcmp(interface, wl_shm_interface.name) == 0) {
window->shm = reinterpret_cast<wl_shm*>(wl_registry_bind(registry, name, &wl_shm_interface, 1));
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
wl_seat* seat = reinterpret_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 1));
wl_seat_add_listener(seat, &seat_listener, window);
} else if (compositor == NULL && strcmp(interface, wl_compositor_interface.name) == 0) {
compositor = reinterpret_cast<wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
} else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
window->xdgWmBase = reinterpret_cast<xdg_wm_base*>(wl_registry_bind(registry, name, &xdg_wm_base_interface, 1));
xdg_wm_base_add_listener(window->xdgWmBase, &xdgWmBaseListener, NULL);
} else if (strcmp(interface, zxdg_decoration_manager_v1_interface.name) == 0) {
window->manager = reinterpret_cast<zxdg_decoration_manager_v1*>(wl_registry_bind(registry, name, &zxdg_decoration_manager_v1_interface, 1));
}
}
void WindowWayland::handle_global_remove(void* data, wl_registry* registry, uint32_t name) {
}
void WindowWayland::xdg_toplevel_configure(void*, xdg_toplevel*, std::int32_t, std::int32_t, wl_array*){
}
void WindowWayland::xdg_toplevel_handle_close(void* data, xdg_toplevel*) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
window->onClose.Invoke();
window->open = false;
}
void WindowWayland::xdg_surface_handle_configure(void* data, xdg_surface* xdg_surface, std::uint32_t serial) {
WindowWayland* window = reinterpret_cast<WindowWayland*>(data);
// The compositor configures our surface, acknowledge the configure event
xdg_surface_ack_configure(xdg_surface, serial);
if (window->configured) {
// If this isn't the first configure event we've received, we already
// have a buffer attached, so no need to do anything. Commit the
// surface to apply the configure acknowledgement.
wl_surface_commit(window->surface);
}
window->configured = true;
}

31
interfaces/Crafter.Graphics-Shm.cppm
View file

@ -1,31 +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
*/
module;
#include <stdio.h>
export module Crafter.Graphics:Shm;
import std;
export namespace Crafter {
void randname(char *buf);
int anonymous_shm_open();
int create_shm_file(off_t size);
}

87
interfaces/Crafter.Graphics-Types.cppm
View file

@ -23,8 +23,8 @@ import std;
namespace Crafter { namespace Crafter {
export struct MousePoint { export struct MousePoint {
std::uint_fast32_t x; double x;
std::uint_fast32_t y; double y;
}; };
export struct MouseMoveEvent { export struct MouseMoveEvent {
@ -33,13 +33,6 @@ namespace Crafter {
MousePoint mouseDelta; MousePoint mouseDelta;
}; };
export struct ScaleData {
std::int_fast32_t x;
std::int_fast32_t y;
std::int_fast32_t width;
std::int_fast32_t height;
};
export struct __attribute__((packed)) Pixel_BU8_GU8_RU8_AU8 { export struct __attribute__((packed)) Pixel_BU8_GU8_RU8_AU8 {
std::uint8_t b; std::uint8_t b;
std::uint8_t g; std::uint8_t g;
@ -94,80 +87,4 @@ namespace Crafter {
float b; float b;
float a; float a;
}; };
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 std::int_fast32_t FractionalToMapped(double f) {
return std::int_fast32_t(f * SCALEDOUBLE);
}
export constexpr std::int_fast32_t MappedToPixel(std::int_fast32_t mapped, std::int_fast32_t width) {
return mapped / (SCALE / width);
}
export constexpr double MappedToFractional(std::int_fast32_t mapped) {
return static_cast<double>(mapped) / SCALEDOUBLE;
}
export constexpr std::int_fast32_t PixelToMapped(std::int_fast32_t pixel, std::int_fast32_t width) {
return pixel * (SCALE / width);
}
// export constexpr double bound = 10;
// export constexpr std::uint_fast32_t FractionalToMapped(double fractional) {
// constexpr double min_x = -bound;
// constexpr double max_x = bound + 1.0;
// constexpr double range_x = max_x - min_x;
// constexpr double MAXD = static_cast<double>(
// std::numeric_limits<std::uint_fast32_t>::max()
// );
// // Normalize to [0,1]
// double t = (fractional - min_x) / range_x;
// // Clamp (important for constexpr safety and edge behavior)
// if (t < 0.0) t = 0.0;
// if (t > 1.0) t = 1.0;
// return static_cast<std::uint_fast32_t>(t * MAXD);
// }
// export constexpr double MappedToFractional(std::uint_fast32_t mapped) {
// constexpr double min_x = -bound;
// constexpr double max_x = bound + 1.0;
// constexpr double range_x = max_x - min_x;
// constexpr double MAXD = static_cast<double>(
// std::numeric_limits<std::uint_fast32_t>::max()
// );
// double t = static_cast<double>(mapped) / MAXD;
// return min_x + t * range_x;
// }
// export constexpr std::int_fast32_t MappedToPixel(std::uint_fast32_t mapped, std::uint_fast32_t size) {
// constexpr double MAXD = static_cast<double>(
// std::numeric_limits<std::uint_fast32_t>::max()
// );
// // scale mapped ∈ [0, MAX] to pixel ∈ [0, size]
// double t = static_cast<double>(mapped) / MAXD;
// // Clamp (shouldn't be necessary, but protects constexpr eval)
// if (t < 0.0) t = 0.0;
// if (t > 1.0) t = 1.0;
// return static_cast<std::int_fast32_t>(t * static_cast<double>(size));
// }
export constexpr std::uint_fast32_t PixelToMapped(double pixel, std::uint_fast32_t size) {
return static_cast<std::uint_fast32_t>((pixel / size) * static_cast<double>((std::numeric_limits<std::uint_fast32_t>::max() / 10)));
}
} }

109
interfaces/Crafter.Graphics-UiElement.cppm
View file

@ -1,11 +1,12 @@
/* /*
Crafter®.Graphics Crafter®.Graphics
Copyright (C) 2025 Catcrafts® Copyright (C) 2025 Catcrafts®
catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation; License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -22,31 +23,10 @@ import std;
import Crafter.Event; import Crafter.Event;
import :Types; import :Types;
export namespace Crafter { namespace Crafter {
class Window; export class Font;
class UiElement { export class UiElement {
public: public:
std::int_fast32_t z;
std::int_fast32_t anchorX;
std::int_fast32_t anchorY;
std::int_fast32_t anchorOffsetX;
std::int_fast32_t anchorOffsetY;
std::uint_fast32_t relativeWidth;
std::uint_fast32_t relativeHeight;
bool ignoreScaling;
std::vector<UiElement*> children;
ScaleData scaled;
UiElement(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX = FractionalToMapped(0.5), std::int_fast32_t anchorOffsetY = FractionalToMapped(0.5), std::int_fast32_t z = 0, bool ignoreScaling = false);
UiElement(UiElement&) = delete;
UiElement& operator=(UiElement&) = delete;
// void UpdatePosition(Window& window);
// void UpdatePosition(UiElement& parent);
};
class UiElementMouse {
public:
ScaleData clickArea;
Event<MouseMoveEvent> onMouseMove; Event<MouseMoveEvent> onMouseMove;
Event<MouseMoveEvent> onMouseEnter; Event<MouseMoveEvent> onMouseEnter;
Event<MouseMoveEvent> onMouseLeave; Event<MouseMoveEvent> onMouseLeave;
@ -56,62 +36,33 @@ export namespace Crafter {
Event<MousePoint> onMouseLeftHold; Event<MousePoint> onMouseLeftHold;
Event<MousePoint> onMouseRightRelease; Event<MousePoint> onMouseRightRelease;
Event<MousePoint> onMouseLeftRelease; Event<MousePoint> onMouseLeftRelease;
}; float z;
float anchorX;
class UiElementBuffer { float anchorY;
public: bool useRelativeSize;
std::uint_fast32_t width; bool ignoreScaling;
std::uint_fast32_t height; std::uint32_t bufferWidth;
UiElementBuffer() = default; std::uint32_t bufferHeight;
UiElementBuffer(std::uint_fast32_t width, std::uint_fast32_t height); std::uint32_t absoluteWidth;
virtual void Create(std::uint_fast32_t width, std::uint_fast32_t height) = 0; std::uint32_t absoluteHeight;
virtual void Resize(std::uint_fast32_t width, std::uint_fast32_t height) = 0; float relativeWidth;
virtual void Resize(std::uint_fast32_t width, std::uint_fast32_t height, std::uint_fast32_t offsetX, std::uint_fast32_t offsetY) = 0; float relativeHeight;
virtual void ResizeNearestNeighbour(std::uint_fast32_t width, std::uint_fast32_t height) = 0; float anchorOffsetX;
virtual void ResizeBicubic(std::uint_fast32_t width, std::uint_fast32_t height) = 0; float anchorOffsetY;
virtual void Destroy() = 0;
virtual void Copy(Pixel_BU8_GU8_RU8_AU8* dst) const = 0;
virtual void CopyNearestNeighbour(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const = 0;
virtual void CopyBicubic(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const = 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 const Pixel_BU8_GU8_RU8_AU8* Read() const = 0;
virtual Pixel_BU8_GU8_RU8_AU8* Get() = 0;
virtual void Store() = 0;
};
class UiElementBufferBufferBase : public UiElementBuffer {
public:
std::vector<Pixel_BU8_GU8_RU8_AU8> buffer; std::vector<Pixel_BU8_GU8_RU8_AU8> buffer;
UiElementBufferBufferBase() = default; std::vector<std::unique_ptr<UiElement>> children;
UiElementBufferBufferBase(std::uint_fast32_t width, std::uint_fast32_t height);
void Create(std::uint_fast32_t width, std::uint_fast32_t height) override; UiElement(float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX = 0.5, float anchorOffsetY = 0.5, float z = 0, bool ignoreScaling = false);
void Resize(std::uint_fast32_t width, std::uint_fast32_t height) override; UiElement(float anchorX, float anchorY, std::uint32_t bufferWidth, std::uint32_t bufferHeight, std::uint32_t absoluteWidth, std::uint32_t absoluteHeight, float anchorOffsetX = 0.5, float anchorOffsetY = 0.5, float z = 0, bool ignoreScaling = false);
void Resize(std::uint_fast32_t width, std::uint_fast32_t height, std::uint_fast32_t offsetX, std::uint_fast32_t offsetY) override; UiElement(float anchorX, float anchorY, std::uint32_t bufferWidth, std::uint32_t bufferHeight, float relativeWidth, float relativeHeight, float anchorOffsetX = 0.5, float anchorOffsetY = 0.5, float z = 0, bool ignoreScaling = false);
void ResizeNearestNeighbour(std::uint_fast32_t width, std::uint_fast32_t height) override; UiElement(const std::filesystem::path& image, float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX = 0.5, float anchorOffsetY = 0.5, float z = 0, bool ignoreScaling = false);
void ResizeBicubic(std::uint_fast32_t width, std::uint_fast32_t height) override; UiElement(UiElement&&) noexcept = default;
void Destroy() override; UiElement& operator=(UiElement&&) noexcept = default;
void Copy(Pixel_BU8_GU8_RU8_AU8* dst) const override;
void CopyNearestNeighbour(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const override;
void CopyBicubic(Pixel_BU8_GU8_RU8_AU8* dst, std::uint_fast32_t dstWidth, std::uint_fast32_t dstHeight) const 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;
const Pixel_BU8_GU8_RU8_AU8* Read() const override;
Pixel_BU8_GU8_RU8_AU8* Get() override;
void Store() override;
}; };
class UiElementBufferBuffer : public UiElement, public UiElementBufferBufferBase { export class TextElement : public UiElement {
public: public:
UiElementBufferBuffer(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX = FractionalToMapped(0.5), std::int_fast32_t anchorOffsetY = FractionalToMapped(0.5), std::int_fast32_t z = 0, bool ignoreScaling = false); TextElement(const std::string_view text, float size, Pixel_BU8_GU8_RU8_AU8 color, const Font& font, float anchorX, float anchorY, float relativeWidth, float relativeHeight, float anchorOffsetX = 0.5, float anchorOffsetY = 0.5, float z = 0, bool ignoreScaling = false);
UiElementBufferBuffer(std::uint_fast32_t width, std::uint_fast32_t height, std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX = FractionalToMapped(0.5), std::int_fast32_t anchorOffsetY = FractionalToMapped(0.5), std::int_fast32_t z = 0, bool ignoreScaling = false); void RenderText(const std::string_view text, float size, Pixel_BU8_GU8_RU8_AU8 color, const Font& font);
};
class UiElementBufferMouseBuffer : public UiElementBufferBuffer, public UiElementMouse {
public:
UiElementBufferMouseBuffer(std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX = FractionalToMapped(0.5), std::int_fast32_t anchorOffsetY = FractionalToMapped(0.5), std::int_fast32_t z = 0, bool ignoreScaling = false);
UiElementBufferMouseBuffer(std::uint_fast32_t width, std::uint_fast32_t height, std::int_fast32_t anchorX, std::int_fast32_t anchorY, std::uint_fast32_t relativeWidth, std::uint_fast32_t relativeHeight, std::int_fast32_t anchorOffsetX = FractionalToMapped(0.5), std::int_fast32_t anchorOffsetY = FractionalToMapped(0.5), std::int_fast32_t z = 0, bool ignoreScaling = false);
}; };
} }

207
interfaces/Crafter.Graphics-Window.cppm
View file

@ -1,11 +1,12 @@
/* /*
Crafter®.Graphics Crafter®.Graphics
Copyright (C) 2025 Catcrafts® Copyright (C) 2025 Catcrafts®
catcrafts.net Catcrafts.net
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License version 3.0 as published by the Free Software Foundation; License as published by the Free Software Foundation; either
version 3.0 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -16,66 +17,31 @@ You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
module; module;
#ifdef CRAFTER_GRAPHICS_WAYLAND #include <wayland-client.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <linux/input-event-codes.h>
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include "../lib/xdg-shell-client-protocol.h" #include "../lib/xdg-shell-client-protocol.h"
#include "../lib/wayland-xdg-decoration-unstable-v1-client-protocol.h" #include "../lib/wayland-xdg-decoration-unstable-v1-client-protocol.h"
#include <string.h>
#include <linux/input.h>
#include <sys/mman.h>
#include <wayland-cursor.h>
#include <xkbcommon/xkbcommon.h>
#include <errno.h>
#include <fcntl.h>
#include <print>
#include <wayland-client.h>
#include <wayland-client-protocol.h>
#endif
export module Crafter.Graphics:Window; export module Crafter.Graphics:Window;
import std; import std;
import :Types;
import Crafter.Event; import Crafter.Event;
import :UiElement;
import :Types;
export namespace Crafter { export namespace Crafter {
class UiElement; struct ScaleData {
std::int32_t x;
std::int32_t y;
std::int32_t width;
std::int32_t height;
};
class Window { class Window {
public: public:
Event<void> onClose; Pixel_BU8_GU8_RU8_AU8* framebuffer = nullptr;
Event<std::chrono::time_point<std::chrono::high_resolution_clock>> onUpdate;
bool open = true;
bool updating = false;
Window() = default;
Window(Window&) = delete;
Window(Window&&) = delete;
virtual ~Window() = default;
Window& operator=(const Window&) = delete;
virtual void StartSync() = 0;
virtual void StartUpdate() = 0;
virtual void StopUpdate() = 0;
ScaleData ScaleElement(const UiElement& element);
};
class WindowKeyboard {
public:
bool heldkeys[255] = {};
Event<void> onKeyDown[255];
Event<void> onKeyHold[255];
Event<void> onKeyUp[255];
Event<char> onAnyKeyDown;
Event<char> onAnyKeyHold;
Event<char> onAnyKeyUp;
};
class UiElementMouse;
class WindowMouse {
public:
Event<MousePoint> onMouseRightClick; Event<MousePoint> onMouseRightClick;
Event<MousePoint> onMouseLeftClick; Event<MousePoint> onMouseLeftClick;
Event<MousePoint> onMouseRightHold; Event<MousePoint> onMouseRightHold;
@ -85,74 +51,53 @@ export namespace Crafter {
Event<MouseMoveEvent> onMouseMove; Event<MouseMoveEvent> onMouseMove;
Event<MouseMoveEvent> onMouseEnter; Event<MouseMoveEvent> onMouseEnter;
Event<MouseMoveEvent> onMouseLeave; Event<MouseMoveEvent> onMouseLeave;
Event<std::uint_fast32_t> onMouseScroll; Event<double> onMouseScroll;
Event<void> onClose;
MousePoint currentMousePos; MousePoint currentMousePos;
MousePoint lastMousePos; MousePoint lastMousePos;
MousePoint mouseDelta; MousePoint mouseDelta;
bool mouseLeftHeld = false; bool mouseLeftHeld = false;
bool mouseRightHeld = false; bool mouseRightHeld = false;
std::vector<UiElementMouse*> mouseElements; bool heldkeys[255] = {};
}; Event<void> onKeyDown[255];
Event<void> onKeyHold[255];
Event<void> onKeyUp[255];
Event<char> onAnyKeyDown;
Event<char> onAnyKeyHold;
Event<char> onAnyKeyUp;
std::vector<UiElement> elements;
std::string name;
std::uint32_t width;
std::uint32_t height;
float scale = 1;
bool open = true;
class WindowTitle { Window(std::string name, std::uint32_t width, std::uint32_t height);
public: ~Window();
virtual void SetTitle(const std::string_view title) = 0; void StartSync();
}; ScaleData ScaleElement(const UiElement& element);
class WindowFramebuffer { protected:
public:
std::uint_fast32_t width;
std::uint_fast32_t height;
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;
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 const Pixel_BU8_GU8_RU8_AU8* Read() const = 0;
virtual Pixel_BU8_GU8_RU8_AU8* Get() = 0;
virtual void Store() = 0;
virtual void Render() = 0;
ScaleData ScaleElementAbsolute(const UiElement& element);
};
#ifdef CRAFTER_GRAPHICS_WAYLAND
class UiElementBufferBuffer;
class WindowWayland final: public Window, public WindowKeyboard, public WindowMouse, public WindowFramebuffer, public WindowTitle {
public:
Pixel_BU8_GU8_RU8_AU8* framebuffer = nullptr;
std::vector<UiElementBufferBuffer*> elements;
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();
bool configured = false; bool configured = false;
wl_shm* shm = nullptr; wl_shm* shm = NULL;
wl_seat* seat = nullptr; wl_seat* seat = NULL;
xdg_toplevel* xdgToplevel = nullptr; xdg_toplevel* xdgToplevel = NULL;
xdg_wm_base* xdgWmBase = nullptr; xdg_wm_base* xdgWmBase = NULL;
zxdg_decoration_manager_v1* manager = nullptr; zxdg_decoration_manager_v1* manager = NULL;
wl_surface* surface = nullptr; wl_surface* surface = NULL;
wl_buffer* buffer = nullptr; wl_buffer* buffer = NULL;
wl_buffer* backBuffer = nullptr; wl_buffer* backBuffer = NULL;
xdg_surface* xdgSurface = nullptr; xdg_surface* xdgSurface = NULL;
wl_display* display = nullptr; wl_display* display = NULL;
wl_callback* cb = nullptr; wl_callback* cb = nullptr;
xkb_keymap* xkb_keymap; inline static wl_compositor* compositor = NULL;
xkb_context* xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS); static wl_pointer_listener pointer_listener;
xkb_state* xkb_state; static wl_keyboard_listener keyboard_listener;
void Render() override; static wl_seat_listener seat_listener;
void StartSync() override; static wl_registry_listener registry_listener;
void StartUpdate() override; static xdg_surface_listener xdg_surface_listener;
void StopUpdate() override; static xdg_toplevel_listener xdg_toplevel_listener;
void SetTitle(const std::string_view title) override; static wl_callback_listener surface_frame_listener;
void Resize(std::uint_fast32_t width, std::uint_fast32_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;
const Pixel_BU8_GU8_RU8_AU8* Read() const override;
Pixel_BU8_GU8_RU8_AU8* Get() override;
void Store() override;
inline static wl_compositor* compositor = nullptr;
static void wl_surface_frame_done(void *data, wl_callback *cb, uint32_t time); static void wl_surface_frame_done(void *data, wl_callback *cb, uint32_t time);
static void PointerListenerHandleMotion(void* data, wl_pointer* wl_pointer, uint time, wl_fixed_t surface_x, wl_fixed_t surface_y); static void PointerListenerHandleMotion(void* data, wl_pointer* wl_pointer, uint time, wl_fixed_t surface_x, wl_fixed_t surface_y);
static void PointerListenerHandleAxis(void*, wl_pointer*, std::uint32_t, std::uint32_t, wl_fixed_t value); static void PointerListenerHandleAxis(void*, wl_pointer*, std::uint32_t, std::uint32_t, wl_fixed_t value);
@ -163,51 +108,5 @@ export namespace Crafter {
static void pointer_handle_button(void* data, wl_pointer* pointer, std::uint32_t serial, std::uint32_t time, std::uint32_t button, std::uint32_t state); static void pointer_handle_button(void* data, wl_pointer* pointer, std::uint32_t serial, std::uint32_t time, std::uint32_t button, std::uint32_t state);
static void seat_handle_capabilities(void* data, wl_seat* seat, uint32_t capabilities); static void seat_handle_capabilities(void* data, wl_seat* seat, uint32_t capabilities);
static void xdg_surface_handle_configure(void* data, xdg_surface* xdg_surface, std::uint32_t serial); static void xdg_surface_handle_configure(void* data, xdg_surface* xdg_surface, std::uint32_t serial);
static void xdg_wm_base_handle_ping(void* data, xdg_wm_base* xdg_wm_base, std::uint32_t serial);
static void keyboard_keymap(void* data, wl_keyboard* keyboard, uint32_t format, int fd, uint32_t size);
static void keyboard_enter(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface, wl_array *keys);
static void keyboard_leave(void *data, wl_keyboard *keyboard, uint32_t serial, wl_surface *surface);
static void keyboard_key(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key, uint32_t state);
static void keyboard_modifiers(void *data, wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group);
static void keyboard_repeat_info(void *data, wl_keyboard *keyboard, int32_t rate, int32_t delay);
static void handle_global_remove(void* data, wl_registry* registry, uint32_t name);
static void xdg_toplevel_configure(void*, xdg_toplevel*, std::int32_t, std::int32_t, wl_array*);
constexpr static wl_pointer_listener pointer_listener = {
.enter = PointerListenerHandleEnter,
.leave = PointerListenerHandleLeave,
.motion = PointerListenerHandleMotion,
.button = pointer_handle_button,
.axis = PointerListenerHandleAxis,
}; };
constexpr static wl_keyboard_listener keyboard_listener = {
.keymap = keyboard_keymap,
.enter = keyboard_enter,
.leave = keyboard_leave,
.key = keyboard_key,
.modifiers = keyboard_modifiers,
.repeat_info = keyboard_repeat_info,
};
constexpr static wl_seat_listener seat_listener = {
.capabilities = seat_handle_capabilities,
};
constexpr static wl_registry_listener registry_listener = {
.global = handle_global,
.global_remove = handle_global_remove,
};
constexpr static xdg_toplevel_listener xdg_toplevel_listener = {
.configure = xdg_toplevel_configure,
.close = xdg_toplevel_handle_close,
};
constexpr static wl_callback_listener wl_callback_listener = {
.done = wl_surface_frame_done,
};
constexpr static xdg_wm_base_listener xdgWmBaseListener = {
.ping = xdg_wm_base_handle_ping,
};
constexpr static xdg_surface_listener xdg_surface_listener = {
.configure = xdg_surface_handle_configure,
};
};
#endif
} }

1
interfaces/Crafter.Graphics.cppm
View file

@ -24,7 +24,6 @@ export import :Window;
export import :UiElement; export import :UiElement;
export import :Types; export import :Types;
export import :Font; export import :Font;
export import :Shm;
// export import :WindowWaylandVulkan; // export import :WindowWaylandVulkan;
// export import :VulkanBuffer; // export import :VulkanBuffer;

58
project.json
View file

@ -3,22 +3,66 @@
"configurations": [ "configurations": [
{ {
"name": "base", "name": "base",
"implementations": ["implementations/Crafter.Graphics-Font", "implementations/Crafter.Graphics-Shm", "implementations/Crafter.Graphics-UiElement", "implementations/Crafter.Graphics-UiElementBufferBuffer", "implementations/Crafter.Graphics-UiElementBufferBufferBase", "implementations/Crafter.Graphics-UiElementBufferMouseBuffer"], "implementations": ["implementations/Crafter.Graphics-Window", "implementations/Crafter.Graphics-UiElement", "implementations/Crafter.Graphics-Font"],
"interfaces": ["interfaces/Crafter.Graphics-Window", "interfaces/Crafter.Graphics", "interfaces/Crafter.Graphics-Types", "interfaces/Crafter.Graphics-Font", "interfaces/Crafter.Graphics-Shm", "interfaces/Crafter.Graphics-UiElement"], "interfaces": ["interfaces/Crafter.Graphics-Window", "interfaces/Crafter.Graphics", "interfaces/Crafter.Graphics-UiElement", "interfaces/Crafter.Graphics-Types", "interfaces/Crafter.Graphics-Font"],
"type": "library" "type": "library"
}, },
{ {
"name": "wayland", "name": "wayland",
"implementations": ["implementations/Crafter.Graphics-Window_wayland"], "implementations": [],
"interfaces": [], "interfaces": [],
"libs": ["wayland-client", "xkbcommon"], "libs": ["wayland-client", "xkbcommon"],
"c_files": ["lib/xdg-shell-protocol", "lib/wayland-xdg-decoration-unstable-v1-client-protocol"], "c_files": ["lib/xdg-shell-protocol", "lib/wayland-xdg-decoration-unstable-v1-client-protocol"],
"extends": ["base"], "extends": ["base"]
"defines": [ },
{ {
"name": "CRAFTER_GRAPHICS_WAYLAND" "name": "vulkan",
"implementations": ["implementations/Crafter.Graphics-VulkanDevice", "implementations/Crafter.Graphics-WindowWaylandVulkan"],
"interfaces": ["interfaces/Crafter.Graphics-WindowWayland", "interfaces/Crafter.Graphics-WindowWaylandWayland", "interfaces/Crafter.Graphics-VulkanDevice", "interfaces/Crafter.Graphics-VulkanPipeline", "interfaces/Crafter.Graphics-VulkanShader", "interfaces/Crafter.Graphics-WindowWaylandVulkan", "interfaces/Crafter.Graphics-VulkanBuffer", "interfaces/Crafter.Graphics-Mesh", "interfaces/Crafter.Graphics-MeshShader", "interfaces/Crafter.Graphics-HeightmapShader","interfaces/Crafter.Graphics-VoxelShader", "interfaces/Crafter.Graphics-VulkanTexture", "interfaces/Crafter.Graphics-TextureShader", "interfaces/Crafter.Graphics-DescriptorSet"],
"libs": ["vulkan"],
"shaders": [
{
"path":"src/shader/MeshShaderXYZ.glsl",
"type":13,
"entrypoint":"main"
},
{
"path":"src/shader/MeshShaderXYZUV.glsl",
"type":13,
"entrypoint":"main"
},
{
"path":"src/shader/MeshShaderXYZRGBA.glsl",
"type":13,
"entrypoint":"main"
},
{
"path":"src/shader/MeshShaderHeightmapRGBA.glsl",
"type":13,
"entrypoint":"main"
},
{
"path":"src/shader/MeshShaderMixedVoxelGrid.glsl",
"type":13,
"entrypoint":"main"
},
{
"path":"src/shader/FragmentShaderSolidWhite.glsl",
"type":4,
"entrypoint":"main"
},
{
"path":"src/shader/FragmentShaderTexture.glsl",
"type":4,
"entrypoint":"main"
},
{
"path":"src/shader/FragmentShaderVertexColor.glsl",
"type":4,
"entrypoint":"main"
} }
] ],
"extends": ["wayland"]
}, },
{ {
"name": "deps", "name": "deps",