stream world data from pxl8d to pxl8

src/net/pxl8_net.c

@@ -1,4 +1,6 @@
 #include "pxl8_net.h"
+#include "pxl8_chunk_cache.h"
+#include "pxl8_log.h"
 #include "pxl8_mem.h"
 
 #include <stdlib.h>
@@ -28,6 +30,9 @@
 
 struct pxl8_net {
     char address[256];
+    u32 chunk_id;
+    u8 chunk_type;
+    pxl8_chunk_cache* chunk_cache;
     bool connected;
     pxl8_entity_state entities[PXL8_MAX_SNAPSHOT_ENTITIES];
     pxl8_event_msg events[PXL8_MAX_SNAPSHOT_EVENTS];
@@ -36,7 +41,6 @@ struct pxl8_net {
     u64 input_head;
     u64 input_oldest_tick;
     f32 interp_time;
-    pxl8_net_mode mode;
     u16 port;
     u8 predicted_state[PXL8_NET_USERDATA_SIZE];
     u64 predicted_tick;
@@ -98,7 +102,6 @@ pxl8_net* pxl8_net_create(const pxl8_net_config* config) {
     pxl8_net* net = pxl8_calloc(1, sizeof(pxl8_net));
     if (!net) return NULL;
 
-    net->mode = config->mode;
     net->port = config->port ? config->port : PXL8_NET_DEFAULT_PORT;
     net->sock = INVALID_SOCK;
     net->connected = false;
@@ -209,6 +212,32 @@ bool pxl8_net_poll(pxl8_net* net) {
 
     pxl8_msg_header hdr;
     usize offset = pxl8_protocol_deserialize_header(net->recv_buf, len, &hdr);
+
+    if (hdr.type == PXL8_MSG_CHUNK) {
+        if (!net->chunk_cache) return false;
+
+        pxl8_chunk_msg_header chunk_hdr;
+        offset += pxl8_protocol_deserialize_chunk_msg_header(net->recv_buf + offset, len - offset, &chunk_hdr);
+
+        const u8* payload = net->recv_buf + offset;
+        usize payload_len = chunk_hdr.payload_size;
+        if (payload_len > len - offset) {
+            payload_len = len - offset;
+        }
+
+        pxl8_chunk_cache_receive(net->chunk_cache, &chunk_hdr, payload, payload_len);
+        return true;
+    }
+
+    if (hdr.type == PXL8_MSG_CHUNK_ENTER) {
+        pxl8_chunk_enter_msg chunk_msg;
+        pxl8_protocol_deserialize_chunk_enter(net->recv_buf + offset, len - offset, &chunk_msg);
+        net->chunk_id = chunk_msg.chunk_id;
+        net->chunk_type = chunk_msg.chunk_type;
+        pxl8_debug("[CLIENT] Received CHUNK_ENTER type=%u id=%u", chunk_msg.chunk_type, chunk_msg.chunk_id);
+        return true;
+    }
+
     if (hdr.type != PXL8_MSG_SNAPSHOT) return false;
 
     pxl8_snapshot_header snap;
@@ -311,3 +340,23 @@ void pxl8_net_update(pxl8_net* net, f32 dt) {
     if (!net) return;
     net->interp_time += dt;
 }
+
+void pxl8_net_set_chunk_cache(pxl8_net* net, pxl8_chunk_cache* cache) {
+    if (!net) return;
+    net->chunk_cache = cache;
+}
+
+pxl8_chunk_cache* pxl8_net_chunk_cache(pxl8_net* net) {
+    if (!net) return NULL;
+    return net->chunk_cache;
+}
+
+u32 pxl8_net_chunk_id(const pxl8_net* net) {
+    if (!net) return 0;
+    return net->chunk_id;
+}
+
+u8 pxl8_net_chunk_type(const pxl8_net* net) {
+    if (!net) return PXL8_CHUNK_TYPE_VXL;
+    return net->chunk_type;
+}

src/net/pxl8_net.h

@@ -11,15 +11,10 @@ extern "C" {
 #define PXL8_NET_USERDATA_SIZE 56
 
 typedef struct pxl8_net pxl8_net;
-
-typedef enum pxl8_net_mode {
-    PXL8_NET_LOCAL = 0,
-    PXL8_NET_REMOTE
-} pxl8_net_mode;
+typedef struct pxl8_chunk_cache pxl8_chunk_cache;
 
 typedef struct pxl8_net_config {
     const char* address;
-    pxl8_net_mode mode;
     u16 port;
 } pxl8_net_config;
 
@@ -48,6 +43,11 @@ pxl8_result pxl8_net_send_input(pxl8_net* net, const pxl8_input_msg* input);
 const pxl8_snapshot_header* pxl8_net_snapshot(const pxl8_net* net);
 u64 pxl8_net_tick(const pxl8_net* net);
 void pxl8_net_update(pxl8_net* net, f32 dt);
+void pxl8_net_set_chunk_cache(pxl8_net* net, pxl8_chunk_cache* cache);
+pxl8_chunk_cache* pxl8_net_chunk_cache(pxl8_net* net);
+
+u32 pxl8_net_chunk_id(const pxl8_net* net);
+u8 pxl8_net_chunk_type(const pxl8_net* net);
 
 #ifdef __cplusplus
 }

src/net/pxl8_protocol.c

@@ -122,3 +122,76 @@ usize pxl8_protocol_deserialize_snapshot_header(const u8* buf, usize len, pxl8_s
     hdr->time = pxl8_read_f32_be(&s);
     return s.offset;
 }
+
+usize pxl8_protocol_serialize_chunk_msg_header(const pxl8_chunk_msg_header* hdr, u8* buf, usize len) {
+    if (len < 24) return 0;
+    pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len);
+    pxl8_write_u8(&s, hdr->chunk_type);
+    pxl8_write_u8(&s, hdr->flags);
+    pxl8_write_u8(&s, hdr->fragment_idx);
+    pxl8_write_u8(&s, hdr->fragment_count);
+    pxl8_write_u32_be(&s, hdr->id);
+    pxl8_write_u32_be(&s, (u32)hdr->cx);
+    pxl8_write_u32_be(&s, (u32)hdr->cy);
+    pxl8_write_u32_be(&s, (u32)hdr->cz);
+    pxl8_write_u32_be(&s, hdr->version);
+    pxl8_write_u16_be(&s, hdr->payload_size);
+    pxl8_write_u16_be(&s, hdr->reserved);
+    return s.offset;
+}
+
+usize pxl8_protocol_deserialize_chunk_msg_header(const u8* buf, usize len, pxl8_chunk_msg_header* hdr) {
+    if (len < 24) return 0;
+    pxl8_stream s = pxl8_stream_create(buf, (u32)len);
+    hdr->chunk_type = pxl8_read_u8(&s);
+    hdr->flags = pxl8_read_u8(&s);
+    hdr->fragment_idx = pxl8_read_u8(&s);
+    hdr->fragment_count = pxl8_read_u8(&s);
+    hdr->id = pxl8_read_u32_be(&s);
+    hdr->cx = (i32)pxl8_read_u32_be(&s);
+    hdr->cy = (i32)pxl8_read_u32_be(&s);
+    hdr->cz = (i32)pxl8_read_u32_be(&s);
+    hdr->version = pxl8_read_u32_be(&s);
+    hdr->payload_size = pxl8_read_u16_be(&s);
+    hdr->reserved = pxl8_read_u16_be(&s);
+    return s.offset;
+}
+
+usize pxl8_protocol_deserialize_bsp_wire_header(const u8* buf, usize len, pxl8_bsp_wire_header* hdr) {
+    if (len < 44) return 0;
+    pxl8_stream s = pxl8_stream_create(buf, (u32)len);
+    hdr->num_vertices = pxl8_read_u32_be(&s);
+    hdr->num_edges = pxl8_read_u32_be(&s);
+    hdr->num_faces = pxl8_read_u32_be(&s);
+    hdr->num_planes = pxl8_read_u32_be(&s);
+    hdr->num_nodes = pxl8_read_u32_be(&s);
+    hdr->num_leafs = pxl8_read_u32_be(&s);
+    hdr->num_surfedges = pxl8_read_u32_be(&s);
+    hdr->num_marksurfaces = pxl8_read_u32_be(&s);
+    hdr->num_cell_portals = pxl8_read_u32_be(&s);
+    hdr->visdata_size = pxl8_read_u32_be(&s);
+    hdr->num_vertex_lights = pxl8_read_u32_be(&s);
+    return s.offset;
+}
+
+usize pxl8_protocol_serialize_chunk_enter(const pxl8_chunk_enter_msg* msg, u8* buf, usize len) {
+    if (len < 8) return 0;
+    pxl8_write_stream s = pxl8_write_stream_create(buf, (u32)len);
+    pxl8_write_u32_be(&s, msg->chunk_id);
+    pxl8_write_u8(&s, msg->chunk_type);
+    pxl8_write_u8(&s, msg->reserved[0]);
+    pxl8_write_u8(&s, msg->reserved[1]);
+    pxl8_write_u8(&s, msg->reserved[2]);
+    return s.offset;
+}
+
+usize pxl8_protocol_deserialize_chunk_enter(const u8* buf, usize len, pxl8_chunk_enter_msg* msg) {
+    if (len < 8) return 0;
+    pxl8_stream s = pxl8_stream_create(buf, (u32)len);
+    msg->chunk_id = pxl8_read_u32_be(&s);
+    msg->chunk_type = pxl8_read_u8(&s);
+    msg->reserved[0] = pxl8_read_u8(&s);
+    msg->reserved[1] = pxl8_read_u8(&s);
+    msg->reserved[2] = pxl8_read_u8(&s);
+    return s.offset;
+}

src/net/pxl8_protocol.h

@@ -14,12 +14,14 @@ extern "C" {
 
 typedef enum pxl8_msg_type {
     PXL8_MSG_NONE = 0,
+    PXL8_MSG_CHUNK,
+    PXL8_MSG_CHUNK_ENTER,
+    PXL8_MSG_COMMAND,
     PXL8_MSG_CONNECT,
     PXL8_MSG_DISCONNECT,
+    PXL8_MSG_EVENT,
     PXL8_MSG_INPUT,
-    PXL8_MSG_COMMAND,
-    PXL8_MSG_SNAPSHOT,
-    PXL8_MSG_EVENT
+    PXL8_MSG_SNAPSHOT
 } pxl8_msg_type;
 
 typedef struct pxl8_msg_header {
@@ -70,6 +72,39 @@ typedef struct pxl8_snapshot_header {
     f32 time;
 } pxl8_snapshot_header;
 
+#define PXL8_CHUNK_TYPE_VXL 0
+#define PXL8_CHUNK_TYPE_BSP 1
+
+#define PXL8_CHUNK_FLAG_RLE   0x01
+#define PXL8_CHUNK_FLAG_FINAL 0x04
+#define PXL8_CHUNK_MAX_PAYLOAD 1400
+
+typedef struct pxl8_chunk_msg_header {
+    u8 chunk_type;
+    u8 flags;
+    u8 fragment_idx;
+    u8 fragment_count;
+    u32 id;
+    i32 cx, cy, cz;
+    u32 version;
+    u16 payload_size;
+    u16 reserved;
+} pxl8_chunk_msg_header;
+
+typedef struct pxl8_bsp_wire_header {
+    u32 num_vertices;
+    u32 num_edges;
+    u32 num_faces;
+    u32 num_planes;
+    u32 num_nodes;
+    u32 num_leafs;
+    u32 num_surfedges;
+    u32 num_marksurfaces;
+    u32 num_cell_portals;
+    u32 visdata_size;
+    u32 num_vertex_lights;
+} pxl8_bsp_wire_header;
+
 usize pxl8_protocol_serialize_header(const pxl8_msg_header* msg, u8* buf, usize len);
 usize pxl8_protocol_deserialize_header(const u8* buf, usize len, pxl8_msg_header* msg);
 
@@ -88,6 +123,20 @@ usize pxl8_protocol_deserialize_event(const u8* buf, usize len, pxl8_event_msg*
 usize pxl8_protocol_serialize_snapshot_header(const pxl8_snapshot_header* hdr, u8* buf, usize len);
 usize pxl8_protocol_deserialize_snapshot_header(const u8* buf, usize len, pxl8_snapshot_header* hdr);
 
+usize pxl8_protocol_serialize_chunk_msg_header(const pxl8_chunk_msg_header* hdr, u8* buf, usize len);
+usize pxl8_protocol_deserialize_chunk_msg_header(const u8* buf, usize len, pxl8_chunk_msg_header* hdr);
+
+usize pxl8_protocol_deserialize_bsp_wire_header(const u8* buf, usize len, pxl8_bsp_wire_header* hdr);
+
+typedef struct pxl8_chunk_enter_msg {
+    u32 chunk_id;
+    u8 chunk_type;
+    u8 reserved[3];
+} pxl8_chunk_enter_msg;
+
+usize pxl8_protocol_serialize_chunk_enter(const pxl8_chunk_enter_msg* msg, u8* buf, usize len);
+usize pxl8_protocol_deserialize_chunk_enter(const u8* buf, usize len, pxl8_chunk_enter_msg* msg);
+
 #ifdef __cplusplus
 }
 #endif