commit 105bef5
uint
·
2026-08-04 14:42:29 +0000 UTC
parent 971a236
reformat all files
23 files changed,
+341,
-308
+3,
-1
1@@ -5,16 +5,18 @@ BreakBeforeBraces: Custom
2 BraceWrapping:
3 AfterControlStatement: Never
4 AfterFunction: true
5- BeforeElse: false
6+ BeforeElse: true
7 ColumnLimit: 120
8 Cpp11BracedListStyle: false
9 AllowAllParametersOfDeclarationOnNextLine: false
10+AllowShortFunctionsOnASingleLine: None
11 AllowShortIfStatementsOnASingleLine: Never
12 AllowShortLoopsOnASingleLine: false
13 BinPackParameters: true
14 IndentCaseLabels: false
15 IndentPPDirectives: BeforeHash
16 IndentWidth: 8
17+InsertNewlineAtEOF: true
18 PenaltyReturnTypeOnItsOwnLine: 1000
19 PointerAlignment: Left
20 ReflowComments: false
+0,
-2
1@@ -20,5 +20,3 @@ void player_server_send_position(Player* player, MGCamera* cam, MCClient* client
2 void player_server_handle_position(Player* player, MGCamera* cam, const MCPacket* packet);
3
4 #endif /* PLAYER_H */
5-
6-
+5,
-6
1@@ -21,13 +21,12 @@ typedef struct {
2 size_t size;
3 } MCPacket;
4
5-int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error,
6- size_t error_size);
7+int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error, size_t error_size);
8 void mc_client_interrupt(MCClient* client);
9 void mc_client_destroy(MCClient* client);
10
11-int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error_size);
12-int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t size);
13+int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error_size);
14+int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t size);
15
16 /* poll for packets.
17 returns 1: packet recieved,
18@@ -38,8 +37,8 @@ int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error
19 void mc_packet_free(MCPacket* packet);
20
21 /* send server player look data */
22-int mc_client_send_position_look(MCClient* client, double x, double feet_y,
23- double z, float yaw, float pitch, i8 grounded);
24+int mc_client_send_position_look(MCClient* client, double x, double feet_y, double z, float yaw, float pitch,
25+ i8 grounded);
26
27 const char* mc_client_username(const MCClient* client);
28 const char* mc_client_uuid(const MCClient* client);
+0,
-1
1@@ -43,4 +43,3 @@ i8 packet_read_f64(PacketReader* reader, double* value);
2 i8 packet_read_varint(PacketReader* reader, i32* value);
3
4 #endif /* PACKET_H */
5-
+35,
-42
1@@ -31,8 +31,8 @@ typedef struct {
2 u16 mask;
3 } BulkChunkMeta;
4
5-static MGCamera cam;
6-static Chunk chunks[WORLD_WIDTH][WORLD_DEPTH];
7+static MGCamera cam;
8+static Chunk chunks[WORLD_WIDTH][WORLD_DEPTH];
9
10 #define NCHUNKS 128
11 static ServerChunk server_chunks[NCHUNKS];
12@@ -45,7 +45,7 @@ ServerChunk* server_chunk_find(i32 x, i32 z)
13 for (i = 0; i < NCHUNKS; i++) {
14 if (!server_chunks[i].used)
15 continue;
16-
17+
18 if (server_chunks[i].x == x && server_chunks[i].z == z)
19 return &server_chunks[i];
20 }
21@@ -135,8 +135,7 @@ i8 load_server_section(Chunk* section, const u8* data, size_t size)
22 memset(section, 0, sizeof(*section));
23
24 for (index = 0; index < 4096; index++) {
25- state = (u16)data[index * 2] |
26- ((u16)data[index * 2 + 1] << 8);
27+ state = (u16)data[index * 2] | ((u16)data[index * 2 + 1] << 8);
28
29 x = index & 15;
30 z = (index >> 4) & 15;
31@@ -169,10 +168,8 @@ void test_scene_chunk(const MCPacket* packet)
32 u8 ground_up;
33 u16 mask;
34
35- if (!packet_read_i32(&reader, &chunk_x) ||
36- !packet_read_i32(&reader, &chunk_z) ||
37- !packet_read_u8(&reader, &ground_up) ||
38- !packet_read_u16(&reader, &mask) ||
39+ if (!packet_read_i32(&reader, &chunk_x) || !packet_read_i32(&reader, &chunk_z) ||
40+ !packet_read_u8(&reader, &ground_up) || !packet_read_u16(&reader, &mask) ||
41 !packet_read_varint(&reader, &data_size)) {
42 mg_log(LOG_ERR, "Malformed Chunk Data packet");
43 return;
44@@ -224,19 +221,19 @@ void test_scene_chunk(const MCPacket* packet)
45
46 void test_scene_bulk_chunks(const MCPacket* packet)
47 {
48- PacketReader reader = packet_reader_init(packet->data, packet->size);
49+ PacketReader reader = packet_reader_init(packet->data, packet->size);
50 BulkChunkMeta* metadata;
51- ServerChunk* column;
52- const u8* data;
53- size_t offset;
54- size_t block_size;
55- size_t column_size;
56- i32 count;
57- i32 index;
58- i32 sections;
59- i32 section;
60- i32 data_section;
61- u8 skylight;
62+ ServerChunk* column;
63+ const u8* data;
64+ size_t offset;
65+ size_t block_size;
66+ size_t column_size;
67+ i32 count;
68+ i32 index;
69+ i32 sections;
70+ i32 section;
71+ i32 data_section;
72+ u8 skylight;
73
74 reader.data = packet->data;
75 reader.size = packet->size;
76@@ -256,9 +253,8 @@ void test_scene_bulk_chunks(const MCPacket* packet)
77 return;
78
79 for (index = 0; index < count; index++) {
80- if (!packet_read_i32(&reader, &metadata[index].x) ||
81- !packet_read_i32( &reader, &metadata[index].z) ||
82- !packet_read_u16( &reader, &metadata[index].mask)) {
83+ if (!packet_read_i32(&reader, &metadata[index].x) || !packet_read_i32(&reader, &metadata[index].z) ||
84+ !packet_read_u16(&reader, &metadata[index].mask)) {
85 free(metadata);
86 return;
87 }
88@@ -344,16 +340,16 @@ void test_scene_create(Player* player, i8 server)
89
90 void test_scene_draw(MGContext* ctx)
91 {
92- MGMat4 proj;
93- MGMat4 view;
94- MGMat4 mvp;
95- MGMat4 model;
96- i32 x;
97- i32 z;
98- i32 width;
99- i32 height;
100- float aspect;
101- i32 texture;
102+ MGMat4 proj;
103+ MGMat4 view;
104+ MGMat4 mvp;
105+ MGMat4 model;
106+ i32 x;
107+ i32 z;
108+ i32 width;
109+ i32 height;
110+ float aspect;
111+ i32 texture;
112
113 ServerChunk* column;
114 Chunk* section_chunk;
115@@ -382,11 +378,8 @@ void test_scene_draw(MGContext* ctx)
116 continue;
117
118 section_chunk = &column->sections[section];
119- model = MG_Translate(MG_V3(
120- column->x * CHUNK_WIDTH,
121- section * CHUNK_HEIGHT,
122- column->z * CHUNK_DEPTH
123- ));
124+ model = MG_Translate(
125+ MG_V3(column->x * CHUNK_WIDTH, section * CHUNK_HEIGHT, column->z * CHUNK_DEPTH));
126 mvp = MG_MulM4(proj, MG_MulM4(view, model));
127 for (texture = 0; texture < BLOCK_TEXTURE_COUNT; texture++) {
128 if (section_chunk->meshes[texture] != MGMESH_INVALID)
129@@ -405,8 +398,8 @@ void test_scene_draw(MGContext* ctx)
130 for (texture = 0; texture < BLOCK_TEXTURE_COUNT; texture++) {
131 if (chunks[x][z].meshes[texture] == MGMESH_INVALID)
132 continue;
133- renderer_mesh_draw(chunks[x][z].meshes[texture],
134- block_texture_get(texture), &mvp);
135+ renderer_mesh_draw(chunks[x][z].meshes[texture], block_texture_get(texture),
136+ &mvp);
137 }
138 }
139 }
140@@ -427,7 +420,7 @@ void test_scene_destroy(void)
141 continue;
142
143 for (section = 0; section < 16; section++)
144- chunk_mesh_destroy(&server_chunks[i] .sections[section]);
145+ chunk_mesh_destroy(&server_chunks[i].sections[section]);
146 }
147 }
148 else {
+2,
-1
1@@ -3,7 +3,8 @@
2
3 #define RGBA(r, g, b, a) (((u32)(r)) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
4
5-typedef enum { /* TODO: rename to MG_EC_... */
6+/* TODO: rename to MG_EC_... */
7+typedef enum {
8 MG_ERR_EXIT_SUCCESS,
9 MG_ERR_EXIT_FAILURE,
10
+6,
-6
1@@ -6,9 +6,9 @@
2
3 typedef u16 BlockType;
4
5-#define BLOCK_AIR ((BlockType)0)
6+#define BLOCK_AIR ((BlockType)0)
7 #define BLOCK_STONE ((BlockType)(1 << 4))
8-#define BLOCK_DIRT ((BlockType)(3 << 4))
9+#define BLOCK_DIRT ((BlockType)(3 << 4))
10 #define BLOCK_BRICK ((BlockType)(45 << 4))
11
12 #define BLOCK_FACE_COUNT 6
13@@ -20,10 +20,10 @@ typedef struct {
14 i32 cullface;
15 } BlockFace;
16
17-i8 block_textures_create(const char* path);
18-void block_textures_destroy(void);
19+i8 block_textures_create(const char* path);
20+void block_textures_destroy(void);
21 const BlockFace* block_model_faces(BlockType block, i32* count);
22-i8 block_model_occludes(BlockType block);
23-MGTexture block_texture_get(i32 index);
24+i8 block_model_occludes(BlockType block);
25+MGTexture block_texture_get(i32 index);
26
27 #endif /* WORLD_BLOCK_H */
+11,
-15
1@@ -8,19 +8,15 @@
2 void player_server_handle_position(Player* player, MGCamera* cam, const MCPacket* packet)
3 {
4 PacketReader reader = packet_reader_init(packet->data, packet->size);
5- double x;
6- double y;
7- double z;
8- float yaw;
9- float pitch;
10- u8 flags;
11-
12- if (!packet_read_f64(&reader, &x) ||
13- !packet_read_f64(&reader, &y) ||
14- !packet_read_f64(&reader, &z) ||
15- !packet_read_f32(&reader, &yaw) ||
16- !packet_read_f32(&reader, &pitch) ||
17- !packet_read_u8(&reader, &flags)) {
18+ double x;
19+ double y;
20+ double z;
21+ float yaw;
22+ float pitch;
23+ u8 flags;
24+
25+ if (!packet_read_f64(&reader, &x) || !packet_read_f64(&reader, &y) || !packet_read_f64(&reader, &z) ||
26+ !packet_read_f32(&reader, &yaw) || !packet_read_f32(&reader, &pitch) || !packet_read_u8(&reader, &flags)) {
27 mg_log(LOG_ERR, "Malformed position packet");
28 return;
29 }
30@@ -53,14 +49,14 @@ void player_server_handle_position(Player* player, MGCamera* cam, const MCPacket
31 player->positioned = 1;
32
33 cam->pos = MG_V3(player->x, player->y + 1.62f, player->z);
34- cam->yaw = MG_AngleDeg( player->yaw - 180.0f);
35+ cam->yaw = MG_AngleDeg(player->yaw - 180.0f);
36 cam->pitch = MG_AngleDeg(-player->pitch);
37 }
38
39 void player_server_send_position(Player* player, MGCamera* cam, MCClient* client)
40 {
41 static u32 last_send;
42- u64 now;
43+ u64 now;
44
45 if (!client || !player->positioned)
46 return;
+9,
-3
1@@ -103,9 +103,15 @@ int main(int argc, char** argv)
2 if (!mc_client_write(client, 0x00, packet.data, packet.size))
3 mg_log(LOG_ERR, "Failed to echo keepalive");
4 break;
5- case 0x08: player_server_handle_position(&player, &cam, &packet); break;
6- case 0x21: test_scene_chunk(&packet); break;
7- case 0x26: test_scene_bulk_chunks(&packet); break;
8+ case 0x08:
9+ player_server_handle_position(&player, &cam, &packet);
10+ break;
11+ case 0x21:
12+ test_scene_chunk(&packet);
13+ break;
14+ case 0x26:
15+ test_scene_bulk_chunks(&packet);
16+ break;
17 }
18
19 mc_packet_free(&packet);
+12,
-16
1@@ -60,7 +60,8 @@ static int json_string(MCBuffer* buffer, const char* value)
2 if (*p < 0x20) {
3 snprintf(escaped, sizeof(escaped), "\\u%04x", *p);
4 size = 6;
5- } else {
6+ }
7+ else {
8 escaped[0] = (char)*p;
9 }
10 }
11@@ -116,8 +117,8 @@ static long http_status(const MCBuffer* response)
12 return status;
13 }
14
15-int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16],
16- const u8* public_key, size_t public_key_size, char* error, size_t error_size)
17+int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16], const u8* public_key,
18+ size_t public_key_size, char* error, size_t error_size)
19 {
20 struct tls_config* config = NULL;
21 struct tls* tls = NULL;
22@@ -141,11 +142,9 @@ int mc_join_server(const MCAccount* account, const char* server_id, const u8 sha
23 bufinit(&request);
24 bufinit(&response);
25 mc_server_hash(server_id, shared_secret, public_key, public_key_size, hash);
26- if (!bufwrite(&json, "{\"accessToken\":", 15) ||
27- !json_string(&json, account->access_token) ||
28- !bufwrite(&json, ",\"selectedProfile\":", 19) ||
29- !json_string(&json, account->profile_uuid) || !bufwrite(&json, ",\"serverId\":", 12) ||
30- !json_string(&json, hash) || !bufwrite_u8(&json, '}')) {
31+ if (!bufwrite(&json, "{\"accessToken\":", 15) || !json_string(&json, account->access_token) ||
32+ !bufwrite(&json, ",\"selectedProfile\":", 19) || !json_string(&json, account->profile_uuid) ||
33+ !bufwrite(&json, ",\"serverId\":", 12) || !json_string(&json, hash) || !bufwrite_u8(&json, '}')) {
34 mc_set_error(error, error_size, "out of memory building session request");
35 goto cleanup;
36 }
37@@ -177,26 +176,23 @@ int mc_join_server(const MCAccount* account, const char* server_id, const u8 sha
38 "Connection: close\r\n"
39 "\r\n",
40 (unsigned long)json.size);
41- if (!bufwrite(&request, headers, strlen(headers)) ||
42- !bufwrite(&request, json.data, json.size)) {
43+ if (!bufwrite(&request, headers, strlen(headers)) || !bufwrite(&request, json.data, json.size)) {
44 mc_set_error(error, error_size, "out of memory building session HTTP request");
45 goto cleanup;
46 }
47 if (!tls_write_all(tls, request.data, request.size)) {
48- mc_set_error(error, error_size, "session join request write failed: %s",
49- tls_error(tls));
50+ mc_set_error(error, error_size, "session join request write failed: %s", tls_error(tls));
51 goto cleanup;
52 }
53 if (!tls_read_response(tls, &response)) {
54- mc_set_error(error, error_size, "session join response read failed: %s",
55- tls_error(tls));
56+ mc_set_error(error, error_size, "session join response read failed: %s", tls_error(tls));
57 goto cleanup;
58 }
59 status = http_status(&response);
60 if (status != 204) {
61 size_t show = response.size < 400 ? response.size : 400;
62- mc_set_error(error, error_size, "session server rejected join (HTTP %ld): %.*s",
63- status, (int)show, response.data ? (char*)response.data : "");
64+ mc_set_error(error, error_size, "session server rejected join (HTTP %ld): %.*s", status, (int)show,
65+ response.data ? (char*)response.data : "");
66 goto cleanup;
67 }
68 ok = 1;
+13,
-5
1@@ -16,7 +16,10 @@ void mc_set_error(char* error, size_t error_size, const char* fmt, ...)
2 va_end(args);
3 }
4
5-void bufinit(MCBuffer* buffer) { memset(buffer, 0, sizeof(*buffer)); }
6+void bufinit(MCBuffer* buffer)
7+{
8+ memset(buffer, 0, sizeof(*buffer));
9+}
10
11 void buffree(MCBuffer* buffer)
12 {
13@@ -62,7 +65,10 @@ int bufwrite(MCBuffer* buffer, const void* data, size_t size)
14 return 1;
15 }
16
17-int bufwrite_u8(MCBuffer* buffer, u8 value) { return bufwrite(buffer, &value, 1); }
18+int bufwrite_u8(MCBuffer* buffer, u8 value)
19+{
20+ return bufwrite(buffer, &value, 1);
21+}
22
23 int bufwrite_u16(MCBuffer* buffer, u16 value)
24 {
25@@ -144,7 +150,10 @@ int bufread(MCBuffer* buffer, void* out, size_t size)
26 return 1;
27 }
28
29-int bufread_u8(MCBuffer* buffer, u8* value) { return bufread(buffer, value, 1); }
30+int bufread_u8(MCBuffer* buffer, u8* value)
31+{
32+ return bufread(buffer, value, 1);
33+}
34
35 int bufread_u16(MCBuffer* buffer, u16* value)
36 {
37@@ -234,8 +243,7 @@ int bufread_string(MCBuffer* buffer, char* value, size_t value_size)
38 int bufread_bytes(MCBuffer* buffer, const u8** value, size_t* size)
39 {
40 i32 length;
41- if (!bufread_varint(buffer, &length) || length < 0 ||
42- (size_t)length > buffer->size - buffer->cursor)
43+ if (!bufread_varint(buffer, &length) || length < 0 || (size_t)length > buffer->size - buffer->cursor)
44 return 0;
45 *value = buffer->data + buffer->cursor;
46 *size = (size_t)length;
+69,
-72
1@@ -15,12 +15,11 @@
2 #include "mg_random.h"
3
4 #ifndef MSG_NOSIGNAL
5-#define MSG_NOSIGNAL 0
6+ #define MSG_NOSIGNAL 0
7 #endif
8
9 /* parse into host and port + validate */
10-static int split_address(const char* address, char* host, size_t host_size, u16* port, char* error,
11- size_t error_size)
12+static int split_address(const char* address, char* host, size_t host_size, u16* port, char* error, size_t error_size)
13 {
14 const char* colon = strrchr(address, ':');
15 const char* end = address + strlen(address);
16@@ -38,18 +37,20 @@ static int split_address(const char* address, char* host, size_t host_size, u16*
17 address += 1;
18 if (close[1] == ':') {
19 parsed_port = strtol(close + 2, &port_end, 10);
20- } else if (close[1] != '\0') {
21+ }
22+ else if (close[1] != '\0') {
23 mc_set_error(error, error_size, "invalid address suffix");
24 return 0;
25 }
26- } else if (colon && strchr(address, ':') == colon) {
27+ }
28+ else if (colon && strchr(address, ':') == colon) {
29 length = (size_t)(colon - address);
30 parsed_port = strtol(colon + 1, &port_end, 10);
31- } else {
32+ }
33+ else {
34 length = (size_t)(end - address);
35 }
36- if ((port_end && *port_end) || length == 0 || length >= host_size || parsed_port < 1 ||
37- parsed_port > 65535) {
38+ if ((port_end && *port_end) || length == 0 || length >= host_size || parsed_port < 1 || parsed_port > 65535) {
39 mc_set_error(error, error_size, "invalid server address");
40 return 0;
41 }
42@@ -75,14 +76,12 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
43
44 result = getaddrinfo(client->host, service, &hints, &addresses);
45 if (result != 0) {
46- mc_set_error(error, error_size, "could not resolve %s: %s", client->host,
47- gai_strerror(result));
48+ mc_set_error(error, error_size, "could not resolve %s: %s", client->host, gai_strerror(result));
49 return 0;
50 }
51
52 for (address = addresses; address; address = address->ai_next) {
53- client->socket_fd =
54- socket(address->ai_family, address->ai_socktype, address->ai_protocol);
55+ client->socket_fd = socket(address->ai_family, address->ai_socktype, address->ai_protocol);
56 if (client->socket_fd < 0)
57 continue;
58 if (connect(client->socket_fd, address->ai_addr, address->ai_addrlen) == 0)
59@@ -93,8 +92,8 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
60 freeaddrinfo(addresses);
61
62 if (client->socket_fd < 0) {
63- mc_set_error(error, error_size, "could not connect to %s:%u: %s", client->host,
64- client->port, strerror(errno));
65+ mc_set_error(error, error_size, "could not connect to %s:%u: %s", client->host, client->port,
66+ strerror(errno));
67 return 0;
68 }
69 return 1;
70@@ -114,13 +113,14 @@ static int socket_write(MCClient* client, const u8* data, size_t size)
71 if (client->encrypted)
72 mc_cipher_encrypt(&client->write_cipher, encrypted, chunk);
73 while (sent < chunk) {
74- ssize_t count =
75- send(client->socket_fd, encrypted + sent, chunk - sent, MSG_NOSIGNAL);
76+ ssize_t count = send(client->socket_fd, encrypted + sent, chunk - sent, MSG_NOSIGNAL);
77 if (count > 0) {
78 sent += (size_t)count;
79- } else if (count < 0 && errno == EINTR) {
80+ }
81+ else if (count < 0 && errno == EINTR) {
82 continue;
83- } else {
84+ }
85+ else {
86 return 0;
87 }
88 }
89@@ -136,9 +136,11 @@ static int socket_read(MCClient* client, u8* data, size_t size)
90 ssize_t count = recv(client->socket_fd, data + offset, size - offset, 0);
91 if (count > 0) {
92 offset += (size_t)count;
93- } else if (count < 0 && errno == EINTR) {
94+ }
95+ else if (count < 0 && errno == EINTR) {
96 continue;
97- } else {
98+ }
99+ else {
100 return 0;
101 }
102 }
103@@ -198,22 +200,21 @@ int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t si
104 if (body.size >= (size_t)client->compression_threshold) {
105 compressed_size = compressBound((uLong)body.size);
106 compressed = (u8*)malloc(compressed_size);
107- if (!compressed ||
108- compress2(compressed, &compressed_size, body.data, (uLong)body.size,
109- Z_DEFAULT_COMPRESSION) != Z_OK)
110+ if (!compressed || compress2(compressed, &compressed_size, body.data, (uLong)body.size,
111+ Z_DEFAULT_COMPRESSION) != Z_OK)
112 goto cleanup;
113 if (!bufwrite_varint(&framed, (i32)body.size) ||
114 !bufwrite(&framed, compressed, compressed_size))
115 goto cleanup;
116- } else if (!bufwrite_varint(&framed, 0) ||
117- !bufwrite(&framed, body.data, body.size)) {
118+ }
119+ else if (!bufwrite_varint(&framed, 0) || !bufwrite(&framed, body.data, body.size)) {
120 goto cleanup;
121 }
122- } else if (!bufwrite(&framed, body.data, body.size)) {
123+ }
124+ else if (!bufwrite(&framed, body.data, body.size)) {
125 goto cleanup;
126 }
127- if (bufwrite_varint(&length, (i32)framed.size) &&
128- socket_write(client, length.data, length.size) &&
129+ if (bufwrite_varint(&length, (i32)framed.size) && socket_write(client, length.data, length.size) &&
130 socket_write(client, framed.data, framed.size))
131 ok = 1;
132
133@@ -242,8 +243,7 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
134 mc_set_error(error, error_size, "connection closed while reading packet length");
135 goto cleanup;
136 }
137- if (frame_length <= 0 || (u32)frame_length > MC_MAX_PACKET_SIZE ||
138- !bufreserve(&frame, (size_t)frame_length)) {
139+ if (frame_length <= 0 || (u32)frame_length > MC_MAX_PACKET_SIZE || !bufreserve(&frame, (size_t)frame_length)) {
140 mc_set_error(error, error_size, "invalid packet length: %d", frame_length);
141 goto cleanup;
142 }
143@@ -254,15 +254,15 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
144 }
145 if (client->compression_threshold >= 0) {
146 /* same as before data length 0 means no compression */
147- if (!bufread_varint(&frame, &data_length) || data_length < 0 ||
148- (u32)data_length > MC_MAX_PACKET_SIZE) {
149+ if (!bufread_varint(&frame, &data_length) || data_length < 0 || (u32)data_length > MC_MAX_PACKET_SIZE) {
150 mc_set_error(error, error_size, "invalid compressed packet header");
151 goto cleanup;
152 }
153 if (data_length == 0) {
154 decoded.data = frame.data + frame.cursor;
155 decoded.size = frame.size - frame.cursor;
156- } else {
157+ }
158+ else {
159 uLongf output_size = (uLongf)data_length;
160 if (!bufreserve(&decoded, (size_t)data_length) ||
161 uncompress(decoded.data, &output_size, frame.data + frame.cursor,
162@@ -274,7 +274,8 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
163 decoded_allocated = 1;
164 decoded.size = (size_t)output_size;
165 }
166- } else {
167+ }
168+ else {
169 decoded.data = frame.data;
170 decoded.size = frame.size;
171 }
172@@ -295,7 +296,8 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
173 cleanup:
174 if (decoded_allocated) {
175 buffree(&decoded);
176- } else {
177+ }
178+ else {
179 decoded.data = NULL;
180 }
181 buffree(&frame);
182@@ -318,9 +320,8 @@ static int send_handshake(MCClient* client)
183 int ok;
184 bufinit(&payload);
185 /* handshake to next state 2 switches the connection into login state */
186- ok = bufwrite_varint(&payload, MC_PROTOCOL_1_8_9) &&
187- bufwrite_string(&payload, client->host) && bufwrite_u16(&payload, client->port) &&
188- bufwrite_varint(&payload, 2) &&
189+ ok = bufwrite_varint(&payload, MC_PROTOCOL_1_8_9) && bufwrite_string(&payload, client->host) &&
190+ bufwrite_u16(&payload, client->port) && bufwrite_varint(&payload, 2) &&
191 mc_client_write(client, 0x00, payload.data, payload.size);
192 buffree(&payload);
193 return ok;
194@@ -331,14 +332,13 @@ static int send_login_start(MCClient* client)
195 MCBuffer payload;
196 int ok;
197 bufinit(&payload);
198- ok = bufwrite_string(&payload, client->username) &&
199- mc_client_write(client, 0x00, payload.data, payload.size);
200+ ok = bufwrite_string(&payload, client->username) && mc_client_write(client, 0x00, payload.data, payload.size);
201 buffree(&payload);
202 return ok;
203 }
204
205-static int handle_encryption(MCClient* client, const MCAccount* account, MCPacket* packet,
206- char* error, size_t error_size)
207+static int handle_encryption(MCClient* client, const MCAccount* account, MCPacket* packet, char* error,
208+ size_t error_size)
209 {
210 MCBuffer input = { packet->data, packet->size, packet->size, 0 };
211 MCBuffer response;
212@@ -367,12 +367,11 @@ static int handle_encryption(MCClient* client, const MCAccount* account, MCPacke
213 return 0;
214 }
215 /* join the mojang session, encrypt the secret, verify token */
216- if (!mc_join_server(account, server_id, shared_secret, public_key, public_key_size, error,
217- error_size) ||
218- !mc_rsa_encrypt(public_key, public_key_size, shared_secret, sizeof(shared_secret),
219- &encrypted_secret, &encrypted_secret_size, error, error_size) ||
220- !mc_rsa_encrypt(public_key, public_key_size, verify_token, verify_token_size,
221- &encrypted_token, &encrypted_token_size, error, error_size))
222+ if (!mc_join_server(account, server_id, shared_secret, public_key, public_key_size, error, error_size) ||
223+ !mc_rsa_encrypt(public_key, public_key_size, shared_secret, sizeof(shared_secret), &encrypted_secret,
224+ &encrypted_secret_size, error, error_size) ||
225+ !mc_rsa_encrypt(public_key, public_key_size, verify_token, verify_token_size, &encrypted_token,
226+ &encrypted_token_size, error, error_size))
227 goto cleanup;
228
229 bufinit(&response);
230@@ -386,7 +385,8 @@ static int handle_encryption(MCClient* client, const MCAccount* account, MCPacke
231 mc_cipher_init(&client->write_cipher, shared_secret);
232 client->encrypted = 1;
233 ok = 1;
234- } else {
235+ }
236+ else {
237 mc_set_error(error, error_size, "could not send encryption response");
238 }
239 buffree(&response);
240@@ -421,8 +421,7 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
241 char reason[1024];
242 if (!bufread_string(&input, reason, sizeof(reason)))
243 strcpy(reason, "malformed disconnect reason");
244- mc_set_error(error, error_size, "server disconnected during login: %s",
245- reason);
246+ mc_set_error(error, error_size, "server disconnected during login: %s", reason);
247 mc_packet_free(&packet);
248 return 0;
249 }
250@@ -463,8 +462,7 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
251 }
252 }
253 /*create a client */
254-int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error,
255- size_t error_size)
256+int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error, size_t error_size)
257 {
258 MCClient* client;
259 size_t username_size;
260@@ -491,11 +489,9 @@ int mc_client_login(MCClient** out, const char* address, const MCAccount* accoun
261 memcpy(client->username, account->username, username_size + 1);
262 printf("connecting to %s as %s\n", address, client->username);
263 /*parse server addr */
264- if (!split_address(address, client->host, sizeof(client->host), &client->port, error,
265- error_size) ||
266+ if (!split_address(address, client->host, sizeof(client->host), &client->port, error, error_size) ||
267 /*open tcp */
268- !tcp_connect(client, error, error_size) || !send_handshake(client) ||
269- !send_login_start(client)) {
270+ !tcp_connect(client, error, error_size) || !send_handshake(client) || !send_login_start(client)) {
271 if (!error || !error_size || !error[0])
272 mc_set_error(error, error_size, "could not start Minecraft login");
273 mc_client_destroy(client);
274@@ -529,7 +525,7 @@ void mc_client_destroy(MCClient* client)
275 int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error_size)
276 {
277 struct pollfd fd;
278- int result;
279+ int result;
280
281 if (!client || client->socket_fd < 0) {
282 mc_set_error(error, error_size, "invalid Minecraft client");
283@@ -567,28 +563,29 @@ int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error
284 return 0;
285 }
286
287-int mc_client_send_position_look(MCClient* client, double x, double feet_y,
288- double z, float yaw, float pitch, i8 grounded)
289+int mc_client_send_position_look(MCClient* client, double x, double feet_y, double z, float yaw, float pitch,
290+ i8 grounded)
291 {
292 MCBuffer payload;
293- int ok;
294+ int ok;
295
296 bufinit(&payload);
297
298- ok =
299- bufwrite_f64(&payload, x) &&
300- bufwrite_f64(&payload, feet_y) &&
301- bufwrite_f64(&payload, z) &&
302- bufwrite_f32(&payload, yaw) &&
303- bufwrite_f32(&payload, pitch) &&
304- bufwrite_u8(&payload, grounded ? 1 : 0) &&
305- /* player (look) position */
306- mc_client_write(client, 0x06, payload.data, payload.size);
307+ ok = bufwrite_f64(&payload, x) && bufwrite_f64(&payload, feet_y) && bufwrite_f64(&payload, z) &&
308+ bufwrite_f32(&payload, yaw) && bufwrite_f32(&payload, pitch) && bufwrite_u8(&payload, grounded ? 1 : 0) &&
309+ /* player (look) position */
310+ mc_client_write(client, 0x06, payload.data, payload.size);
311
312 buffree(&payload);
313 return ok;
314 }
315
316-const char* mc_client_username(const MCClient* client) { return client ? client->username : ""; }
317+const char* mc_client_username(const MCClient* client)
318+{
319+ return client ? client->username : "";
320+}
321
322-const char* mc_client_uuid(const MCClient* client) { return client ? client->uuid : ""; }
323+const char* mc_client_uuid(const MCClient* client)
324+{
325+ return client ? client->uuid : "";
326+}
+13,
-18
1@@ -39,8 +39,7 @@ static int der_length(DERReader* reader, size_t* length)
2 static int der_value(DERReader* reader, u8 tag, DERReader* value)
3 {
4 size_t length;
5- if (reader->cursor >= reader->size || reader->data[reader->cursor++] != tag ||
6- !der_length(reader, &length))
7+ if (reader->cursor >= reader->size || reader->data[reader->cursor++] != tag || !der_length(reader, &length))
8 return 0;
9 value->data = reader->data + reader->cursor;
10 value->size = length;
11@@ -50,8 +49,7 @@ static int der_value(DERReader* reader, u8 tag, DERReader* value)
12 }
13
14 /* parse the server's X.509 RSA pubkey for BearSSL */
15-static int rsa_public_key(const u8* der, size_t der_size, br_rsa_public_key* key, char* error,
16- size_t error_size)
17+static int rsa_public_key(const u8* der, size_t der_size, br_rsa_public_key* key, char* error, size_t error_size)
18 {
19 DERReader root = { der, der_size, 0 };
20 DERReader spki;
21@@ -61,14 +59,13 @@ static int rsa_public_key(const u8* der, size_t der_size, br_rsa_public_key* key
22 DERReader modulus;
23 DERReader exponent;
24
25- if (!der_value(&root, 0x30, &spki) || !der_value(&spki, 0x30, &algorithm) ||
26- !der_value(&spki, 0x03, &bits) || bits.size < 1 || bits.data[0] != 0) {
27+ if (!der_value(&root, 0x30, &spki) || !der_value(&spki, 0x30, &algorithm) || !der_value(&spki, 0x03, &bits) ||
28+ bits.size < 1 || bits.data[0] != 0) {
29 mc_set_error(error, error_size, "invalid X.509 RSA public key");
30 return 0;
31 }
32 bits.cursor = 1;
33- if (!der_value(&bits, 0x30, &rsa) || !der_value(&rsa, 0x02, &modulus) ||
34- !der_value(&rsa, 0x02, &exponent)) {
35+ if (!der_value(&bits, 0x30, &rsa) || !der_value(&rsa, 0x02, &modulus) || !der_value(&rsa, 0x02, &exponent)) {
36 mc_set_error(error, error_size, "invalid RSA public key integers");
37 return 0;
38 }
39@@ -124,9 +121,8 @@ void mc_cipher_decrypt(MCCipher* cipher, u8* data, size_t size)
40 }
41 }
42
43-int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message,
44- size_t message_size, u8** encrypted, size_t* encrypted_size, char* error,
45- size_t error_size)
46+int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message, size_t message_size, u8** encrypted,
47+ size_t* encrypted_size, char* error, size_t error_size)
48 {
49 br_rsa_public_key key;
50 br_rsa_public rsa;
51@@ -159,8 +155,7 @@ int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* messa
52 while (output[2 + i] == 0) {
53 if (!mg_random_bytes(output + 2 + i, 1)) {
54 free(output);
55- mc_set_error(error, error_size,
56- "could not obtain secure random bytes");
57+ mc_set_error(error, error_size, "could not obtain secure random bytes");
58 return 0;
59 }
60 }
61@@ -192,8 +187,8 @@ static void twos_complement(u8* data, size_t size)
62 }
63 }
64
65-void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key,
66- size_t public_key_size, char output[42])
67+void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key, size_t public_key_size,
68+ char output[42])
69 {
70 static const char hex[] = "0123456789abcdef";
71 br_sha1_context sha;
72@@ -218,7 +213,8 @@ void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8*
73 output[out++] = '-';
74 if (first == sizeof(digest)) {
75 output[out++] = '0';
76- } else {
77+ }
78+ else {
79 output[out++] = hex[digest[first] >> 4];
80 output[out++] = hex[digest[first] & 15];
81 for (i = first + 1; i < sizeof(digest); ++i) {
82@@ -226,8 +222,7 @@ void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8*
83 output[out++] = hex[digest[i] & 15];
84 }
85 if (output[negative ? 1 : 0] == '0') {
86- memmove(output + (negative ? 1 : 0), output + (negative ? 2 : 1),
87- out - (negative ? 2 : 1));
88+ memmove(output + (negative ? 1 : 0), output + (negative ? 2 : 1), out - (negative ? 2 : 1));
89 --out;
90 }
91 }
+6,
-7
1@@ -64,12 +64,11 @@ int bufread_bytes(MCBuffer* buffer, const u8** value, size_t* size);
2 void mc_cipher_init(MCCipher* cipher, const u8 key[16]);
3 void mc_cipher_encrypt(MCCipher* cipher, u8* data, size_t size);
4 void mc_cipher_decrypt(MCCipher* cipher, u8* data, size_t size);
5-int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message,
6- size_t message_size, u8** encrypted, size_t* encrypted_size, char* error,
7- size_t error_size);
8-void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key,
9- size_t public_key_size, char output[42]);
10-int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16],
11- const u8* public_key, size_t public_key_size, char* error, size_t error_size);
12+int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message, size_t message_size, u8** encrypted,
13+ size_t* encrypted_size, char* error, size_t error_size);
14+void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key, size_t public_key_size,
15+ char output[42]);
16+int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16], const u8* public_key,
17+ size_t public_key_size, char* error, size_t error_size);
18
19 #endif /* MCPROTO_INTERNAL_H */
+6,
-14
1@@ -19,7 +19,6 @@ static i8 packet_read(PacketReader* reader, void* output, size_t size)
2 return 1;
3 }
4
5-
6 PacketReader packet_reader_init(const void* data, size_t size)
7 {
8 PacketReader reader = { data, size, 0 };
9@@ -38,26 +37,20 @@ i8 packet_read_u16(PacketReader* reader, u16* value)
10 if (!packet_read(reader, data, 2))
11 return 0;
12
13- *value =
14- ((u16)data[0] << 8) |
15- (u16)data[1];
16+ *value = ((u16)data[0] << 8) | (u16)data[1];
17
18 return 1;
19 }
20
21 i8 packet_read_i32(PacketReader* reader, i32* value)
22 {
23- u8 data[4];
24+ u8 data[4];
25 u32 result;
26
27 if (!packet_read(reader, data, 4))
28 return 0;
29
30- result =
31- ((u32)data[0] << 24) |
32- ((u32)data[1] << 16) |
33- ((u32)data[2] << 8) |
34- (u32)data[3];
35+ result = ((u32)data[0] << 24) | ((u32)data[1] << 16) | ((u32)data[2] << 8) | (u32)data[3];
36
37 *value = (i32)result;
38 return 1;
39@@ -65,7 +58,7 @@ i8 packet_read_i32(PacketReader* reader, i32* value)
40
41 i8 packet_read_u64(PacketReader* reader, u64* value)
42 {
43- u8 data[8];
44+ u8 data[8];
45 u64 result;
46 i32 i;
47
48@@ -106,12 +99,12 @@ i8 packet_read_f64(PacketReader* reader, double* value)
49 i8 packet_read_varint(PacketReader* reader, i32* value)
50 {
51 u32 result;
52- u8 byte;
53+ u8 byte;
54 i32 shift;
55
56 result = 0;
57
58- for (shift = 0; shift < 7*5; shift += 7) { /* varints have max 5 bytes */
59+ for (shift = 0; shift < 7 * 5; shift += 7) { /* varints have max 5 bytes */
60 if (!packet_read_u8(reader, &byte))
61 return 0;
62
63@@ -125,4 +118,3 @@ i8 packet_read_varint(PacketReader* reader, i32* value)
64
65 return 0;
66 }
67-
+3,
-3
1@@ -4,14 +4,14 @@
2 #include <stddef.h>
3
4 #if defined(__linux__)
5-#include <sys/random.h>
6+ #include <sys/random.h>
7 #elif defined(__APPLE__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
8 defined(__DragonFly__) || defined(__illumos__)
9-#include <stdlib.h>
10+ #include <stdlib.h>
11 #elif defined(_WIN32)
12 /* TODO: Windows shi*/
13 #else
14-#error "mg_random_bytes needs a platform CSPRNG implementation"
15+ #error "mg_random_bytes needs a platform CSPRNG implementation"
16 #endif
17
18 int mg_random_bytes(u8* data, size_t size)
+45,
-13
1@@ -9,7 +9,10 @@ static MGVec3 mg_from_hmm_v3(HMM_Vec3 vec);
2 static MGVec4 mg_from_hmm_v4(HMM_Vec4 vec);
3 static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat);
4
5-static HMM_Vec3 mg_to_hmm_v3(MGVec3 vec) { return HMM_V3(vec.x, vec.y, vec.z); }
6+static HMM_Vec3 mg_to_hmm_v3(MGVec3 vec)
7+{
8+ return HMM_V3(vec.x, vec.y, vec.z);
9+}
10
11 static HMM_Mat4 mg_to_hmm_m4(MGMat4 mat)
12 {
13@@ -72,19 +75,40 @@ static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat)
14 return result;
15 }
16
17-float MG_SinF(float angle) { return HMM_SinF(angle); }
18+float MG_SinF(float angle)
19+{
20+ return HMM_SinF(angle);
21+}
22
23-float MG_CosF(float angle) { return HMM_CosF(angle); }
24+float MG_CosF(float angle)
25+{
26+ return HMM_CosF(angle);
27+}
28
29-float MG_TanF(float angle) { return HMM_TanF(angle); }
30+float MG_TanF(float angle)
31+{
32+ return HMM_TanF(angle);
33+}
34
35-float MG_SqrtF(float value) { return HMM_SqrtF(value); }
36+float MG_SqrtF(float value)
37+{
38+ return HMM_SqrtF(value);
39+}
40
41-MGVec2 MG_V2(float x, float y) { return mg_from_hmm_v2(HMM_V2(x, y)); }
42+MGVec2 MG_V2(float x, float y)
43+{
44+ return mg_from_hmm_v2(HMM_V2(x, y));
45+}
46
47-MGVec3 MG_V3(float x, float y, float z) { return mg_from_hmm_v3(HMM_V3(x, y, z)); }
48+MGVec3 MG_V3(float x, float y, float z)
49+{
50+ return mg_from_hmm_v3(HMM_V3(x, y, z));
51+}
52
53-MGVec4 MG_V4(float x, float y, float z, float w) { return mg_from_hmm_v4(HMM_V4(x, y, z, w)); }
54+MGVec4 MG_V4(float x, float y, float z, float w)
55+{
56+ return mg_from_hmm_v4(HMM_V4(x, y, z, w));
57+}
58
59 MGVec3 MG_AddV3(MGVec3 left, MGVec3 right)
60 {
61@@ -111,11 +135,20 @@ MGVec3 MG_Cross(MGVec3 left, MGVec3 right)
62 return mg_from_hmm_v3(HMM_Cross(mg_to_hmm_v3(left), mg_to_hmm_v3(right)));
63 }
64
65-MGVec3 MG_NormV3(MGVec3 vec) { return mg_from_hmm_v3(HMM_NormV3(mg_to_hmm_v3(vec))); }
66+MGVec3 MG_NormV3(MGVec3 vec)
67+{
68+ return mg_from_hmm_v3(HMM_NormV3(mg_to_hmm_v3(vec)));
69+}
70
71-MGMat4 MG_M4(void) { return mg_from_hmm_m4(HMM_M4()); }
72+MGMat4 MG_M4(void)
73+{
74+ return mg_from_hmm_m4(HMM_M4());
75+}
76
77-MGMat4 MG_M4D(float diagonal) { return mg_from_hmm_m4(HMM_M4D(diagonal)); }
78+MGMat4 MG_M4D(float diagonal)
79+{
80+ return mg_from_hmm_m4(HMM_M4D(diagonal));
81+}
82
83 MGMat4 MG_MulM4(MGMat4 left, MGMat4 right)
84 {
85@@ -134,6 +167,5 @@ MGMat4 MG_Perspective_RH_NO(float fov_y, float aspect, float near_z, float far_z
86
87 MGMat4 MG_LookAt_RH(MGVec3 eye, MGVec3 center, MGVec3 up)
88 {
89- return mg_from_hmm_m4(
90- HMM_LookAt_RH(mg_to_hmm_v3(eye), mg_to_hmm_v3(center), mg_to_hmm_v3(up)));
91+ return mg_from_hmm_m4(HMM_LookAt_RH(mg_to_hmm_v3(eye), mg_to_hmm_v3(center), mg_to_hmm_v3(up)));
92 }
+32,
-8
1@@ -1,28 +1,52 @@
2 #include "renderer/renderer.h"
3 #include "renderer_backend.h"
4
5-void renderer_create(MGContext* ctx) { renderer_backend_create(ctx); }
6+void renderer_create(MGContext* ctx)
7+{
8+ renderer_backend_create(ctx);
9+}
10
11-void renderer_begin(void) { renderer_backend_begin(); }
12+void renderer_begin(void)
13+{
14+ renderer_backend_begin();
15+}
16
17-void renderer_end(void) { renderer_backend_end(); }
18+void renderer_end(void)
19+{
20+ renderer_backend_end();
21+}
22
23-void renderer_destroy(void) { renderer_backend_destroy(); }
24+void renderer_destroy(void)
25+{
26+ renderer_backend_destroy();
27+}
28
29-MGMesh renderer_mesh_create(const MGMeshDesc* desc) { return renderer_backend_mesh_create(desc); }
30+MGMesh renderer_mesh_create(const MGMeshDesc* desc)
31+{
32+ return renderer_backend_mesh_create(desc);
33+}
34
35 void renderer_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mvp)
36 {
37 renderer_backend_mesh_draw(mesh, texture, mvp);
38 }
39
40-void renderer_mesh_destroy(MGMesh mesh) { renderer_backend_mesh_destroy(mesh); }
41+void renderer_mesh_destroy(MGMesh mesh)
42+{
43+ renderer_backend_mesh_destroy(mesh);
44+}
45
46-MGTexture renderer_texture_load(const char* path) { return renderer_backend_texture_load(path); }
47+MGTexture renderer_texture_load(const char* path)
48+{
49+ return renderer_backend_texture_load(path);
50+}
51
52 MGTexture renderer_texture_create(const MGTextureDesc* desc)
53 {
54 return renderer_backend_texture_create(desc);
55 }
56
57-void renderer_texture_destroy(MGTexture texture) { renderer_backend_texture_destroy(texture); }
58+void renderer_texture_destroy(MGTexture texture)
59+{
60+ renderer_backend_texture_destroy(texture);
61+}
+38,
-42
1@@ -3,7 +3,7 @@
2 #include <stb_image_c89.h>
3
4 #ifdef MG_PLATFORM_SDL
5-#include <SDL2/SDL.h>
6+ #include <SDL2/SDL.h>
7 #endif
8
9 #include "util.h"
10@@ -87,13 +87,12 @@ static void destroy_screen_texture(void);
11
12 static ClipVertex transform_vertex(const MGMat4* mvp, const MGVertex* v);
13 static i8 triangle_outside(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
14-static i8 triangle_front_facing(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
15-static S3L_Vec4 clip_to_screen(const ClipVertex* v);
16-static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture,
17- const S3L_PixelInfo* pixel);
18-static u16 rgba_to_rgb565(u32 rgba);
19-static u32 rgb565_to_argb(u16 rgb);
20-static u32 pack_texture_pixel(u32 rgba);
21+static i8 triangle_front_facing(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
22+static S3L_Vec4 clip_to_screen(const ClipVertex* v);
23+static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture, const S3L_PixelInfo* pixel);
24+static u16 rgba_to_rgb565(u32 rgba);
25+static u32 rgb565_to_argb(u16 rgb);
26+static u32 pack_texture_pixel(u32 rgba);
27
28 static inline void small3dlib_pixel(S3L_PixelInfo* pixel)
29 {
30@@ -138,8 +137,7 @@ static void create_screen_texture(i32 width, i32 height)
31 return;
32
33 if (width > S3L_MAX_WIDTH || height > S3L_MAX_HEIGHT)
34- mg_die(MG_ERR_REN_CREATE, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH,
35- S3L_MAX_HEIGHT);
36+ mg_die(MG_ERR_REN_CREATE, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH, S3L_MAX_HEIGHT);
37
38 pixel_count = (u64)width * (u64)height;
39 framebuffer = malloc(pixel_count * sizeof(*framebuffer));
40@@ -154,8 +152,7 @@ static void create_screen_texture(i32 width, i32 height)
41 SDL_TEXTUREACCESS_STREAMING, width, height);
42
43 if (!ren.screen_texture)
44- mg_die(MG_ERR_REN_CREATE, "Failed to create small3dlib texture: %s",
45- SDL_GetError());
46+ mg_die(MG_ERR_REN_CREATE, "Failed to create small3dlib texture: %s", SDL_GetError());
47 #endif
48
49 free(ren.framebuffer);
50@@ -186,14 +183,14 @@ static ClipVertex transform_vertex(const MGMat4* mvp, const MGVertex* v)
51 {
52 ClipVertex r;
53
54- r.x = mvp->Elements[0][0] * v->x + mvp->Elements[1][0] * v->y + mvp->Elements[2][0] * v->z +
55- mvp->Elements[3][0];
56- r.y = mvp->Elements[0][1] * v->x + mvp->Elements[1][1] * v->y + mvp->Elements[2][1] * v->z +
57- mvp->Elements[3][1];
58- r.z = mvp->Elements[0][2] * v->x + mvp->Elements[1][2] * v->y + mvp->Elements[2][2] * v->z +
59- mvp->Elements[3][2];
60- r.w = mvp->Elements[0][3] * v->x + mvp->Elements[1][3] * v->y + mvp->Elements[2][3] * v->z +
61- mvp->Elements[3][3];
62+ r.x =
63+ mvp->Elements[0][0] * v->x + mvp->Elements[1][0] * v->y + mvp->Elements[2][0] * v->z + mvp->Elements[3][0];
64+ r.y =
65+ mvp->Elements[0][1] * v->x + mvp->Elements[1][1] * v->y + mvp->Elements[2][1] * v->z + mvp->Elements[3][1];
66+ r.z =
67+ mvp->Elements[0][2] * v->x + mvp->Elements[1][2] * v->y + mvp->Elements[2][2] * v->z + mvp->Elements[3][2];
68+ r.w =
69+ mvp->Elements[0][3] * v->x + mvp->Elements[1][3] * v->y + mvp->Elements[2][3] * v->z + mvp->Elements[3][3];
70
71 return r;
72 }
73@@ -251,8 +248,7 @@ static S3L_Vec4 clip_to_screen(const ClipVertex* v)
74 return r;
75 }
76
77-static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture,
78- const S3L_PixelInfo* pixel)
79+static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture, const S3L_PixelInfo* pixel)
80 {
81 u32 sampled;
82 u32 colour;
83@@ -284,22 +280,22 @@ static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* textu
84 ren.tri_uvs[5] = (i32)(v[2]->v * (float)texture->height);
85 }
86
87- weighted_x = pixel->barycentric[0] * ren.tri_uvs[0] +
88- pixel->barycentric[1] * ren.tri_uvs[2] +
89+ weighted_x = pixel->barycentric[0] * ren.tri_uvs[0] + pixel->barycentric[1] * ren.tri_uvs[2] +
90 pixel->barycentric[2] * ren.tri_uvs[4];
91- weighted_y = pixel->barycentric[0] * ren.tri_uvs[1] +
92- pixel->barycentric[1] * ren.tri_uvs[3] +
93+ weighted_y = pixel->barycentric[0] * ren.tri_uvs[1] + pixel->barycentric[1] * ren.tri_uvs[3] +
94 pixel->barycentric[2] * ren.tri_uvs[5];
95 x = weighted_x >> 9;
96 y = weighted_y >> 9;
97 if (x < 0) {
98 x = 0;
99- } else if (x >= texture->width) {
100+ }
101+ else if (x >= texture->width) {
102 x = texture->width - 1;
103 }
104 if (y < 0) {
105 y = 0;
106- } else if (y >= texture->height) {
107+ }
108+ else if (y >= texture->height) {
109 y = texture->height - 1;
110 }
111 sampled = texture->pixels[y * texture->width + x];
112@@ -332,7 +328,10 @@ static u32 rgb565_to_argb(u16 rgb)
113 return 0xff000000 | (r << 16) | (g << 8) | b;
114 }
115
116-static u32 pack_texture_pixel(u32 rgba) { return ((rgba >> 24) << 24) | rgba_to_rgb565(rgba); }
117+static u32 pack_texture_pixel(u32 rgba)
118+{
119+ return ((rgba >> 24) << 24) | rgba_to_rgb565(rgba);
120+}
121
122 void renderer_backend_create(MGContext* ctx)
123 {
124@@ -381,8 +380,8 @@ void renderer_backend_begin(void)
125 void renderer_backend_end(void)
126 {
127 #ifdef MG_PLATFORM_MAUS
128- i32 x;
129- i32 y;
130+ i32 x;
131+ i32 y;
132 u32* dst;
133 #endif
134
135@@ -390,8 +389,7 @@ void renderer_backend_end(void)
136 return;
137
138 #ifdef MG_PLATFORM_SDL
139- SDL_UpdateTexture(ren.screen_texture, NULL, ren.framebuffer,
140- ren.width * (i32)sizeof(*ren.framebuffer));
141+ SDL_UpdateTexture(ren.screen_texture, NULL, ren.framebuffer, ren.width * (i32)sizeof(*ren.framebuffer));
142 SDL_RenderClear(ren.ctx->vbe.renderer);
143 SDL_RenderCopy(ren.ctx->vbe.renderer, ren.screen_texture, NULL, NULL);
144 #else
145@@ -400,7 +398,8 @@ void renderer_backend_end(void)
146 i32 sy = y * ren.height / ren.ctx->win->height;
147 for (x = 0; (u32)x < ren.ctx->win->width; x++) {
148 i32 sx = x * ren.width / ren.ctx->win->width;
149- dst[(u32)y * ren.ctx->win->stride + (u32)x] = rgb565_to_argb(ren.framebuffer[sy * ren.width + sx]);
150+ dst[(u32)y * ren.ctx->win->stride + (u32)x] =
151+ rgb565_to_argb(ren.framebuffer[sy * ren.width + sx]);
152 }
153 }
154 #endif
155@@ -499,13 +498,11 @@ void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mv
156 if (rmesh->vc > ren.scratch_capacity) {
157 ClipVertex* clip_vertices;
158 S3L_Vec4* screen_vertices;
159- clip_vertices =
160- (ClipVertex*)realloc(ren.clip_vertices, rmesh->vc * sizeof(*clip_vertices));
161+ clip_vertices = (ClipVertex*)realloc(ren.clip_vertices, rmesh->vc * sizeof(*clip_vertices));
162 if (!clip_vertices)
163 return;
164 ren.clip_vertices = clip_vertices;
165- screen_vertices =
166- (S3L_Vec4*)realloc(ren.screen_vertices, rmesh->vc * sizeof(*screen_vertices));
167+ screen_vertices = (S3L_Vec4*)realloc(ren.screen_vertices, rmesh->vc * sizeof(*screen_vertices));
168 if (!screen_vertices)
169 return;
170 ren.screen_vertices = screen_vertices;
171@@ -535,8 +532,8 @@ void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mv
172 if (!triangle_front_facing(ca, cb, cc))
173 continue;
174
175- S3L_drawTriangle(ren.screen_vertices[ia], ren.screen_vertices[ib],
176- ren.screen_vertices[ic], 0, (S3L_Index)(tri / 3));
177+ S3L_drawTriangle(ren.screen_vertices[ia], ren.screen_vertices[ib], ren.screen_vertices[ic], 0,
178+ (S3L_Index)(tri / 3));
179 }
180
181 ren.active_mesh = NULL;
182@@ -614,8 +611,7 @@ MGTexture renderer_backend_texture_create(const MGTextureDesc* desc)
183
184 for (i = 0; i < pixel_count; ++i) {
185 const u8* source = desc->pixels + i * 4;
186- u32 rgba = (u32)source[0] | ((u32)source[1] << 8) | ((u32)source[2] << 16) |
187- ((u32)source[3] << 24);
188+ u32 rgba = (u32)source[0] | ((u32)source[1] << 8) | ((u32)source[2] << 16) | ((u32)source[3] << 24);
189 texture->pixels[i] = pack_texture_pixel(rgba);
190 }
191 texture->width = desc->width;
+3,
-6
1@@ -44,8 +44,7 @@ static void create_pipelines(void);
2 static void create_sampler(void);
3
4 /* logging function for passing to sokol */
5-static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln,
6- const char* file, void* user);
7+static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln, const char* file, void* user);
8
9 static RendererState ren;
10 /* TODO: textures */
11@@ -143,8 +142,7 @@ static void create_sampler(void)
12 mg_die(MG_ERR_SAMPLER_CREATE, "Failed to create sampler");
13 }
14
15-static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln,
16- const char* file, void* user)
17+static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln, const char* file, void* user)
18 {
19 LogType type;
20 (void)item;
21@@ -152,8 +150,7 @@ static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32
22
23 type = level <= 1 ? LOG_ERR : LOG_DBG;
24
25- mg_log(type, "%s: %s [%s:%u]", tag ? tag : "Sokol", msg ? msg : "No message",
26- file ? file : "Unknown", ln);
27+ mg_log(type, "%s: %s [%s:%u]", tag ? tag : "Sokol", msg ? msg : "No message", file ? file : "Unknown", ln);
28 }
29
30 void renderer_backend_create(MGContext* ctx)
+2,
-1
1@@ -40,7 +40,8 @@ void mg_log(LogType lt, const char* fmt, ...)
2
3 if (lt == LOG_DBG || lt == LOG_ERR) {
4 fd = stderr;
5- } else {
6+ }
7+ else {
8 fd = stdout;
9 }
10
+4,
-2
1@@ -207,12 +207,14 @@ static void model_rotate(BlockModel* model, i32 first, cJSON* rotation)
2 b = value[2];
3 value[1] = a * cosine - b * sine;
4 value[2] = a * sine + b * cosine;
5- } else if (axis[0] == 'y') {
6+ }
7+ else if (axis[0] == 'y') {
8 a = value[2];
9 b = value[0];
10 value[2] = a * cosine - b * sine;
11 value[0] = a * sine + b * cosine;
12- } else {
13+ }
14+ else {
15 a = value[0];
16 b = value[1];
17 value[0] = a * cosine - b * sine;
+24,
-24
1@@ -6,15 +6,16 @@
2
3 #define MAX_MESH_VERTICES 65535U
4
5-static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count,
6- const BlockFace* face, i32 x, i32 y, i32 z);
7+static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count, const BlockFace* face,
8+ i32 x, i32 y, i32 z);
9
10 /* 6 = number of faces on a cube */
11-static const i32 face_offsets[6][3] = { { 0, 0, -1 }, { 0, 0, 1 }, { -1, 0, 0 },
12- { 1, 0, 0 }, { 0, -1, 0 }, { 0, 1, 0 } };
13+static const i32 face_offsets[6][3] = {
14+ { 0, 0, -1 }, { 0, 0, 1 }, { -1, 0, 0 }, { 1, 0, 0 }, { 0, -1, 0 }, { 0, 1, 0 }
15+};
16
17-static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count,
18- const BlockFace* face, i32 x, i32 y, i32 z)
19+static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count, const BlockFace* face,
20+ i32 x, i32 y, i32 z)
21 {
22 MGVertex vtx;
23 u32 base;
24@@ -102,21 +103,21 @@ void chunk_set(Chunk* chunk, i32 x, i32 y, i32 z, BlockType block)
25
26 i8 chunk_mesh_create(Chunk* chunk)
27 {
28- MGVertex* vertices[BLOCK_TEXTURE_COUNT];
29- u16* indices[BLOCK_TEXTURE_COUNT];
30- u32 face_counts[BLOCK_TEXTURE_COUNT];
31- u32 vertex_counts[BLOCK_TEXTURE_COUNT];
32- u32 index_counts[BLOCK_TEXTURE_COUNT];
33- MGMeshDesc desc;
34- BlockType block;
35- BlockType neighbour;
36+ MGVertex* vertices[BLOCK_TEXTURE_COUNT];
37+ u16* indices[BLOCK_TEXTURE_COUNT];
38+ u32 face_counts[BLOCK_TEXTURE_COUNT];
39+ u32 vertex_counts[BLOCK_TEXTURE_COUNT];
40+ u32 index_counts[BLOCK_TEXTURE_COUNT];
41+ MGMeshDesc desc;
42+ BlockType block;
43+ BlockType neighbour;
44 const BlockFace* faces;
45- i32 face_count;
46- i32 texture;
47- i32 face;
48- i32 x;
49- i32 y;
50- i32 z;
51+ i32 face_count;
52+ i32 texture;
53+ i32 face;
54+ i32 x;
55+ i32 y;
56+ i32 z;
57
58 if (!chunk)
59 return 0;
60@@ -196,12 +197,11 @@ i8 chunk_mesh_create(Chunk* chunk)
61 z + face_offsets[texture][2]);
62 if (neighbour != BLOCK_AIR && block_model_occludes(neighbour))
63 continue;
64- }
65+ }
66
67 texture = faces[face].texture;
68- add_face(vertices[texture], indices[texture],
69- &vertex_counts[texture], &index_counts[texture], &faces[face],
70- x, y, z);
71+ add_face(vertices[texture], indices[texture], &vertex_counts[texture],
72+ &index_counts[texture], &faces[face], x, y, z);
73 }
74 }
75 }