veclavtalica/brightstone
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

many things, cosmo build!

Browse Source
This commit is contained in:
veclavtlica
2026-10-12 21:12:47 +03:00
parent ba4131abbf
commit 8d2bb5575e
29 changed files with 699 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Player/Display/x11.c
+190 -111
View File
@@ -1,6 +1,3 @@
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <fcntl.h>
#include <stdbool.h>
#include <stdint.h>
@@ -11,16 +8,26 @@
#include "../../Common/bits.h"
#include "../../Common/buf.h"
#include "../../Common/cfg.h"
#include "../../Common/def.h"
#include "../../Common/lzw.h"
#include "../../Common/mat.h"
#include "../../Common/std.h"
#include "../../Common/str.h"
#include "../../Common/test.h"
#include "../draw.h"
#include "display.h"
/* https://hereket.com/posts/from-scratch-x11-windowing/ */
/* https://gaultier.github.io/blog/write_a_video_game_from_scratch_like_1987.html
*/
#if COM_DEF_TARGET == COM_DEF_TARGET_COSMO
#include <X.h>
#else
#include <X11/X.h>
#endif
/*
https://hereket.com/posts/from-scratch-x11-windowing/
https://gaultier.github.io/blog/write_a_video_game_from_scratch_like_1987.html
https://xorg.freedesktop.org/archive/X11R7.7-RC1/doc/xproto/x11protocol.html
*/
static struct {
uint32_t id;
@@ -94,7 +101,7 @@ static struct plr_x11_auth_entry {
result.success = true;
return result;
BREAK:
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return result;
}
@@ -108,8 +115,8 @@ static bool plr_x11_handshake(com_std_fd xfd,
uint16_t auth_len;
uint16_t auth_data_len;
uint16_t pad1;
} request = {
.endianness = 'l',
} __attribute__((packed)) request = {
.endianness = COM_DEF_CPU_LITEND ? 'l' : 'B',
.major_version = 11,
.auth_len = sizeof(AUTH_ENTRY_MAGIC_COOKIE) - 1, // IS -1 NEEDED?
.auth_data_len = auth_entry.auth_data->len,
@@ -131,7 +138,7 @@ static bool plr_x11_handshake(com_std_fd xfd,
uint16_t major_version;
uint16_t minor_version;
uint16_t length;
} response;
} __attribute__((packed)) response;
if (!com_std_read(xfd, &response, sizeof response))
return false;
@@ -154,7 +161,7 @@ static bool plr_x11_handshake(com_std_fd xfd,
uint8_t min_keycode;
uint8_t max_keycode;
uint32_t pad2;
} dyn_response;
} __attribute__((packed)) dyn_response;
if (!com_std_read(xfd, &dyn_response, sizeof dyn_response))
return false;
@@ -177,6 +184,54 @@ static bool plr_x11_handshake(com_std_fd xfd,
return true;
}
/* TODO: Instead have a poll_events function instead. */
static inline bool plr_x11_poll_errors(com_std_fd xfd) {
union {
struct {
uint8_t type;
uint8_t errcode;
uint16_t sequenceid;
uint32_t badval;
uint16_t minorop;
uint32_t majorop;
char pad[18];
} __attribute__((packed)) error;
struct {
uint8_t type;
uint8_t data;
uint16_t sequenceid;
uint32_t length;
char pad[24];
} __attribute__((packed)) reply;
} response;
while (com_std_has_data(xfd)) {
if (!com_std_read(xfd, &response, sizeof response))
return false;
/* Exhaust variable length data of reply. */
if (response.reply.type == 1) {
char buf[1024];
com_std_assert(response.reply.length * 4 <= sizeof buf);
if (!com_std_read(xfd, &buf, response.reply.length * 4))
return false;
}
if (response.reply.type == 0 && response.error.errcode != 0) {
com_std_print('c', "X11 error code=", 'u', response.error.errcode, 'c',
" for seqid=", 'u', response.error.sequenceid);
/* This means X11 closed the connection. */
// if (response.error.errcode == 0)
// return false;
}
/* TODO: Save polled events, as they might be used later. */
};
return true;
}
static inline uint32_t plr_x11_next_id(void) {
static uint32_t cur_id = 0;
cur_id = 1 + ((plr_x11_connection.resource_id_mask & (cur_id)) |
@@ -184,29 +239,35 @@ static inline uint32_t plr_x11_next_id(void) {
return cur_id;
}
/* Used to number requests. */
static inline uint32_t plr_x11_next_seqid(void) {
static uint32_t cur_id = 1;
return cur_id++;
}
static uint32_t plr_x11_create_graphical_context(com_std_fd xfd) {
uint32_t const gc_id = plr_x11_next_id();
uint32_t const seq = plr_x11_next_seqid();
struct {
uint8_t opcode;
uint8_t pad1;
uint16_t length;
uint16_t request_length;
uint32_t id;
uint32_t drawable;
uint32_t bitmask;
uint32_t value1;
} request = {
} __attribute__((packed)) request = {
.opcode = 55,
.length = 5,
.request_length = sizeof request / 4,
.id = gc_id,
.drawable = plr_x11_root_screen.id,
.bitmask = 8, /* TODO: Figure out. */
.value1 = 0x0000ff00,
.value1 = 0x00000000,
};
if (com_std_write(xfd, &request, sizeof request))
return gc_id;
else
if (!com_std_write(xfd, &request, sizeof request))
return 0;
return gc_id;
}
static uint32_t plr_x11_create_window(com_std_fd xfd) {
@@ -220,6 +281,7 @@ static uint32_t plr_x11_create_window(com_std_fd xfd) {
#define EVENT_FLAG_BUTTON_RELEASE 0x8
uint32_t const window_id = plr_x11_next_id();
uint32_t const seq = plr_x11_next_seqid();
struct {
uint8_t opcode;
uint8_t depth;
@@ -236,10 +298,10 @@ static uint32_t plr_x11_create_window(com_std_fd xfd) {
uint32_t bitmask;
uint32_t value1;
uint32_t value2;
} request = {
} __attribute__((packed)) request = {
.opcode = 1,
.depth = 32,
.request_length = 8 + 2,
.depth = COM_CFG_COLORS * 8,
.request_length = sizeof request / 4,
.window_id = window_id,
.parent_id = plr_x11_root_screen.id,
.width = COM_CFG_WIDTH,
@@ -248,16 +310,15 @@ static uint32_t plr_x11_create_window(com_std_fd xfd) {
.class = 1,
.root_visual_id = plr_x11_root_screen.root_visual_id,
.bitmask = FLAG_WIN_BG_PIXEL | FLAG_WIN_EVENT,
.value1 = 0x00ffff00,
.value1 = 0x00000000,
.value2 = EVENT_FLAG_EXPOSURE | EVENT_FLAG_BUTTON_RELEASE |
EVENT_FLAG_BUTTON_PRESS | EVENT_FLAG_KEY_PRESS |
EVENT_FLAG_KEY_RELEASE,
};
if (com_std_write(xfd, &request, sizeof request))
return window_id;
else
if (!com_std_write(xfd, &request, sizeof request))
return 0;
return window_id;
}
static bool plr_x11_show_window(com_std_fd xfd, uint32_t window_id) {
@@ -266,9 +327,9 @@ static bool plr_x11_show_window(com_std_fd xfd, uint32_t window_id) {
uint8_t pad1;
uint16_t request_length;
uint32_t window_id;
} request = {
} __attribute__((packed)) request = {
.opcode = 8,
.request_length = 2,
.request_length = sizeof request / 4,
.window_id = window_id,
};
return com_std_write(xfd, &request, sizeof request);
@@ -276,36 +337,35 @@ static bool plr_x11_show_window(com_std_fd xfd, uint32_t window_id) {
static uint32_t plr_x11_create_pixmap(com_std_fd xfd, uint32_t window_id) {
uint32_t const pixmap_id = plr_x11_next_id();
uint32_t const seq = plr_x11_next_seqid();
struct {
uint8_t opcode;
uint8_t depth;
uint16_t length;
uint16_t request_length;
uint32_t pixmap_id;
uint32_t drawable;
uint16_t width;
uint16_t height;
} request = {
} __attribute__((packed)) request = {
.opcode = 53,
.depth = 32,
.length = 4,
.depth = COM_CFG_COLORS * 8,
.request_length = sizeof request / 4,
.pixmap_id = pixmap_id,
.drawable = window_id,
.width = COM_CFG_WIDTH,
.height = COM_CFG_HEIGHT,
};
if (com_std_write(xfd, &request, sizeof request))
return pixmap_id;
else
if (!com_std_write(xfd, &request, sizeof request))
return 0;
return pixmap_id;
}
static bool
plr_x11_put_framebuffer(com_std_fd xfd, uint32_t gc_id, uint32_t window_id,
uint32_t pixmap_id,
uint32_t pixels[COM_CFG_WIDTH * COM_CFG_HEIGHT]) {
uint32_t const padded =
com_bits_nalign(4 * COM_CFG_WIDTH * COM_CFG_HEIGHT, 4);
static bool plr_x11_put_framebuffer(com_std_fd xfd, uint32_t gc_id,
uint32_t pixmap_id,
uint8_t pixels[COM_CFG_FBSIZE]) {
uint32_t const seq = plr_x11_next_seqid();
uint32_t const padded = com_bits_nalign(COM_CFG_FBSIZE, 4);
struct {
uint8_t opcode;
@@ -320,35 +380,84 @@ plr_x11_put_framebuffer(com_std_fd xfd, uint32_t gc_id, uint32_t window_id,
uint8_t left_pad;
uint8_t depth;
uint16_t pad1;
} request = {
} __attribute__((packed)) request = {
.opcode = 72,
.format = 2, // ZPixmap
.request_length = 6 + padded / 4,
.request_length = sizeof request / 4 + padded / 4,
.drawable_id = pixmap_id,
.gc_id = gc_id,
.width = COM_CFG_WIDTH,
.height = COM_CFG_HEIGHT,
.dst_x = 0,
.dst_y = 0,
.depth = 32,
.depth = COM_CFG_COLORS * 8,
};
if (!com_std_write(xfd, &request, sizeof request))
return false;
if (!com_std_write(xfd, pixels, 4 * COM_CFG_WIDTH * COM_CFG_HEIGHT))
if (!com_std_write(xfd, pixels, COM_CFG_FBSIZE))
return false;
/* Use request memory for pad, it doesn't matter what we write. */
uint32_t const padfinal = padded - (4 * COM_CFG_WIDTH * COM_CFG_HEIGHT);
if (padfinal && !com_std_write(xfd, &request, padfinal))
uint32_t const padfinal = padded - COM_CFG_FBSIZE;
if (padfinal && !com_std_write(xfd, &pixels, padfinal))
return false;
return true;
}
static bool plr_x11_establish_connection(com_std_fd xfd, int argc,
char const *const *argv) {
com_buf_make_on_stack(char, xauthbuf, 1024, 0);
/* First we need to authenticate X11 connection, which requires some funk.
*/
/* We assume that $XAUTHORITY is set and I hope it is true. */
char const *xauthpath = NULL;
for (char const *const *envp = &argv[argc + 1]; *envp != NULL; ++envp) {
static const struct com_str xauthlit = com_str_lit("XAUTHORITY=");
if (com_str_ext_prefixed(*envp, xauthlit)) {
xauthpath = &((*envp)[xauthlit.len]);
break;
}
}
/* Open it and parse. */
com_std_fd const xauthfd = com_std_open(xauthpath, COM_STD_OPEN_READ);
if (xauthfd < 0) {
com_std_print('c', "Failure to initialize X11");
return false;
}
struct com_bin xauthbin = {
.ctx = (void *)(int64_t)xauthfd,
.flags = COM_BIN_BIG_ENDIAN,
.interface = {.readn = fileread, .skipn = fileskip}};
/* Loop over auth entries until we find magic cookie one. */
struct plr_x11_auth_entry auth_entry;
do {
com_buf_clear(xauthbuf);
auth_entry = plr_x11_read_auth_entry(&xauthbin, xauthbuf);
} while (auth_entry.success && auth_entry.family != 256);
if (!auth_entry.success) {
com_std_print('c', "Failure to initialize X11");
return false;
}
com_std_close(xauthfd);
/* TODO: Check for auth_entry.name == MAGIC ? */
if (!plr_x11_handshake(xfd, auth_entry)) {
com_std_print('c', "Failure to initialize X11");
return false;
}
com_buf_free(xauthbuf);
return true;
}
static uint32_t pixel_buffer[COM_CFG_WIDTH * COM_CFG_HEIGHT];
// TODO: correct error handling.
extern int plr_display_x11_main(int argc, char *argv[]) {
extern int plr_display_x11_main(int argc, char const *const *argv) {
char test_string[] = "what is this?";
char *compressed_string = NULL;
uint32_t compressed_string_sz = 0;
@@ -366,12 +475,16 @@ extern int plr_display_x11_main(int argc, char *argv[]) {
com_mat_t t0 = com_mat_mul(m1, m0);
com_mat_t t1 = com_mat_mul_reodered(com_mat_reoder(m1), m0);
com_fix_print(t0.a[4]);
com_fix_print(t1.a[4]);
com_std_print('f', t0.a[4]);
com_std_print('f', t1.a[4]);
// com_vec_t v0 = com_mat_vec_project(com_mat_reoder(m0), com_vec_identity());
// com_fix_print(v0.a[0]);
#ifndef NDEBUG
com_test_run();
#endif
// com_fix_run_tests();
// com_fix_run_bench();
// com_mat_run_bench();
@@ -380,87 +493,47 @@ extern int plr_display_x11_main(int argc, char *argv[]) {
/* Open X11 socket for communication. */
com_std_fd const xfd = com_std_socket(false);
if (!xfd) {
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return -1;
}
if (!com_std_connect(xfd, false, "/tmp/.X11-unix/X0")) {
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return -1;
}
/* First we need to authenticate X11 connection, which requires some funk. */
/* We assume that $XAUTHORITY is set and I hope it is true. */
char const *xauthpath = NULL;
for (char **envp = &argv[argc + 1]; *envp != NULL; ++envp) {
static const struct com_str xauthlit = com_str_lit("XAUTHORITY=");
if (com_str_ext_prefixed(*envp, xauthlit)) {
xauthpath = &((*envp)[xauthlit.len]);
break;
}
}
/* Open it and parse. */
com_std_fd const xauthfd = com_std_open(xauthpath, COM_STD_OPEN_READ);
if (xauthfd < 0) {
com_std_printf("Failure to initialize X11\n");
if (!plr_x11_establish_connection(xfd, argc, argv)) {
com_std_print('c', "Failure to initialize X11");
return -1;
}
com_buf_make_on_stack(char, xauthbuf, 1024, 0);
struct com_bin xauthbin = {
.ctx = (void *)(int64_t)xauthfd,
.flags = COM_BIN_BIG_ENDIAN,
.interface = {.readn = fileread, .skipn = fileskip}};
/* Loop over auth entries until we find magic cookie one. */
struct plr_x11_auth_entry auth_entry;
do {
com_buf_clear(xauthbuf);
auth_entry = plr_x11_read_auth_entry(&xauthbin, xauthbuf);
} while (auth_entry.success && auth_entry.family != 256);
if (!auth_entry.success) {
com_std_printf("Failure to initialize X11\n");
return -1;
}
com_std_close(xauthfd);
/* TODO: Check for auth_entry.name == MAGIC ? */
if (!plr_x11_handshake(xfd, auth_entry)) {
com_std_printf("Failure to initialize X11\n");
return -1;
}
com_buf_free(xauthbuf);
uint32_t const gc = plr_x11_create_graphical_context(xfd);
if (!gc) {
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return -1;
}
uint32_t const win = plr_x11_create_window(xfd);
if (!win) {
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return -1;
}
uint32_t const fb = plr_x11_create_pixmap(xfd, win);
if (!fb) {
com_std_printf("Failure to initialize X11\n");
com_std_print('c', "Failure to initialize X11");
return -1;
}
// Display *display = XOpenDisplay(NULL);
// if (NULL == display) {
// com_std_printf("Failed to initialize display");
// com_std_print('c', "Failed to initialize display");
// return -1;
// }
// Window root = DefaultRootWindow(display);
// if (None == root) {
// com_std_printf("No root window found");
// com_std_print('c', "No root window found");
// XCloseDisplay(display);
// return -1;
// }
@@ -473,7 +546,7 @@ extern int plr_display_x11_main(int argc, char *argv[]) {
// XCreateSimpleWindow(display, root, 0, 0, WIDTH, HEIGHT, 0, 0,
// 0xffffffff);
// if (None == window) {
// com_std_printf("Failed to create window");
// com_std_print('c', "Failed to create window");
// XCloseDisplay(display);
// return -1;
// }
@@ -507,7 +580,7 @@ extern int plr_display_x11_main(int argc, char *argv[]) {
// pixel_buffer, WIDTH, HEIGHT, 32, 0);
// if (!ximage) {
// com_std_printf("Failed to create XImage\n");
// com_std_print('c', "Failed to create XImage");
// // com_std_alloc(pixel_buffer, 0);
// XCloseDisplay(display);
// return -1;
@@ -547,16 +620,22 @@ extern int plr_display_x11_main(int argc, char *argv[]) {
// XCloseDisplay(display);
uint8_t *fbm = plr_draw_get_pixel_buffer();
plr_draw_screen(fbm);
// if (!plr_x11_put_framebuffer(xfd, gc, fb, fbm)) {
// com_std_print('c', "Failure to drive X11");
// return -1;
// }
if (!plr_x11_show_window(xfd, win)) {
com_std_print('c', "Failure to drive X11");
return -1;
}
while (1) {
plr_draw_screen((uint8_t *)pixel_buffer);
if (!plr_x11_put_framebuffer(xfd, gc, win, fb, pixel_buffer)) {
com_std_printf("Failure to drive X11\n");
return -1;
}
if (!plr_x11_show_window(xfd, win)) {
com_std_printf("Failure to drive X11\n");
if (!plr_x11_poll_errors(xfd)) {
com_std_print('c', "X11 closed connection");
return -1;
}
}