commit f9537fc
shrub
·
2026-07-31 18:05:54 +0000 UTC
parent baa5105
format + doc
29 files changed,
+554,
-705
+12,
-2
1@@ -1,13 +1,23 @@
2 AlignConsecutiveDeclarations: Consecutive
3 AlignEscapedNewlines: DontAlign
4 AlignTrailingComments: false
5-BreakBeforeBraces: Linux
6-ColumnLimit: 0
7+BreakBeforeBraces: Custom
8+BraceWrapping:
9+ AfterControlStatement: Never
10+ AfterFunction: true
11+ BeforeElse: false
12+ColumnLimit: 100
13 Cpp11BracedListStyle: false
14+AllowAllParametersOfDeclarationOnNextLine: false
15+AllowShortIfStatementsOnASingleLine: Never
16+AllowShortLoopsOnASingleLine: false
17+BinPackParameters: true
18 IndentCaseLabels: false
19 IndentPPDirectives: None
20 IndentWidth: 8
21+PenaltyReturnTypeOnItsOwnLine: 1000
22 PointerAlignment: Left
23+ReflowComments: false
24 SortIncludes: false
25 TabWidth: 8
26 UseTab: ForIndentation
+0,
-1
1@@ -30,4 +30,3 @@ extern MGConfig mg_config;
2 void config_default(void);
3
4 #endif /* CONFIG_H */
5-
+6,
-10
1@@ -16,22 +16,18 @@ typedef struct {
2 } MCAccount;
3
4 typedef struct {
5- i32 id;
6- u8* data;
7+ i32 id;
8+ u8* data;
9 size_t size;
10 } MCPacket;
11
12-int mc_client_login(
13- MCClient** out,
14- const char* address,
15- const MCAccount* account,
16- char* error,
17- size_t error_size);
18+int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error,
19+ size_t error_size);
20 void mc_client_interrupt(MCClient* client);
21 void mc_client_destroy(MCClient* client);
22
23-int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error_size);
24-int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t size);
25+int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error_size);
26+int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t size);
27 void mc_packet_free(MCPacket* packet);
28
29 const char* mc_client_username(const MCClient* client);
+1,
-1
1@@ -41,7 +41,7 @@ MGVec4 MG_V4(float x, float y, float z, float w);
2 MGVec3 MG_AddV3(MGVec3 left, MGVec3 right);
3 MGVec3 MG_SubV3(MGVec3 left, MGVec3 right);
4 MGVec3 MG_MulV3F(MGVec3 left, float right);
5-float MG_DotV3(MGVec3 left, MGVec3 right);
6+float MG_DotV3(MGVec3 left, MGVec3 right);
7 MGVec3 MG_Cross(MGVec3 left, MGVec3 right);
8 MGVec3 MG_NormV3(MGVec3 vec);
9
+6,
-6
1@@ -17,13 +17,13 @@ typedef struct {
2 } MGVidBE;
3
4 typedef struct {
5- MGWindow* win;
6- MGVidBE vbe;
7+ MGWindow* win;
8+ MGVidBE vbe;
9 const char* title;
10- i32 x;
11- i32 y;
12- i32 width;
13- i32 height;
14+ i32 x;
15+ i32 y;
16+ i32 width;
17+ i32 height;
18 } MGContext;
19
20 /* get drawable screen size. usually different due to hi-dpi options
+5,
-5
1@@ -13,8 +13,8 @@ typedef u32 MGTexture;
2
3 typedef struct {
4 const u8* pixels;
5- i32 width;
6- i32 height;
7+ i32 width;
8+ i32 height;
9 } MGTextureDesc;
10
11 typedef struct {
12@@ -30,9 +30,9 @@ typedef struct {
13
14 typedef struct {
15 const MGVertex* vtc; /* vertices */
16- u32 vtcc; /* vertices count */
17- const u16* idc; /* indecies */
18- u32 idcc; /* indecies count */
19+ u32 vtcc; /* vertices count */
20+ const u16* idc; /* indecies */
21+ u32 idcc; /* indecies count */
22 } MGMeshDesc;
23
24 /* create renderer with chosen context
+1,
-5
1@@ -3,11 +3,7 @@
2
3 #include "renderer/renderer.h"
4
5-#define RGBA(r, g, b, a) ( \
6- ((u32)(r)) | \
7- ((u32)(g) << 8) | \
8- ((u32)(b) << 16) | \
9- ((u32)(a) << 24))
10+#define RGBA(r, g, b, a) (((u32)(r)) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
11
12 MGMesh block_mesh_create(void);
13
+20,
-18
1@@ -9,23 +9,26 @@
2 #include "world/chunk.h"
3
4 static MGTexture block_textures[BLOCK_LAST];
5-static Chunk chunks[WORLD_WIDTH][WORLD_DEPTH];
6-static MGCamera cam;
7+static Chunk chunks[WORLD_WIDTH][WORLD_DEPTH];
8+static MGCamera cam;
9
10 void test_scene_create(void)
11 {
12 i32 x;
13 i32 z;
14
15- block_textures[BLOCK_BRICK] = renderer_texture_load("assets/resourcepacks/default/blocks/brick.png");
16+ block_textures[BLOCK_BRICK] =
17+ renderer_texture_load("assets/resourcepacks/default/blocks/brick.png");
18 if (block_textures[BLOCK_BRICK] == MGTEXTURE_INVALID)
19 mg_die(MG_ERR_TEXTURE_LOAD, "Failed to load brick texture");
20
21- block_textures[BLOCK_DIRT] = renderer_texture_load("assets/resourcepacks/default/blocks/dirt.png");
22+ block_textures[BLOCK_DIRT] =
23+ renderer_texture_load("assets/resourcepacks/default/blocks/dirt.png");
24 if (block_textures[BLOCK_DIRT] == MGTEXTURE_INVALID)
25 mg_die(MG_ERR_TEXTURE_LOAD, "Failed to load dirt texture");
26
27- block_textures[BLOCK_STONE] = renderer_texture_load("assets/resourcepacks/default/blocks/stone.png");
28+ block_textures[BLOCK_STONE] =
29+ renderer_texture_load("assets/resourcepacks/default/blocks/stone.png");
30 if (block_textures[BLOCK_STONE] == MGTEXTURE_INVALID)
31 mg_die(MG_ERR_TEXTURE_LOAD, "Failed to load stone texture");
32
33@@ -34,9 +37,7 @@ void test_scene_create(void)
34 chunk_create(&chunks[x][z]);
35
36 if (!chunk_mesh_create(&chunks[x][z]))
37- mg_die(
38- MG_ERR_MESH_CREATE,
39- "Failed to create chunk mesh");
40+ mg_die(MG_ERR_MESH_CREATE, "Failed to create chunk mesh");
41 }
42 }
43
44@@ -47,15 +48,15 @@ void test_scene_create(void)
45
46 void test_scene_draw(MGContext* ctx)
47 {
48- MGMat4 proj;
49- MGMat4 view;
50- MGMat4 mvp;
51- MGMat4 model;
52- i32 x;
53- i32 z;
54- i32 width;
55- i32 height;
56- float aspect;
57+ MGMat4 proj;
58+ MGMat4 view;
59+ MGMat4 mvp;
60+ MGMat4 model;
61+ i32 x;
62+ i32 z;
63+ i32 width;
64+ i32 height;
65+ float aspect;
66 BlockType block;
67
68 platform_get_drawable_size(ctx, &width, &height);
69@@ -76,7 +77,8 @@ void test_scene_draw(MGContext* ctx)
70 for (block = BLOCK_BRICK; block < BLOCK_LAST; block++) {
71 if (chunks[x][z].meshes[block] == MGMESH_INVALID)
72 continue;
73- renderer_mesh_draw(chunks[x][z].meshes[block], block_textures[block], &mvp);
74+ renderer_mesh_draw(chunks[x][z].meshes[block],
75+ block_textures[block], &mvp);
76 }
77 }
78 }
+5,
-5
1@@ -3,11 +3,11 @@
2
3 #include <stdint.h>
4
5-typedef int8_t i8;
6-typedef int16_t i16;
7-typedef int32_t i32;
8-typedef int64_t i64;
9-typedef uint8_t u8;
10+typedef int8_t i8;
11+typedef int16_t i16;
12+typedef int32_t i32;
13+typedef int64_t i64;
14+typedef uint8_t u8;
15 typedef uint16_t u16;
16 typedef uint32_t u32;
17 typedef uint64_t u64;
+1,
-5
1@@ -1,11 +1,7 @@
2 #ifndef UTIL_H
3 #define UTIL_H
4
5-#define RGBA(r, g, b, a) ( \
6- ((u32)(r)) | \
7- ((u32)(g) << 8) | \
8- ((u32)(b) << 16) | \
9- ((u32)(a) << 24))
10+#define RGBA(r, g, b, a) (((u32)(r)) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
11
12 typedef enum { /* TODO: rename to MG_EC_... */
13 MG_ERR_EXIT_SUCCESS,
+0,
-1
1@@ -11,4 +11,3 @@ typedef enum {
2 } BlockType;
3
4 #endif /* WORLD_BLOCK_H */
5-
+2,
-3
1@@ -14,10 +14,10 @@
2
3 typedef struct {
4 BlockType blocks[CHUNK_WIDTH][CHUNK_HEIGHT][CHUNK_DEPTH];
5- MGMesh meshes[BLOCK_LAST];
6+ MGMesh meshes[BLOCK_LAST];
7 } Chunk;
8
9-/* create a new chunk
10+/* create a new chunk
11 just stone and dirt with a hint of brick for now */
12 void chunk_create(Chunk* chunk);
13
14@@ -41,4 +41,3 @@ i8 chunk_mesh_create(Chunk* chunk);
15 void chunk_mesh_destroy(Chunk* chunk);
16
17 #endif /* CHUNK_H */
18-
+1,
-1
1@@ -47,7 +47,7 @@ void camera_rotate(MGCamera* cam, float dyaw, float dpitch)
2 MGVec3 camera_get_forward(const MGCamera* cam)
3 {
4 MGVec3 forward;
5- float pcos = MG_CosF(cam->pitch);
6+ float pcos = MG_CosF(cam->pitch);
7
8 forward.x = pcos * MG_SinF(cam->yaw);
9 forward.y = MG_SinF(cam->pitch);
+0,
-1
1@@ -23,4 +23,3 @@ void config_default(void)
2 /* temp */
3 mg_config.temp_movement_speed = 4.0f;
4 }
5-
+12,
-21
1@@ -12,13 +12,7 @@
2 #include "renderer/test_scene.h"
3
4 static MGContext ctx = {
5- NULL,
6- { NULL },
7- "Magnolia",
8- 0,
9- 0,
10- 1024,
11- 768,
12+ NULL, { NULL }, "Magnolia", 0, 0, 1024, 768,
13 };
14
15 static void input(void)
16@@ -26,12 +20,12 @@ static void input(void)
17 static u32 last;
18
19 const u8* keys = SDL_GetKeyboardState(NULL);
20- MGVec3 move = MG_V3(0.0f, 0.0f, 0.0f);
21- u32 now = SDL_GetTicks();
22- float sensitivity = mg_config.input_sensitivity;
23- float dt;
24- i32 mx;
25- i32 my;
26+ MGVec3 move = MG_V3(0.0f, 0.0f, 0.0f);
27+ u32 now = SDL_GetTicks();
28+ float sensitivity = mg_config.input_sensitivity;
29+ float dt;
30+ i32 mx;
31+ i32 my;
32
33 if (!last) {
34 last = now;
35@@ -64,7 +58,7 @@ static int protocol_poc(const char* address, const char* username)
36 {
37 MCAccount account;
38 MCClient* client;
39- char error[1024];
40+ char error[1024];
41
42 account.username = username;
43 account.profile_uuid = getenv("MANGOLIA_PROFILE_UUID");
44@@ -73,11 +67,9 @@ static int protocol_poc(const char* address, const char* username)
45 fprintf(stderr, "%s\n", error);
46 return MG_ERR_EXIT_FAILURE;
47 }
48- /*
49- * offline mode protocol test:
50- * packet keep alive is play/clientbound 0x00 in protocol 47
51- *https://prismarinejs.github.io/minecraft-data/protocol/pc/1.8/#play.toClient.types.packet_keep_alive
52- */
53+ /* offline mode protocol test:
54+ packet keep alive is play/clientbound 0x00 in protocol 47
55+ https://prismarinejs.github.io/minecraft-data/protocol/pc/1.8/#play.toClient.types.packet_keep_alive */
56 puts("entered play state: printing packet ids and echoing keepalives");
57 for (;;) {
58 MCPacket packet;
59@@ -86,8 +78,7 @@ static int protocol_poc(const char* address, const char* username)
60 mc_client_destroy(client);
61 return MG_ERR_EXIT_FAILURE;
62 }
63- printf("play packet 0x%02x size %lu\n",
64- packet.id, (unsigned long)packet.size);
65+ printf("play packet 0x%02x size %lu\n", packet.id, (unsigned long)packet.size);
66 if (packet.id == 0x00) {
67 if (!mc_client_write(client, 0x00, packet.data, packet.size)) {
68 fprintf(stderr, "failed to echo keepalive\n");
+68,
-50
1@@ -18,16 +18,44 @@ static int json_string(MCBuffer* buffer, const char* value)
2 if (!bufwrite_u8(buffer, '"'))
3 return 0;
4 while (*p) {
5- char escaped[7];
6+ char escaped[7];
7 size_t size = 1;
8 switch (*p) {
9- case '"': escaped[0] = '\\'; escaped[1] = '"'; size = 2; break;
10- case '\\': escaped[0] = '\\'; escaped[1] = '\\'; size = 2; break;
11- case '\b': escaped[0] = '\\'; escaped[1] = 'b'; size = 2; break;
12- case '\f': escaped[0] = '\\'; escaped[1] = 'f'; size = 2; break;
13- case '\n': escaped[0] = '\\'; escaped[1] = 'n'; size = 2; break;
14- case '\r': escaped[0] = '\\'; escaped[1] = 'r'; size = 2; break;
15- case '\t': escaped[0] = '\\'; escaped[1] = 't'; size = 2; break;
16+ case '"':
17+ escaped[0] = '\\';
18+ escaped[1] = '"';
19+ size = 2;
20+ break;
21+ case '\\':
22+ escaped[0] = '\\';
23+ escaped[1] = '\\';
24+ size = 2;
25+ break;
26+ case '\b':
27+ escaped[0] = '\\';
28+ escaped[1] = 'b';
29+ size = 2;
30+ break;
31+ case '\f':
32+ escaped[0] = '\\';
33+ escaped[1] = 'f';
34+ size = 2;
35+ break;
36+ case '\n':
37+ escaped[0] = '\\';
38+ escaped[1] = 'n';
39+ size = 2;
40+ break;
41+ case '\r':
42+ escaped[0] = '\\';
43+ escaped[1] = 'r';
44+ size = 2;
45+ break;
46+ case '\t':
47+ escaped[0] = '\\';
48+ escaped[1] = 't';
49+ size = 2;
50+ break;
51 default:
52 if (*p < 0x20) {
53 snprintf(escaped, sizeof(escaped), "\\u%04x", *p);
54@@ -46,7 +74,7 @@ static int json_string(MCBuffer* buffer, const char* value)
55 static int tls_write_all(struct tls* tls, const void* data, size_t size)
56 {
57 const u8* bytes = (const u8*)data;
58- size_t sent = 0;
59+ size_t sent = 0;
60
61 while (sent < size) {
62 ssize_t count = tls_write(tls, bytes + sent, size - sent);
63@@ -88,29 +116,24 @@ static long http_status(const MCBuffer* response)
64 return status;
65 }
66
67-int mc_join_server(
68- const MCAccount* account,
69- const char* server_id,
70- const u8 shared_secret[16],
71- const u8* public_key,
72- size_t public_key_size,
73- char* error,
74- size_t error_size)
75+int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16],
76+ const u8* public_key, size_t public_key_size, char* error, size_t error_size)
77 {
78 struct tls_config* config = NULL;
79- struct tls* tls = NULL;
80- MCBuffer json;
81- MCBuffer request;
82- MCBuffer response;
83- char hash[42];
84- char headers[512];
85- long status;
86- int ok = 0;
87-
88- if (!account->access_token || !account->access_token[0] ||
89- !account->profile_uuid || !account->profile_uuid[0]) {
90+ struct tls* tls = NULL;
91+ MCBuffer json;
92+ MCBuffer request;
93+ MCBuffer response;
94+ char hash[42];
95+ char headers[512];
96+ long status;
97+ int ok = 0;
98+
99+ if (!account->access_token || !account->access_token[0] || !account->profile_uuid ||
100+ !account->profile_uuid[0]) {
101 mc_set_error(error, error_size,
102- "online-mode server requires MANGOLIA_ACCESS_TOKEN and MANGOLIA_PROFILE_UUID");
103+ "online-mode server requires "
104+ "MANGOLIA_ACCESS_TOKEN and MANGOLIA_PROFILE_UUID");
105 return 0;
106 }
107
108@@ -121,10 +144,8 @@ int mc_join_server(
109 if (!bufwrite(&json, "{\"accessToken\":", 15) ||
110 !json_string(&json, account->access_token) ||
111 !bufwrite(&json, ",\"selectedProfile\":", 19) ||
112- !json_string(&json, account->profile_uuid) ||
113- !bufwrite(&json, ",\"serverId\":", 12) ||
114- !json_string(&json, hash) ||
115- !bufwrite_u8(&json, '}')) {
116+ !json_string(&json, account->profile_uuid) || !bufwrite(&json, ",\"serverId\":", 12) ||
117+ !json_string(&json, hash) || !bufwrite_u8(&json, '}')) {
118 mc_set_error(error, error_size, "out of memory building session request");
119 goto cleanup;
120 }
121@@ -140,24 +161,22 @@ int mc_join_server(
122 goto cleanup;
123 }
124 if (tls_configure(tls, config) != 0) {
125- mc_set_error(error, error_size, "libtls configure failed: %s",
126- tls_error(tls));
127+ mc_set_error(error, error_size, "libtls configure failed: %s", tls_error(tls));
128 goto cleanup;
129 }
130 if (tls_connect(tls, MC_JOIN_HOST, MC_JOIN_PORT) != 0) {
131- mc_set_error(error, error_size, "session TLS connect failed: %s",
132- tls_error(tls));
133+ mc_set_error(error, error_size, "session TLS connect failed: %s", tls_error(tls));
134 goto cleanup;
135 }
136 snprintf(headers, sizeof(headers),
137- "POST " MC_JOIN_PATH " HTTP/1.1\r\n"
138- "Host: " MC_JOIN_HOST "\r\n"
139- "User-Agent: Magnolia/1.8.9\r\n"
140- "Content-Type: application/json\r\n"
141- "Content-Length: %lu\r\n"
142- "Connection: close\r\n"
143- "\r\n",
144- (unsigned long)json.size);
145+ "POST " MC_JOIN_PATH " HTTP/1.1\r\n"
146+ "Host: " MC_JOIN_HOST "\r\n"
147+ "User-Agent: Magnolia/1.8.9\r\n"
148+ "Content-Type: application/json\r\n"
149+ "Content-Length: %lu\r\n"
150+ "Connection: close\r\n"
151+ "\r\n",
152+ (unsigned long)json.size);
153 if (!bufwrite(&request, headers, strlen(headers)) ||
154 !bufwrite(&request, json.data, json.size)) {
155 mc_set_error(error, error_size, "out of memory building session HTTP request");
156@@ -165,20 +184,19 @@ int mc_join_server(
157 }
158 if (!tls_write_all(tls, request.data, request.size)) {
159 mc_set_error(error, error_size, "session join request write failed: %s",
160- tls_error(tls));
161+ tls_error(tls));
162 goto cleanup;
163 }
164 if (!tls_read_response(tls, &response)) {
165 mc_set_error(error, error_size, "session join response read failed: %s",
166- tls_error(tls));
167+ tls_error(tls));
168 goto cleanup;
169 }
170 status = http_status(&response);
171 if (status != 204) {
172 size_t show = response.size < 400 ? response.size : 400;
173- mc_set_error(error, error_size,
174- "session server rejected join (HTTP %ld): %.*s",
175- status, (int)show, response.data ? (char*)response.data : "");
176+ mc_set_error(error, error_size, "session server rejected join (HTTP %ld): %.*s",
177+ status, (int)show, response.data ? (char*)response.data : "");
178 goto cleanup;
179 }
180 ok = 1;
+22,
-37
1@@ -16,10 +16,7 @@ void mc_set_error(char* error, size_t error_size, const char* fmt, ...)
2 va_end(args);
3 }
4
5-void bufinit(MCBuffer* buffer)
6-{
7- memset(buffer, 0, sizeof(*buffer));
8-}
9+void bufinit(MCBuffer* buffer) { memset(buffer, 0, sizeof(*buffer)); }
10
11 void buffree(MCBuffer* buffer)
12 {
13@@ -27,11 +24,12 @@ void buffree(MCBuffer* buffer)
14 memset(buffer, 0, sizeof(*buffer));
15 }
16
17+/* make sure an MCBuffer has can fit its current size + extra bytes */
18 int bufreserve(MCBuffer* buffer, size_t extra)
19 {
20 size_t needed;
21 size_t capacity;
22- u8* data;
23+ u8* data;
24
25 if (extra > MC_MAX_PACKET_SIZE || buffer->size > MC_MAX_PACKET_SIZE - extra)
26 return 0;
27@@ -64,18 +62,13 @@ int bufwrite(MCBuffer* buffer, const void* data, size_t size)
28 return 1;
29 }
30
31-int bufwrite_u8(MCBuffer* buffer, u8 value)
32-{
33- return bufwrite(buffer, &value, 1);
34-}
35+int bufwrite_u8(MCBuffer* buffer, u8 value) { return bufwrite(buffer, &value, 1); }
36
37 int bufwrite_u16(MCBuffer* buffer, u16 value)
38 {
39 u8 data[2];
40- /*
41- * minecraft protocol integers are big-endian except VarInt
42- * https://wikivg.booky.dev/Protocol#Data_types
43- */
44+ /* minecraft protocol integers are big-endian except VarInt
45+ https://wikivg.booky.dev/Protocol#Data_types */
46 data[0] = (u8)(value >> 8);
47 data[1] = (u8)value;
48 return bufwrite(buffer, data, sizeof(data));
49@@ -84,7 +77,7 @@ int bufwrite_u16(MCBuffer* buffer, u16 value)
50 int bufwrite_i32(MCBuffer* buffer, i32 value)
51 {
52 u32 v = (u32)value;
53- u8 data[4];
54+ u8 data[4];
55 data[0] = (u8)(v >> 24);
56 data[1] = (u8)(v >> 16);
57 data[2] = (u8)(v >> 8);
58@@ -95,7 +88,7 @@ int bufwrite_i32(MCBuffer* buffer, i32 value)
59 int bufwrite_i64(MCBuffer* buffer, i64 value)
60 {
61 u64 v = (u64)value;
62- u8 data[8];
63+ u8 data[8];
64 int i;
65 for (i = 0; i < 8; ++i)
66 data[i] = (u8)(v >> (56 - i * 8));
67@@ -119,10 +112,9 @@ int bufwrite_f64(MCBuffer* buffer, double value)
68 int bufwrite_varint(MCBuffer* buffer, i32 value)
69 {
70 u32 v = (u32)value;
71- /*
72- * minecraft VarInt is 7 data bits per byte (5 bytes max on i32) and high bit means more bytes follow
73- * https://wikivg.booky.dev/Protocol#VarInt_and_VarLong
74- */
75+ /* minecraft VarInt is 7 data bits per byte (5 bytes max on i32) and
76+ high bit means more bytes follow
77+ https://wikivg.booky.dev/Protocol#VarInt_and_VarLong */
78 do {
79 u8 byte = (u8)(v & 0x7f);
80 v >>= 7;
81@@ -139,8 +131,7 @@ int bufwrite_string(MCBuffer* buffer, const char* value)
82 size_t size = strlen(value);
83 if (size > MC_MAX_STRING_SIZE)
84 return 0;
85- return bufwrite_varint(buffer, (i32)size) &&
86- bufwrite(buffer, value, size);
87+ return bufwrite_varint(buffer, (i32)size) && bufwrite(buffer, value, size);
88 }
89
90 int bufread(MCBuffer* buffer, void* out, size_t size)
91@@ -153,10 +144,7 @@ int bufread(MCBuffer* buffer, void* out, size_t size)
92 return 1;
93 }
94
95-int bufread_u8(MCBuffer* buffer, u8* value)
96-{
97- return bufread(buffer, value, 1);
98-}
99+int bufread_u8(MCBuffer* buffer, u8* value) { return bufread(buffer, value, 1); }
100
101 int bufread_u16(MCBuffer* buffer, u16* value)
102 {
103@@ -169,19 +157,18 @@ int bufread_u16(MCBuffer* buffer, u16* value)
104
105 int bufread_i32(MCBuffer* buffer, i32* value)
106 {
107- u8 data[4];
108+ u8 data[4];
109 u32 result;
110 if (!bufread(buffer, data, sizeof(data)))
111 return 0;
112- result = ((u32)data[0] << 24) | ((u32)data[1] << 16) |
113- ((u32)data[2] << 8) | data[3];
114+ result = ((u32)data[0] << 24) | ((u32)data[1] << 16) | ((u32)data[2] << 8) | data[3];
115 *value = (i32)result;
116 return 1;
117 }
118
119 int bufread_i64(MCBuffer* buffer, i64* value)
120 {
121- u8 data[8];
122+ u8 data[8];
123 u64 result = 0;
124 int i;
125 if (!bufread(buffer, data, sizeof(data)))
126@@ -215,12 +202,10 @@ int bufread_varint(MCBuffer* buffer, i32* value)
127 u32 result = 0;
128 int shift;
129
130- /*
131- * VarInt is at best 5 bytes for a 32-bit value
132- * https://wikivg.booky.dev/Protocol#VarInt_and_VarLong
133- *
134- * 35 = 7*5
135- */
136+ /* VarInt is at best 5 bytes for a 32-bit value
137+ https://wikivg.booky.dev/Protocol#VarInt_and_VarLong
138+
139+ 35 = 7*5 */
140 for (shift = 0; shift < 35; shift += 7) {
141 u8 byte;
142 if (!bufread_u8(buffer, &byte))
143@@ -237,8 +222,8 @@ int bufread_varint(MCBuffer* buffer, i32* value)
144 int bufread_string(MCBuffer* buffer, char* value, size_t value_size)
145 {
146 i32 length;
147- if (!bufread_varint(buffer, &length) || length < 0 ||
148- (size_t)length >= value_size || (size_t)length > MC_MAX_STRING_SIZE)
149+ if (!bufread_varint(buffer, &length) || length < 0 || (size_t)length >= value_size ||
150+ (size_t)length > MC_MAX_STRING_SIZE)
151 return 0;
152 if (!bufread(buffer, value, (size_t)length))
153 return 0;
+116,
-135
1@@ -17,19 +17,15 @@
2 #define MSG_NOSIGNAL 0
3 #endif
4
5-static int split_address(
6- const char* address,
7- char* host,
8- size_t host_size,
9- u16* port,
10- char* error,
11- size_t error_size)
12+/* parse into host and port + validate */
13+static int split_address(const char* address, char* host, size_t host_size, u16* port, char* error,
14+ size_t error_size)
15 {
16 const char* colon = strrchr(address, ':');
17 const char* end = address + strlen(address);
18- char* port_end = NULL;
19- size_t length;
20- long parsed_port = 25565;
21+ char* port_end = NULL;
22+ size_t length;
23+ long parsed_port = 25565;
24
25 if (address[0] == '[') {
26 const char* close = strchr(address, ']');
27@@ -39,9 +35,9 @@ static int split_address(
28 }
29 length = (size_t)(close - address - 1);
30 address += 1;
31- if (close[1] == ':')
32+ if (close[1] == ':') {
33 parsed_port = strtol(close + 2, &port_end, 10);
34- else if (close[1] != '\0') {
35+ } else if (close[1] != '\0') {
36 mc_set_error(error, error_size, "invalid address suffix");
37 return 0;
38 }
39@@ -51,8 +47,8 @@ static int split_address(
40 } else {
41 length = (size_t)(end - address);
42 }
43- if ((port_end && *port_end) || length == 0 || length >= host_size ||
44- parsed_port < 1 || parsed_port > 65535) {
45+ if ((port_end && *port_end) || length == 0 || length >= host_size || parsed_port < 1 ||
46+ parsed_port > 65535) {
47 mc_set_error(error, error_size, "invalid server address");
48 return 0;
49 }
50@@ -62,27 +58,30 @@ static int split_address(
51 return 1;
52 }
53
54+/* connect to the configured server address */
55 static int tcp_connect(MCClient* client, char* error, size_t error_size)
56 {
57- struct addrinfo hints;
58+ struct addrinfo hints;
59 struct addrinfo* addresses = NULL;
60 struct addrinfo* address;
61- char service[6];
62- int result;
63+ char service[6];
64+ int result;
65
66 memset(&hints, 0, sizeof(hints));
67 hints.ai_family = AF_UNSPEC;
68 hints.ai_socktype = SOCK_STREAM;
69 snprintf(service, sizeof(service), "%u", client->port);
70+
71 result = getaddrinfo(client->host, service, &hints, &addresses);
72 if (result != 0) {
73- mc_set_error(error, error_size, "could not resolve %s: %s",
74- client->host, gai_strerror(result));
75+ mc_set_error(error, error_size, "could not resolve %s: %s", client->host,
76+ gai_strerror(result));
77 return 0;
78 }
79+
80 for (address = addresses; address; address = address->ai_next) {
81- client->socket_fd = socket(
82- address->ai_family, address->ai_socktype, address->ai_protocol);
83+ client->socket_fd =
84+ socket(address->ai_family, address->ai_socktype, address->ai_protocol);
85 if (client->socket_fd < 0)
86 continue;
87 if (connect(client->socket_fd, address->ai_addr, address->ai_addrlen) == 0)
88@@ -91,9 +90,10 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
89 client->socket_fd = -1;
90 }
91 freeaddrinfo(addresses);
92+
93 if (client->socket_fd < 0) {
94- mc_set_error(error, error_size, "could not connect to %s:%u: %s",
95- client->host, client->port, strerror(errno));
96+ mc_set_error(error, error_size, "could not connect to %s:%u: %s", client->host,
97+ client->port, strerror(errno));
98 return 0;
99 }
100 return 1;
101@@ -101,7 +101,7 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
102
103 static int socket_write(MCClient* client, const u8* data, size_t size)
104 {
105- u8 encrypted[4096];
106+ u8 encrypted[4096];
107 size_t offset = 0;
108
109 while (offset < size) {
110@@ -113,14 +113,15 @@ static int socket_write(MCClient* client, const u8* data, size_t size)
111 if (client->encrypted)
112 mc_cipher_encrypt(&client->write_cipher, encrypted, chunk);
113 while (sent < chunk) {
114- ssize_t count = send(client->socket_fd, encrypted + sent,
115- chunk - sent, MSG_NOSIGNAL);
116- if (count > 0)
117+ ssize_t count =
118+ send(client->socket_fd, encrypted + sent, chunk - sent, MSG_NOSIGNAL);
119+ if (count > 0) {
120 sent += (size_t)count;
121- else if (count < 0 && errno == EINTR)
122+ } else if (count < 0 && errno == EINTR) {
123 continue;
124- else
125+ } else {
126 return 0;
127+ }
128 }
129 offset += chunk;
130 }
131@@ -132,12 +133,13 @@ static int socket_read(MCClient* client, u8* data, size_t size)
132 size_t offset = 0;
133 while (offset < size) {
134 ssize_t count = recv(client->socket_fd, data + offset, size - offset, 0);
135- if (count > 0)
136+ if (count > 0) {
137 offset += (size_t)count;
138- else if (count < 0 && errno == EINTR)
139+ } else if (count < 0 && errno == EINTR) {
140 continue;
141- else
142+ } else {
143 return 0;
144+ }
145 }
146 if (client->encrypted)
147 mc_cipher_decrypt(&client->read_cipher, data, size);
148@@ -166,39 +168,38 @@ int mc_client_write(MCClient* client, i32 packet_id, const void* data, size_t si
149 MCBuffer body;
150 MCBuffer framed;
151 MCBuffer length;
152- u8* compressed = NULL;
153- uLongf compressed_size;
154- int ok = 0;
155+ u8* compressed = NULL;
156+ uLongf compressed_size;
157+ int ok = 0;
158
159 if (!client || client->socket_fd < 0 || size > MC_MAX_PACKET_SIZE)
160 return 0;
161 bufinit(&body);
162 bufinit(&framed);
163 bufinit(&length);
164- if (!bufwrite_varint(&body, packet_id) ||
165- !bufwrite(&body, data, size))
166+ /* build the packet body... */
167+ if (!bufwrite_varint(&body, packet_id) || !bufwrite(&body, data, size))
168 goto cleanup;
169- /*
170- * packet layout:
171- * length VarInt
172- * [data length VarInt if compression is enabled]
173- * packet id VarInt
174- * payload
175- *
176- * https://wikivg.booky.dev/Protocol#Packet_format
177- */
178+ /* packet layout:
179+ length VarInt
180+ [data length VarInt if compression is enabled]
181+ packet id VarInt
182+ payload
183+
184+ https://wikivg.booky.dev/Protocol#Packet_format */
185+
186+ /* ...then add the packet length and compression header */
187 if (client->compression_threshold >= 0) {
188- /*
189- * if in compressed mode, data length 0 means this packet body is
190- * not actually compressed. otherwise it is the size after zlib decompression
191- * https://wikivg.booky.dev/Protocol#With_compression
192- */
193+ /* if in compressed mode, data length 0 means this packet body
194+ is not actually compressed. otherwise it is the size after
195+ zlib decompression
196+ https://wikivg.booky.dev/Protocol#With_compression */
197 if (body.size >= (size_t)client->compression_threshold) {
198 compressed_size = compressBound((uLong)body.size);
199 compressed = (u8*)malloc(compressed_size);
200 if (!compressed ||
201- compress2(compressed, &compressed_size, body.data,
202- (uLong)body.size, Z_DEFAULT_COMPRESSION) != Z_OK)
203+ compress2(compressed, &compressed_size, body.data, (uLong)body.size,
204+ Z_DEFAULT_COMPRESSION) != Z_OK)
205 goto cleanup;
206 if (!bufwrite_varint(&framed, (i32)body.size) ||
207 !bufwrite(&framed, compressed, compressed_size))
208@@ -225,13 +226,13 @@ cleanup:
209
210 int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error_size)
211 {
212- i32 frame_length;
213+ i32 frame_length;
214 MCBuffer frame;
215 MCBuffer decoded;
216- i32 data_length;
217- i32 packet_id;
218- int decoded_allocated = 0;
219- int ok = 0;
220+ i32 data_length;
221+ i32 packet_id;
222+ int decoded_allocated = 0;
223+ int ok = 0;
224
225 memset(packet, 0, sizeof(*packet));
226 bufinit(&frame);
227@@ -251,9 +252,7 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
228 goto cleanup;
229 }
230 if (client->compression_threshold >= 0) {
231- /*
232- * same as before data length 0 means no compression
233- */
234+ /* same as before data length 0 means no compression */
235 if (!bufread_varint(&frame, &data_length) || data_length < 0 ||
236 (u32)data_length > MC_MAX_PACKET_SIZE) {
237 mc_set_error(error, error_size, "invalid compressed packet header");
238@@ -265,9 +264,8 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
239 } else {
240 uLongf output_size = (uLongf)data_length;
241 if (!bufreserve(&decoded, (size_t)data_length) ||
242- uncompress(decoded.data, &output_size,
243- frame.data + frame.cursor,
244- (uLong)(frame.size - frame.cursor)) != Z_OK ||
245+ uncompress(decoded.data, &output_size, frame.data + frame.cursor,
246+ (uLong)(frame.size - frame.cursor)) != Z_OK ||
247 output_size != (uLongf)data_length) {
248 mc_set_error(error, error_size, "invalid zlib packet");
249 goto cleanup;
250@@ -294,10 +292,11 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
251 ok = 1;
252
253 cleanup:
254- if (decoded_allocated)
255+ if (decoded_allocated) {
256 buffree(&decoded);
257- else
258+ } else {
259 decoded.data = NULL;
260+ }
261 buffree(&frame);
262 if (!ok)
263 mc_packet_free(packet);
264@@ -315,14 +314,11 @@ void mc_packet_free(MCPacket* packet)
265 static int send_handshake(MCClient* client)
266 {
267 MCBuffer payload;
268- int ok;
269+ int ok;
270 bufinit(&payload);
271- /*
272- * handshake to next state 2 switches the connection into login state
273- */
274+ /* handshake to next state 2 switches the connection into login state */
275 ok = bufwrite_varint(&payload, MC_PROTOCOL_1_8_9) &&
276- bufwrite_string(&payload, client->host) &&
277- bufwrite_u16(&payload, client->port) &&
278+ bufwrite_string(&payload, client->host) && bufwrite_u16(&payload, client->port) &&
279 bufwrite_varint(&payload, 2) &&
280 mc_client_write(client, 0x00, payload.data, payload.size);
281 buffree(&payload);
282@@ -332,7 +328,7 @@ static int send_handshake(MCClient* client)
283 static int send_login_start(MCClient* client)
284 {
285 MCBuffer payload;
286- int ok;
287+ int ok;
288 bufinit(&payload);
289 ok = bufwrite_string(&payload, client->username) &&
290 mc_client_write(client, 0x00, payload.data, payload.size);
291@@ -340,45 +336,42 @@ static int send_login_start(MCClient* client)
292 return ok;
293 }
294
295-static int handle_encryption(
296- MCClient* client,
297- const MCAccount* account,
298- MCPacket* packet,
299- char* error,
300- size_t error_size)
301+static int handle_encryption(MCClient* client, const MCAccount* account, MCPacket* packet,
302+ char* error, size_t error_size)
303 {
304- MCBuffer input = { packet->data, packet->size, packet->size, 0 };
305- MCBuffer response;
306- char server_id[256];
307+ MCBuffer input = { packet->data, packet->size, packet->size, 0 };
308+ MCBuffer response;
309+ char server_id[256];
310 const u8* public_key;
311 const u8* verify_token;
312- size_t public_key_size;
313- size_t verify_token_size;
314- u8 shared_secret[16];
315- u8* encrypted_secret = NULL;
316- u8* encrypted_token = NULL;
317- size_t encrypted_secret_size = 0;
318- size_t encrypted_token_size = 0;
319- int ok = 0;
320-
321+ size_t public_key_size;
322+ size_t verify_token_size;
323+ u8 shared_secret[16];
324+ u8* encrypted_secret = NULL;
325+ u8* encrypted_token = NULL;
326+ size_t encrypted_secret_size = 0;
327+ size_t encrypted_token_size = 0;
328+ int ok = 0;
329+
330+ /* parse the server encryption request */
331 if (!bufread_string(&input, server_id, sizeof(server_id)) ||
332 !bufread_bytes(&input, &public_key, &public_key_size) ||
333 !bufread_bytes(&input, &verify_token, &verify_token_size)) {
334 mc_set_error(error, error_size, "malformed encryption request");
335 return 0;
336 }
337+ /* create the AES shared secret for the connection */
338 if (!mg_random_bytes(shared_secret, sizeof(shared_secret))) {
339 mc_set_error(error, error_size, "could not obtain secure random bytes");
340 return 0;
341 }
342- if (!mc_join_server(account, server_id, shared_secret,
343- public_key, public_key_size, error, error_size) ||
344- !mc_rsa_encrypt(public_key, public_key_size,
345- shared_secret, sizeof(shared_secret),
346- &encrypted_secret, &encrypted_secret_size, error, error_size) ||
347- !mc_rsa_encrypt(public_key, public_key_size,
348- verify_token, verify_token_size,
349- &encrypted_token, &encrypted_token_size, error, error_size))
350+ /* join the mojang session, encrypt the secret, verify token */
351+ if (!mc_join_server(account, server_id, shared_secret, public_key, public_key_size, error,
352+ error_size) ||
353+ !mc_rsa_encrypt(public_key, public_key_size, shared_secret, sizeof(shared_secret),
354+ &encrypted_secret, &encrypted_secret_size, error, error_size) ||
355+ !mc_rsa_encrypt(public_key, public_key_size, verify_token, verify_token_size,
356+ &encrypted_token, &encrypted_token_size, error, error_size))
357 goto cleanup;
358
359 bufinit(&response);
360@@ -387,6 +380,7 @@ static int handle_encryption(
361 bufwrite_varint(&response, (i32)encrypted_token_size) &&
362 bufwrite(&response, encrypted_token, encrypted_token_size) &&
363 mc_client_write(client, 0x01, response.data, response.size)) {
364+ /* enable encryption after sending the unencrypted response */
365 mc_cipher_init(&client->read_cipher, shared_secret);
366 mc_cipher_init(&client->write_cipher, shared_secret);
367 client->encrypted = 1;
368@@ -403,21 +397,16 @@ cleanup:
369 return ok;
370 }
371
372-static int login_loop(
373- MCClient* client,
374- const MCAccount* account,
375- char* error,
376- size_t error_size)
377+/* process the login packets until we enter play state */
378+static int login_loop(MCClient* client, const MCAccount* account, char* error, size_t error_size)
379 {
380- /*
381- * login state packet ids for protocol 47:
382- * 0x00 disconnect
383- * 0x01 encryption request
384- * 0x02 login success
385- * 0x03 set compression
386- *
387- * https://prismarinejs.github.io/minecraft-data/protocol/pc/1.8/#login.toClient.types
388- */
389+ /* login state packet ids for protocol 47:
390+ 0x00 disconnect
391+ 0x01 encryption request
392+ 0x02 login success
393+ 0x03 set compression
394+
395+ https://prismarinejs.github.io/minecraft-data/protocol/pc/1.8/#login.toClient.types */
396 for (;;) {
397 MCPacket packet;
398 MCBuffer input;
399@@ -431,7 +420,8 @@ static int login_loop(
400 char reason[1024];
401 if (!bufread_string(&input, reason, sizeof(reason)))
402 strcpy(reason, "malformed disconnect reason");
403- mc_set_error(error, error_size, "server disconnected during login: %s", reason);
404+ mc_set_error(error, error_size, "server disconnected during login: %s",
405+ reason);
406 mc_packet_free(&packet);
407 return 0;
408 }
409@@ -471,17 +461,13 @@ static int login_loop(
410 return 0;
411 }
412 }
413-
414-int mc_client_login(
415- MCClient** out,
416- const char* address,
417- const MCAccount* account,
418- char* error,
419- size_t error_size)
420+/*create a client */
421+int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error,
422+ size_t error_size)
423 {
424 MCClient* client;
425- size_t username_size;
426-
427+ size_t username_size;
428+ /*validate inputs*/
429 *out = NULL;
430 if (error && error_size)
431 error[0] = '\0';
432@@ -503,10 +489,11 @@ int mc_client_login(
433 client->compression_threshold = -1;
434 memcpy(client->username, account->username, username_size + 1);
435 printf("connecting to %s as %s\n", address, client->username);
436- if (!split_address(address, client->host, sizeof(client->host),
437- &client->port, error, error_size) ||
438- !tcp_connect(client, error, error_size) ||
439- !send_handshake(client) ||
440+ /*parse server addr */
441+ if (!split_address(address, client->host, sizeof(client->host), &client->port, error,
442+ error_size) ||
443+ /*open tcp */
444+ !tcp_connect(client, error, error_size) || !send_handshake(client) ||
445 !send_login_start(client)) {
446 if (!error || !error_size || !error[0])
447 mc_set_error(error, error_size, "could not start Minecraft login");
448@@ -538,12 +525,6 @@ void mc_client_destroy(MCClient* client)
449 free(client);
450 }
451
452-const char* mc_client_username(const MCClient* client)
453-{
454- return client ? client->username : "";
455-}
456+const char* mc_client_username(const MCClient* client) { return client ? client->username : ""; }
457
458-const char* mc_client_uuid(const MCClient* client)
459-{
460- return client ? client->uuid : "";
461-}
462+const char* mc_client_uuid(const MCClient* client) { return client ? client->uuid : ""; }
+34,
-49
1@@ -4,16 +4,17 @@
2 #include "internal.h"
3 #include "mg_random.h"
4
5+/* naive der parser */
6 typedef struct {
7 const u8* data;
8- size_t size;
9- size_t cursor;
10+ size_t size;
11+ size_t cursor;
12 } DERReader;
13
14 static int der_length(DERReader* reader, size_t* length)
15 {
16- u8 first;
17- size_t value = 0;
18+ u8 first;
19+ size_t value = 0;
20 unsigned count;
21 unsigned i;
22
23@@ -25,8 +26,7 @@ static int der_length(DERReader* reader, size_t* length)
24 return *length <= reader->size - reader->cursor;
25 }
26 count = first & 0x7f;
27- if (count == 0 || count > sizeof(size_t) ||
28- count > reader->size - reader->cursor)
29+ if (count == 0 || count > sizeof(size_t) || count > reader->size - reader->cursor)
30 return 0;
31 for (i = 0; i < count; ++i)
32 value = (value << 8) | reader->data[reader->cursor++];
33@@ -49,12 +49,9 @@ static int der_value(DERReader* reader, u8 tag, DERReader* value)
34 return 1;
35 }
36
37-static int rsa_public_key(
38- const u8* der,
39- size_t der_size,
40- br_rsa_public_key* key,
41- char* error,
42- size_t error_size)
43+/* parse the server's X.509 RSA pubkey for BearSSL */
44+static int rsa_public_key(const u8* der, size_t der_size, br_rsa_public_key* key, char* error,
45+ size_t error_size)
46 {
47 DERReader root = { der, der_size, 0 };
48 DERReader spki;
49@@ -64,16 +61,13 @@ static int rsa_public_key(
50 DERReader modulus;
51 DERReader exponent;
52
53- if (!der_value(&root, 0x30, &spki) ||
54- !der_value(&spki, 0x30, &algorithm) ||
55- !der_value(&spki, 0x03, &bits) ||
56- bits.size < 1 || bits.data[0] != 0) {
57+ if (!der_value(&root, 0x30, &spki) || !der_value(&spki, 0x30, &algorithm) ||
58+ !der_value(&spki, 0x03, &bits) || bits.size < 1 || bits.data[0] != 0) {
59 mc_set_error(error, error_size, "invalid X.509 RSA public key");
60 return 0;
61 }
62 bits.cursor = 1;
63- if (!der_value(&bits, 0x30, &rsa) ||
64- !der_value(&rsa, 0x02, &modulus) ||
65+ if (!der_value(&bits, 0x30, &rsa) || !der_value(&rsa, 0x02, &modulus) ||
66 !der_value(&rsa, 0x02, &exponent)) {
67 mc_set_error(error, error_size, "invalid RSA public key integers");
68 return 0;
69@@ -130,21 +124,15 @@ void mc_cipher_decrypt(MCCipher* cipher, u8* data, size_t size)
70 }
71 }
72
73-int mc_rsa_encrypt(
74- const u8* public_key,
75- size_t public_key_size,
76- const u8* message,
77- size_t message_size,
78- u8** encrypted,
79- size_t* encrypted_size,
80- char* error,
81- size_t error_size)
82+int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message,
83+ size_t message_size, u8** encrypted, size_t* encrypted_size, char* error,
84+ size_t error_size)
85 {
86 br_rsa_public_key key;
87- br_rsa_public rsa;
88- u8* output;
89- size_t padding_size;
90- size_t i;
91+ br_rsa_public rsa;
92+ u8* output;
93+ size_t padding_size;
94+ size_t i;
95
96 if (!rsa_public_key(public_key, public_key_size, &key, error, error_size))
97 return 0;
98@@ -160,7 +148,8 @@ int mc_rsa_encrypt(
99 padding_size = key.nlen - message_size - 3;
100 output[0] = 0;
101 output[1] = 2;
102- /* PKCS#1 v1.5 encryption padding requires every padding byte to be nonzero */
103+ /* PKCS#1 v1.5 encryption padding requires every padding byte to be
104+ nonzero */
105 if (!mg_random_bytes(output + 2, padding_size)) {
106 free(output);
107 mc_set_error(error, error_size, "could not obtain secure random bytes");
108@@ -170,7 +159,8 @@ int mc_rsa_encrypt(
109 while (output[2 + i] == 0) {
110 if (!mg_random_bytes(output + 2 + i, 1)) {
111 free(output);
112- mc_set_error(error, error_size, "could not obtain secure random bytes");
113+ mc_set_error(error, error_size,
114+ "could not obtain secure random bytes");
115 return 0;
116 }
117 }
118@@ -191,7 +181,7 @@ int mc_rsa_encrypt(
119
120 static void twos_complement(u8* data, size_t size)
121 {
122- size_t i = size;
123+ size_t i = size;
124 unsigned carry = 1;
125 while (i > 0) {
126 unsigned value;
127@@ -202,20 +192,16 @@ static void twos_complement(u8* data, size_t size)
128 }
129 }
130
131-void mc_server_hash(
132- const char* server_id,
133- const u8 shared_secret[16],
134- const u8* public_key,
135- size_t public_key_size,
136- char output[42])
137+void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key,
138+ size_t public_key_size, char output[42])
139 {
140 static const char hex[] = "0123456789abcdef";
141- br_sha1_context sha;
142- u8 digest[20];
143- size_t first = 0;
144- size_t i;
145- size_t out = 0;
146- int negative;
147+ br_sha1_context sha;
148+ u8 digest[20];
149+ size_t first = 0;
150+ size_t i;
151+ size_t out = 0;
152+ int negative;
153
154 br_sha1_init(&sha);
155 br_sha1_update(&sha, server_id, strlen(server_id));
156@@ -240,9 +226,8 @@ void mc_server_hash(
157 output[out++] = hex[digest[i] & 15];
158 }
159 if (output[negative ? 1 : 0] == '0') {
160- memmove(output + (negative ? 1 : 0),
161- output + (negative ? 2 : 1),
162- out - (negative ? 2 : 1));
163+ memmove(output + (negative ? 1 : 0), output + (negative ? 2 : 1),
164+ out - (negative ? 2 : 1));
165 --out;
166 }
167 }
+26,
-42
1@@ -11,7 +11,7 @@
2 #define MC_MAX_STRING_SIZE 32767u
3
4 typedef struct {
5- u8* data;
6+ u8* data;
7 size_t size;
8 size_t capacity;
9 /* read offset used by bufread funcs, writes always append at size */
10@@ -20,17 +20,17 @@ typedef struct {
11
12 typedef struct {
13 br_aes_ct_cbcenc_keys key;
14- u8 state[16];
15+ u8 state[16];
16 } MCCipher;
17
18 struct MCClient {
19- int socket_fd;
20- char host[256];
21- u16 port;
22- char username[17];
23- char uuid[37];
24- i32 compression_threshold;
25- int encrypted;
26+ int socket_fd;
27+ char host[256];
28+ u16 port;
29+ char username[17];
30+ char uuid[37];
31+ i32 compression_threshold;
32+ int encrypted;
33 MCCipher read_cipher;
34 MCCipher write_cipher;
35 };
36@@ -39,16 +39,16 @@ void mc_set_error(char* error, size_t error_size, const char* fmt, ...);
37
38 void bufinit(MCBuffer* buffer);
39 void buffree(MCBuffer* buffer);
40-int bufreserve(MCBuffer* buffer, size_t extra);
41-int bufwrite(MCBuffer* buffer, const void* data, size_t size);
42-int bufwrite_u8(MCBuffer* buffer, u8 value);
43-int bufwrite_u16(MCBuffer* buffer, u16 value);
44-int bufwrite_i32(MCBuffer* buffer, i32 value);
45-int bufwrite_i64(MCBuffer* buffer, i64 value);
46-int bufwrite_f32(MCBuffer* buffer, float value);
47-int bufwrite_f64(MCBuffer* buffer, double value);
48-int bufwrite_varint(MCBuffer* buffer, i32 value);
49-int bufwrite_string(MCBuffer* buffer, const char* value);
50+int bufreserve(MCBuffer* buffer, size_t extra);
51+int bufwrite(MCBuffer* buffer, const void* data, size_t size);
52+int bufwrite_u8(MCBuffer* buffer, u8 value);
53+int bufwrite_u16(MCBuffer* buffer, u16 value);
54+int bufwrite_i32(MCBuffer* buffer, i32 value);
55+int bufwrite_i64(MCBuffer* buffer, i64 value);
56+int bufwrite_f32(MCBuffer* buffer, float value);
57+int bufwrite_f64(MCBuffer* buffer, double value);
58+int bufwrite_varint(MCBuffer* buffer, i32 value);
59+int bufwrite_string(MCBuffer* buffer, const char* value);
60
61 int bufread(MCBuffer* buffer, void* out, size_t size);
62 int bufread_u8(MCBuffer* buffer, u8* value);
63@@ -64,28 +64,12 @@ int bufread_bytes(MCBuffer* buffer, const u8** value, size_t* size);
64 void mc_cipher_init(MCCipher* cipher, const u8 key[16]);
65 void mc_cipher_encrypt(MCCipher* cipher, u8* data, size_t size);
66 void mc_cipher_decrypt(MCCipher* cipher, u8* data, size_t size);
67-int mc_rsa_encrypt(
68- const u8* public_key,
69- size_t public_key_size,
70- const u8* message,
71- size_t message_size,
72- u8** encrypted,
73- size_t* encrypted_size,
74- char* error,
75- size_t error_size);
76-void mc_server_hash(
77- const char* server_id,
78- const u8 shared_secret[16],
79- const u8* public_key,
80- size_t public_key_size,
81- char output[42]);
82-int mc_join_server(
83- const MCAccount* account,
84- const char* server_id,
85- const u8 shared_secret[16],
86- const u8* public_key,
87- size_t public_key_size,
88- char* error,
89- size_t error_size);
90+int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* message,
91+ size_t message_size, u8** encrypted, size_t* encrypted_size, char* error,
92+ size_t error_size);
93+void mc_server_hash(const char* server_id, const u8 shared_secret[16], const u8* public_key,
94+ size_t public_key_size, char output[42]);
95+int mc_join_server(const MCAccount* account, const char* server_id, const u8 shared_secret[16],
96+ const u8* public_key, size_t public_key_size, char* error, size_t error_size);
97
98 #endif /* MCPROTO_INTERNAL_H */
+2,
-2
1@@ -5,8 +5,8 @@
2
3 #if defined(__linux__)
4 #include <sys/random.h>
5-#elif defined(__APPLE__) || defined(__OpenBSD__) || defined(__FreeBSD__) || \
6- defined(__NetBSD__) || defined(__DragonFly__)
7+#elif defined(__APPLE__) || defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
8+ defined(__DragonFly__)
9 #include <stdlib.h>
10 #elif defined(_WIN32)
11 /* TODO: Windows shi*/
+21,
-56
1@@ -4,21 +4,18 @@
2
3 static HMM_Vec3 mg_to_hmm_v3(MGVec3 vec);
4 static HMM_Mat4 mg_to_hmm_m4(MGMat4 mat);
5-static MGVec2 mg_from_hmm_v2(HMM_Vec2 vec);
6-static MGVec3 mg_from_hmm_v3(HMM_Vec3 vec);
7-static MGVec4 mg_from_hmm_v4(HMM_Vec4 vec);
8-static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat);
9+static MGVec2 mg_from_hmm_v2(HMM_Vec2 vec);
10+static MGVec3 mg_from_hmm_v3(HMM_Vec3 vec);
11+static MGVec4 mg_from_hmm_v4(HMM_Vec4 vec);
12+static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat);
13
14-static HMM_Vec3 mg_to_hmm_v3(MGVec3 vec)
15-{
16- return HMM_V3(vec.x, vec.y, vec.z);
17-}
18+static HMM_Vec3 mg_to_hmm_v3(MGVec3 vec) { return HMM_V3(vec.x, vec.y, vec.z); }
19
20 static HMM_Mat4 mg_to_hmm_m4(MGMat4 mat)
21 {
22 HMM_Mat4 result;
23- int col;
24- int row;
25+ int col;
26+ int row;
27
28 for (col = 0; col < 4; col++) {
29 for (row = 0; row < 4; row++)
30@@ -64,8 +61,8 @@ static MGVec4 mg_from_hmm_v4(HMM_Vec4 vec)
31 static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat)
32 {
33 MGMat4 result;
34- int col;
35- int row;
36+ int col;
37+ int row;
38
39 for (col = 0; col < 4; col++) {
40 for (row = 0; row < 4; row++)
41@@ -75,40 +72,19 @@ static MGMat4 mg_from_hmm_m4(HMM_Mat4 mat)
42 return result;
43 }
44
45-float MG_SinF(float angle)
46-{
47- return HMM_SinF(angle);
48-}
49+float MG_SinF(float angle) { return HMM_SinF(angle); }
50
51-float MG_CosF(float angle)
52-{
53- return HMM_CosF(angle);
54-}
55+float MG_CosF(float angle) { return HMM_CosF(angle); }
56
57-float MG_TanF(float angle)
58-{
59- return HMM_TanF(angle);
60-}
61+float MG_TanF(float angle) { return HMM_TanF(angle); }
62
63-float MG_SqrtF(float value)
64-{
65- return HMM_SqrtF(value);
66-}
67+float MG_SqrtF(float value) { return HMM_SqrtF(value); }
68
69-MGVec2 MG_V2(float x, float y)
70-{
71- return mg_from_hmm_v2(HMM_V2(x, y));
72-}
73+MGVec2 MG_V2(float x, float y) { return mg_from_hmm_v2(HMM_V2(x, y)); }
74
75-MGVec3 MG_V3(float x, float y, float z)
76-{
77- return mg_from_hmm_v3(HMM_V3(x, y, z));
78-}
79+MGVec3 MG_V3(float x, float y, float z) { return mg_from_hmm_v3(HMM_V3(x, y, z)); }
80
81-MGVec4 MG_V4(float x, float y, float z, float w)
82-{
83- return mg_from_hmm_v4(HMM_V4(x, y, z, w));
84-}
85+MGVec4 MG_V4(float x, float y, float z, float w) { return mg_from_hmm_v4(HMM_V4(x, y, z, w)); }
86
87 MGVec3 MG_AddV3(MGVec3 left, MGVec3 right)
88 {
89@@ -135,20 +111,11 @@ MGVec3 MG_Cross(MGVec3 left, MGVec3 right)
90 return mg_from_hmm_v3(HMM_Cross(mg_to_hmm_v3(left), mg_to_hmm_v3(right)));
91 }
92
93-MGVec3 MG_NormV3(MGVec3 vec)
94-{
95- return mg_from_hmm_v3(HMM_NormV3(mg_to_hmm_v3(vec)));
96-}
97+MGVec3 MG_NormV3(MGVec3 vec) { return mg_from_hmm_v3(HMM_NormV3(mg_to_hmm_v3(vec))); }
98
99-MGMat4 MG_M4(void)
100-{
101- return mg_from_hmm_m4(HMM_M4());
102-}
103+MGMat4 MG_M4(void) { return mg_from_hmm_m4(HMM_M4()); }
104
105-MGMat4 MG_M4D(float diagonal)
106-{
107- return mg_from_hmm_m4(HMM_M4D(diagonal));
108-}
109+MGMat4 MG_M4D(float diagonal) { return mg_from_hmm_m4(HMM_M4D(diagonal)); }
110
111 MGMat4 MG_MulM4(MGMat4 left, MGMat4 right)
112 {
113@@ -167,8 +134,6 @@ MGMat4 MG_Perspective_RH_NO(float fov_y, float aspect, float near_z, float far_z
114
115 MGMat4 MG_LookAt_RH(MGVec3 eye, MGVec3 center, MGVec3 up)
116 {
117- return mg_from_hmm_m4(HMM_LookAt_RH(
118- mg_to_hmm_v3(eye),
119- mg_to_hmm_v3(center),
120- mg_to_hmm_v3(up)));
121+ return mg_from_hmm_m4(
122+ HMM_LookAt_RH(mg_to_hmm_v3(eye), mg_to_hmm_v3(center), mg_to_hmm_v3(up)));
123 }
+1,
-3
1@@ -91,9 +91,7 @@ void platform_window_create(MGContext* ctx)
2 flags |= SDL_WINDOW_OPENGL;
3 #endif
4
5- ctx->win = SDL_CreateWindow(
6- ctx->title, ctx->x, ctx->y, ctx->width, ctx->height,
7- flags);
8+ ctx->win = SDL_CreateWindow(ctx->title, ctx->x, ctx->y, ctx->width, ctx->height, flags);
9
10 if (!ctx->win)
11 mg_die(MG_ERR_SDL_CREATE_WIN, "Failed to create window: %s", SDL_GetError());
+8,
-32
1@@ -1,52 +1,28 @@
2 #include "renderer/renderer.h"
3 #include "renderer_backend.h"
4
5-void renderer_create(MGContext* ctx)
6-{
7- renderer_backend_create(ctx);
8-}
9+void renderer_create(MGContext* ctx) { renderer_backend_create(ctx); }
10
11-void renderer_begin(void)
12-{
13- renderer_backend_begin();
14-}
15+void renderer_begin(void) { renderer_backend_begin(); }
16
17-void renderer_end(void)
18-{
19- renderer_backend_end();
20-}
21+void renderer_end(void) { renderer_backend_end(); }
22
23-void renderer_destroy(void)
24-{
25- renderer_backend_destroy();
26-}
27+void renderer_destroy(void) { renderer_backend_destroy(); }
28
29-MGMesh renderer_mesh_create(const MGMeshDesc* desc)
30-{
31- return renderer_backend_mesh_create(desc);
32-}
33+MGMesh renderer_mesh_create(const MGMeshDesc* desc) { return renderer_backend_mesh_create(desc); }
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)
41-{
42- renderer_backend_mesh_destroy(mesh);
43-}
44+void renderer_mesh_destroy(MGMesh mesh) { renderer_backend_mesh_destroy(mesh); }
45
46-MGTexture renderer_texture_load(const char* path)
47-{
48- return renderer_backend_texture_load(path);
49-}
50+MGTexture renderer_texture_load(const char* path) { return renderer_backend_texture_load(path); }
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)
58-{
59- renderer_backend_texture_destroy(texture);
60-}
61+void renderer_texture_destroy(MGTexture texture) { renderer_backend_texture_destroy(texture); }
+3,
-3
1@@ -9,11 +9,11 @@ void renderer_backend_end(void);
2 void renderer_backend_destroy(void);
3
4 MGMesh renderer_backend_mesh_create(const MGMeshDesc* desc);
5-void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mvp);
6-void renderer_backend_mesh_destroy(MGMesh mesh);
7+void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mvp);
8+void renderer_backend_mesh_destroy(MGMesh mesh);
9
10 MGTexture renderer_backend_texture_load(const char* path);
11 MGTexture renderer_backend_texture_create(const MGTextureDesc* desc);
12-void renderer_backend_texture_destroy(MGTexture texture);
13+void renderer_backend_texture_destroy(MGTexture texture);
14
15 #endif /* RENDERER_BACKEND_H */
+90,
-102
1@@ -34,42 +34,42 @@ typedef struct {
2
3 typedef struct {
4 MGVertex* vtc; /* vertices */
5- u16* idc; /* indices */
6- u32 vc; /* vertex count */
7- u32 ic; /* index count */
8- i8 used;
9+ u16* idc; /* indices */
10+ u32 vc; /* vertex count */
11+ u32 ic; /* index count */
12+ i8 used;
13 } RendererMesh;
14
15 typedef struct {
16 u32* pixels;
17- i32 width;
18- i32 height;
19- i8 used;
20+ i32 width;
21+ i32 height;
22+ i8 used;
23 } RendererTexture;
24
25 typedef struct {
26 MGContext* ctx;
27- i8 pass; /* basically a bool; in
28+ i8 pass; /* basically a bool; in
29 render pass or not */
30
31 SDL_Texture* screen_texture;
32- u16* framebuffer;
33- i32 width;
34- i32 height;
35+ u16* framebuffer;
36+ i32 width;
37+ i32 height;
38
39- RendererMesh meshes[MAX_MESHES];
40+ RendererMesh meshes[MAX_MESHES];
41 RendererTexture textures[MAX_TEXTURES];
42
43- RendererMesh* active_mesh;
44+ RendererMesh* active_mesh;
45 RendererTexture* active_texture;
46- u32 active_triangle;
47- i32 tri_uvs[6];
48- u32 sampled_colour;
49- u8 texture_sample_count;
50+ u32 active_triangle;
51+ i32 tri_uvs[6];
52+ u32 sampled_colour;
53+ u8 texture_sample_count;
54
55 ClipVertex* clip_vertices;
56- S3L_Vec4* screen_vertices;
57- u32 scratch_capacity;
58+ S3L_Vec4* screen_vertices;
59+ u32 scratch_capacity;
60 } RendererState;
61
62 static RendererState ren;
63@@ -81,12 +81,13 @@ static void create_screen_texture(i32 width, i32 height);
64 static void destroy_screen_texture(void);
65
66 static ClipVertex transform_vertex(const MGMat4* mvp, const MGVertex* v);
67-static i8 triangle_outside(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
68+static i8 triangle_outside(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
69 static i8 triangle_front_facing(const ClipVertex* a, const ClipVertex* b, const ClipVertex* c);
70 static S3L_Vec4 clip_to_screen(const ClipVertex* v);
71-static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture, const S3L_PixelInfo* pixel);
72-static u16 rgba_to_rgb565(u32 rgba);
73-static u32 pack_texture_pixel(u32 rgba);
74+static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture,
75+ const S3L_PixelInfo* pixel);
76+static u16 rgba_to_rgb565(u32 rgba);
77+static u32 pack_texture_pixel(u32 rgba);
78
79 static inline void small3dlib_pixel(S3L_PixelInfo* pixel)
80 {
81@@ -99,8 +100,7 @@ static inline void small3dlib_pixel(S3L_PixelInfo* pixel)
82 if (ren.active_triangle != (u32)pixel->triangleIndex)
83 ren.texture_sample_count = 0;
84 if (ren.texture_sample_count == 0) {
85- ren.sampled_colour =
86- sample_texture(ren.active_mesh, ren.active_texture, pixel);
87+ ren.sampled_colour = sample_texture(ren.active_mesh, ren.active_texture, pixel);
88 if ((ren.sampled_colour >> 24) == 0xff)
89 ren.texture_sample_count = TEXTURE_SAMPLE_PERIOD;
90 }
91@@ -117,7 +117,7 @@ static inline void small3dlib_pixel(S3L_PixelInfo* pixel)
92
93 static void create_screen_texture(i32 width, i32 height)
94 {
95- u64 pixel_count;
96+ u64 pixel_count;
97 u16* framebuffer;
98
99 if (width == ren.width && height == ren.height && ren.framebuffer && ren.screen_texture)
100@@ -127,7 +127,8 @@ static void create_screen_texture(i32 width, i32 height)
101 return;
102
103 if (width > S3L_MAX_WIDTH || height > S3L_MAX_HEIGHT)
104- mg_die(MG_ERR_REN_CREATE, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH, S3L_MAX_HEIGHT);
105+ mg_die(MG_ERR_REN_CREATE, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH,
106+ S3L_MAX_HEIGHT);
107
108 pixel_count = (u64)width * (u64)height;
109 framebuffer = malloc(pixel_count * sizeof(*framebuffer));
110@@ -137,15 +138,12 @@ static void create_screen_texture(i32 width, i32 height)
111 if (ren.screen_texture)
112 SDL_DestroyTexture(ren.screen_texture);
113
114- ren.screen_texture = SDL_CreateTexture(
115- ren.ctx->vbe.renderer,
116- SDL_PIXELFORMAT_RGB565,
117- SDL_TEXTUREACCESS_STREAMING,
118- width,
119- height);
120+ ren.screen_texture = SDL_CreateTexture(ren.ctx->vbe.renderer, SDL_PIXELFORMAT_RGB565,
121+ SDL_TEXTUREACCESS_STREAMING, width, height);
122
123 if (!ren.screen_texture)
124- mg_die(MG_ERR_REN_CREATE, "Failed to create small3dlib texture: %s", SDL_GetError());
125+ mg_die(MG_ERR_REN_CREATE, "Failed to create small3dlib texture: %s",
126+ SDL_GetError());
127
128 free(ren.framebuffer);
129 ren.framebuffer = framebuffer;
130@@ -173,14 +171,14 @@ static ClipVertex transform_vertex(const MGMat4* mvp, const MGVertex* v)
131 {
132 ClipVertex r;
133
134- r.x = mvp->Elements[0][0] * v->x + mvp->Elements[1][0] * v->y +
135- mvp->Elements[2][0] * v->z + mvp->Elements[3][0];
136- r.y = mvp->Elements[0][1] * v->x + mvp->Elements[1][1] * v->y +
137- mvp->Elements[2][1] * v->z + mvp->Elements[3][1];
138- r.z = mvp->Elements[0][2] * v->x + mvp->Elements[1][2] * v->y +
139- mvp->Elements[2][2] * v->z + mvp->Elements[3][2];
140- r.w = mvp->Elements[0][3] * v->x + mvp->Elements[1][3] * v->y +
141- mvp->Elements[2][3] * v->z + mvp->Elements[3][3];
142+ r.x = mvp->Elements[0][0] * v->x + mvp->Elements[1][0] * v->y + mvp->Elements[2][0] * v->z +
143+ mvp->Elements[3][0];
144+ r.y = mvp->Elements[0][1] * v->x + mvp->Elements[1][1] * v->y + mvp->Elements[2][1] * v->z +
145+ mvp->Elements[3][1];
146+ r.z = mvp->Elements[0][2] * v->x + mvp->Elements[1][2] * v->y + mvp->Elements[2][2] * v->z +
147+ mvp->Elements[3][2];
148+ r.w = mvp->Elements[0][3] * v->x + mvp->Elements[1][3] * v->y + mvp->Elements[2][3] * v->z +
149+ mvp->Elements[3][3];
150
151 return r;
152 }
153@@ -222,16 +220,14 @@ static i8 triangle_front_facing(const ClipVertex* a, const ClipVertex* b, const
154 static S3L_Vec4 clip_to_screen(const ClipVertex* v)
155 {
156 S3L_Vec4 r;
157- float inv_w = 1.0f / v->w;
158- float ndc_x = v->x * inv_w;
159- float ndc_y = v->y * inv_w;
160+ float inv_w = 1.0f / v->w;
161+ float ndc_x = v->x * inv_w;
162+ float ndc_y = v->y * inv_w;
163
164 r.x = (S3L_Unit)((ndc_x * 0.5f + 0.5f) * (float)(ren.width - 1));
165 r.y = (S3L_Unit)((0.5f - ndc_y * 0.5f) * (float)(ren.height - 1));
166- /*
167- * keep enough reciprocal depth precision for a
168- * useful amount of perspective correction
169- */
170+ /* keep enough reciprocal depth precision for a
171+ useful amount of perspective correction */
172 r.z = (S3L_Unit)(v->w * 16.0f);
173 if (r.z < 1)
174 r.z = 1;
175@@ -240,14 +236,15 @@ static S3L_Vec4 clip_to_screen(const ClipVertex* v)
176 return r;
177 }
178
179-static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture, const S3L_PixelInfo* pixel)
180+static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* texture,
181+ const S3L_PixelInfo* pixel)
182 {
183- u32 tri;
184+ u32 tri;
185 const MGVertex* v[3];
186- i32 x;
187- i32 y;
188- i32 weighted_x;
189- i32 weighted_y;
190+ i32 x;
191+ i32 y;
192+ i32 weighted_x;
193+ i32 weighted_y;
194
195 if (!texture || !texture->pixels)
196 return 0xffffffff;
197@@ -275,14 +272,16 @@ static u32 sample_texture(const RendererMesh* mesh, const RendererTexture* textu
198 pixel->barycentric[2] * ren.tri_uvs[5];
199 x = weighted_x >> 9;
200 y = weighted_y >> 9;
201- if (x < 0)
202+ if (x < 0) {
203 x = 0;
204- else if (x >= texture->width)
205+ } else if (x >= texture->width) {
206 x = texture->width - 1;
207- if (y < 0)
208+ }
209+ if (y < 0) {
210 y = 0;
211- else if (y >= texture->height)
212+ } else if (y >= texture->height) {
213 y = texture->height - 1;
214+ }
215 return texture->pixels[y * texture->width + x];
216 }
217
218@@ -295,10 +294,7 @@ static u16 rgba_to_rgb565(u32 rgba)
219 return (u16)(((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3));
220 }
221
222-static u32 pack_texture_pixel(u32 rgba)
223-{
224- return ((rgba >> 24) << 24) | rgba_to_rgb565(rgba);
225-}
226+static u32 pack_texture_pixel(u32 rgba) { return ((rgba >> 24) << 24) | rgba_to_rgb565(rgba); }
227
228 void renderer_backend_create(MGContext* ctx)
229 {
230@@ -327,13 +323,11 @@ void renderer_backend_begin(void)
231 scaled_width = width;
232 scaled_height = height;
233 if (scaled_width > SOFTWARE_MAX_WIDTH) {
234- scaled_height =
235- (i32)(((i64)scaled_height * SOFTWARE_MAX_WIDTH) / scaled_width);
236+ scaled_height = (i32)(((i64)scaled_height * SOFTWARE_MAX_WIDTH) / scaled_width);
237 scaled_width = SOFTWARE_MAX_WIDTH;
238 }
239 if (scaled_height > SOFTWARE_MAX_HEIGHT) {
240- scaled_width =
241- (i32)(((i64)scaled_width * SOFTWARE_MAX_HEIGHT) / scaled_height);
242+ scaled_width = (i32)(((i64)scaled_width * SOFTWARE_MAX_HEIGHT) / scaled_height);
243 scaled_height = SOFTWARE_MAX_HEIGHT;
244 }
245 create_screen_texture(scaled_width, scaled_height);
246@@ -351,7 +345,8 @@ void renderer_backend_end(void)
247 if (!ren.pass)
248 return;
249
250- SDL_UpdateTexture(ren.screen_texture, NULL, ren.framebuffer, ren.width * (i32)sizeof(*ren.framebuffer));
251+ SDL_UpdateTexture(ren.screen_texture, NULL, ren.framebuffer,
252+ ren.width * (i32)sizeof(*ren.framebuffer));
253 SDL_RenderClear(ren.ctx->vbe.renderer);
254 SDL_RenderCopy(ren.ctx->vbe.renderer, ren.screen_texture, NULL, NULL);
255 ren.pass = 0;
256@@ -385,7 +380,7 @@ void renderer_backend_destroy(void)
257 MGMesh renderer_backend_mesh_create(const MGMeshDesc* desc)
258 {
259 RendererMesh* mesh;
260- u32 id;
261+ u32 id;
262
263 if (!desc || !desc->vtc || !desc->idc || desc->vtcc == 0 || desc->idcc == 0)
264 return MGMESH_INVALID;
265@@ -427,10 +422,10 @@ MGMesh renderer_backend_mesh_create(const MGMeshDesc* desc)
266
267 void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mvp)
268 {
269- RendererMesh* rmesh;
270+ RendererMesh* rmesh;
271 RendererTexture* rtexture;
272- u32 vertex;
273- u32 tri;
274+ u32 vertex;
275+ u32 tri;
276
277 if (!ren.pass || !mvp)
278 return;
279@@ -448,25 +443,23 @@ void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mv
280
281 if (rmesh->vc > ren.scratch_capacity) {
282 ClipVertex* clip_vertices;
283- S3L_Vec4* screen_vertices;
284- clip_vertices = (ClipVertex*)realloc(ren.clip_vertices,
285- rmesh->vc * sizeof(*clip_vertices));
286+ S3L_Vec4* screen_vertices;
287+ clip_vertices =
288+ (ClipVertex*)realloc(ren.clip_vertices, rmesh->vc * sizeof(*clip_vertices));
289 if (!clip_vertices)
290 return;
291 ren.clip_vertices = clip_vertices;
292- screen_vertices = (S3L_Vec4*)realloc(ren.screen_vertices,
293- rmesh->vc * sizeof(*screen_vertices));
294+ screen_vertices =
295+ (S3L_Vec4*)realloc(ren.screen_vertices, rmesh->vc * sizeof(*screen_vertices));
296 if (!screen_vertices)
297 return;
298 ren.screen_vertices = screen_vertices;
299 ren.scratch_capacity = rmesh->vc;
300 }
301 for (vertex = 0; vertex < rmesh->vc; ++vertex) {
302- ren.clip_vertices[vertex] =
303- transform_vertex(mvp, &rmesh->vtc[vertex]);
304+ ren.clip_vertices[vertex] = transform_vertex(mvp, &rmesh->vtc[vertex]);
305 if (ren.clip_vertices[vertex].w > 0.0001f)
306- ren.screen_vertices[vertex] =
307- clip_to_screen(&ren.clip_vertices[vertex]);
308+ ren.screen_vertices[vertex] = clip_to_screen(&ren.clip_vertices[vertex]);
309 }
310
311 ren.active_mesh = rmesh;
312@@ -475,9 +468,9 @@ void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mv
313 ren.texture_sample_count = 0;
314
315 for (tri = 0; tri < rmesh->ic; tri += 3) {
316- u16 ia = rmesh->idc[tri + 0];
317- u16 ib = rmesh->idc[tri + 1];
318- u16 ic = rmesh->idc[tri + 2];
319+ u16 ia = rmesh->idc[tri + 0];
320+ u16 ib = rmesh->idc[tri + 1];
321+ u16 ic = rmesh->idc[tri + 2];
322 ClipVertex* ca = &ren.clip_vertices[ia];
323 ClipVertex* cb = &ren.clip_vertices[ib];
324 ClipVertex* cc = &ren.clip_vertices[ic];
325@@ -487,11 +480,8 @@ void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mv
326 if (!triangle_front_facing(ca, cb, cc))
327 continue;
328
329- S3L_drawTriangle(
330- ren.screen_vertices[ia],
331- ren.screen_vertices[ib],
332- ren.screen_vertices[ic],
333- 0, (S3L_Index)(tri / 3));
334+ S3L_drawTriangle(ren.screen_vertices[ia], ren.screen_vertices[ib],
335+ ren.screen_vertices[ic], 0, (S3L_Index)(tri / 3));
336 }
337
338 ren.active_mesh = NULL;
339@@ -517,12 +507,12 @@ void renderer_backend_mesh_destroy(MGMesh id)
340
341 MGTexture renderer_backend_texture_load(const char* path)
342 {
343- stbi_uc* pixels;
344- int width;
345- int height;
346- int channels;
347+ stbi_uc* pixels;
348+ int width;
349+ int height;
350+ int channels;
351 MGTextureDesc desc;
352- MGTexture texture;
353+ MGTexture texture;
354
355 if (!path)
356 return MGTEXTURE_INVALID;
357@@ -542,10 +532,10 @@ MGTexture renderer_backend_texture_load(const char* path)
358 MGTexture renderer_backend_texture_create(const MGTextureDesc* desc)
359 {
360 RendererTexture* texture;
361- size_t size;
362- size_t pixel_count;
363- size_t i;
364- u32 id;
365+ size_t size;
366+ size_t pixel_count;
367+ size_t i;
368+ u32 id;
369
370 if (!desc || !desc->pixels || desc->width <= 0 || desc->height <= 0)
371 return MGTEXTURE_INVALID;
372@@ -569,10 +559,8 @@ MGTexture renderer_backend_texture_create(const MGTextureDesc* desc)
373
374 for (i = 0; i < pixel_count; ++i) {
375 const u8* source = desc->pixels + i * 4;
376- u32 rgba = (u32)source[0] |
377- ((u32)source[1] << 8) |
378- ((u32)source[2] << 16) |
379- ((u32)source[3] << 24);
380+ u32 rgba = (u32)source[0] | ((u32)source[1] << 8) | ((u32)source[2] << 16) |
381+ ((u32)source[3] << 24);
382 texture->pixels[i] = pack_texture_pixel(rgba);
383 }
384 texture->width = desc->width;
+59,
-64
1@@ -13,26 +13,26 @@
2 typedef struct {
3 sg_buffer vb; /* vertex buffer */
4 sg_buffer ib; /* index buffer */
5- u32 ic; /* index count */
6- i8 used;
7+ u32 ic; /* index count */
8+ i8 used;
9 } RendererMesh;
10
11 typedef struct {
12 sg_image image;
13- sg_view view;
14- i8 used;
15+ sg_view view;
16+ i8 used;
17 } RendererTexture;
18
19 typedef struct {
20 MGContext* ctx;
21- i8 pass; /* basically a bool; in
22+ i8 pass; /* basically a bool; in
23 render pass or not */
24
25- sg_shader shader;
26+ sg_shader shader;
27 sg_pipeline pipeline;
28- sg_sampler sampler;
29+ sg_sampler sampler;
30
31- RendererMesh meshes[MAX_MESHES];
32+ RendererMesh meshes[MAX_MESHES];
33 RendererTexture textures[MAX_MESHES];
34 } RendererState;
35
36@@ -43,44 +43,43 @@ static void create_pipelines(void);
37 static void create_sampler(void);
38
39 /* logging function for passing to sokol */
40-static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln, const char* file, void* user);
41+static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln,
42+ const char* file, void* user);
43
44 static RendererState ren;
45 /* TODO: textures */
46-static const char* vsdr =
47- "#version 330\n"
48- "layout(location=0) in vec3 position;\n"
49- "layout(location=1) in vec2 texcoord0;\n"
50- "layout(location=2) in vec4 color0;\n"
51- "\n"
52- "uniform mat4 mvp;\n"
53- "\n"
54- "out vec2 uv;\n"
55- "out vec4 colour;\n"
56- "\n"
57- "void main(void)\n"
58- "{\n"
59- " gl_Position = mvp * vec4(position, 1.0);\n"
60- " uv = texcoord0;\n"
61- " colour = color0;\n"
62- "}\n";
63-static const char* fsdr =
64- "#version 330\n"
65- "in vec2 uv;\n"
66- "in vec4 colour;\n"
67- "\n"
68- "uniform sampler2D tex;\n"
69- "\n"
70- "out vec4 frag_colour;\n"
71- "\n"
72- "void main(void)\n"
73- "{\n"
74- " frag_colour = texture(tex, uv);\n"
75- "}\n";
76+static const char* vsdr = "#version 330\n"
77+ "layout(location=0) in vec3 position;\n"
78+ "layout(location=1) in vec2 texcoord0;\n"
79+ "layout(location=2) in vec4 color0;\n"
80+ "\n"
81+ "uniform mat4 mvp;\n"
82+ "\n"
83+ "out vec2 uv;\n"
84+ "out vec4 colour;\n"
85+ "\n"
86+ "void main(void)\n"
87+ "{\n"
88+ " gl_Position = mvp * vec4(position, 1.0);\n"
89+ " uv = texcoord0;\n"
90+ " colour = color0;\n"
91+ "}\n";
92+static const char* fsdr = "#version 330\n"
93+ "in vec2 uv;\n"
94+ "in vec4 colour;\n"
95+ "\n"
96+ "uniform sampler2D tex;\n"
97+ "\n"
98+ "out vec4 frag_colour;\n"
99+ "\n"
100+ "void main(void)\n"
101+ "{\n"
102+ " frag_colour = texture(tex, uv);\n"
103+ "}\n";
104
105 static void create_pipelines(void)
106 {
107- sg_shader_desc shader_desc = { 0 };
108+ sg_shader_desc shader_desc = { 0 };
109 sg_pipeline_desc pipeline_desc = { 0 };
110
111 /* shader descriptor */
112@@ -142,7 +141,8 @@ static void create_sampler(void)
113 mg_die(MG_ERR_SAMPLER_CREATE, "Failed to create sampler");
114 }
115
116-static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln, const char* file, void* user)
117+static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32 ln,
118+ const char* file, void* user)
119 {
120 LogType type;
121 (void)item;
122@@ -150,12 +150,8 @@ static void sokol_log(const char* tag, u32 level, u32 item, const char* msg, u32
123
124 type = level <= 1 ? LOG_ERR : LOG_DBG;
125
126- mg_log(
127- type, "%s: %s [%s:%u]",
128- tag ? tag : "Sokol",
129- msg ? msg : "No message",
130- file ? file : "Unknown",
131- ln);
132+ mg_log(type, "%s: %s [%s:%u]", tag ? tag : "Sokol", msg ? msg : "No message",
133+ file ? file : "Unknown", ln);
134 }
135
136 void renderer_backend_create(MGContext* ctx)
137@@ -183,8 +179,8 @@ void renderer_backend_create(MGContext* ctx)
138 void renderer_backend_begin(void)
139 {
140 sg_pass pass = { 0 };
141- i32 width;
142- i32 height;
143+ i32 width;
144+ i32 height;
145
146 ren.pass = 0;
147
148@@ -251,8 +247,8 @@ void renderer_backend_destroy(void)
149 MGMesh renderer_backend_mesh_create(const MGMeshDesc* desc)
150 {
151 sg_buffer_desc buffer_desc = { 0 };
152- RendererMesh* mesh;
153- u32 id;
154+ RendererMesh* mesh;
155+ u32 id;
156
157 if (!desc || !desc->vtc || !desc->idc || desc->vtcc == 0 || desc->idcc == 0)
158 return MGMESH_INVALID;
159@@ -303,10 +299,10 @@ MGMesh renderer_backend_mesh_create(const MGMeshDesc* desc)
160
161 void renderer_backend_mesh_draw(MGMesh mesh, MGTexture texture, const MGMat4* mvp)
162 {
163- RendererMesh* rmesh;
164+ RendererMesh* rmesh;
165 RendererTexture* rtexture;
166- sg_bindings bindings = { 0 };
167- sg_range uniforms;
168+ sg_bindings bindings = { 0 };
169+ sg_range uniforms;
170
171 if (!ren.pass || !mvp)
172 return;
173@@ -356,12 +352,12 @@ void renderer_backend_mesh_destroy(MGMesh id)
174
175 MGTexture renderer_backend_texture_load(const char* path)
176 {
177- stbi_uc* pixels;
178- int width;
179- int height;
180- int channels;
181+ stbi_uc* pixels;
182+ int width;
183+ int height;
184+ int channels;
185 MGTextureDesc desc;
186- MGTexture texture;
187+ MGTexture texture;
188
189 if (!path)
190 return MGTEXTURE_INVALID;
191@@ -382,10 +378,10 @@ MGTexture renderer_backend_texture_load(const char* path)
192
193 MGTexture renderer_backend_texture_create(const MGTextureDesc* desc)
194 {
195- sg_image_desc image_desc = { 0 };
196- sg_view_desc view_desc = { 0 };
197+ sg_image_desc image_desc = { 0 };
198+ sg_view_desc view_desc = { 0 };
199 RendererTexture* texture;
200- u32 id;
201+ u32 id;
202
203 if (!desc || !desc->pixels || desc->width <= 0 || desc->height <= 0)
204 return MGTEXTURE_INVALID;
205@@ -405,8 +401,7 @@ MGTexture renderer_backend_texture_create(const MGTextureDesc* desc)
206 image_desc.height = desc->height;
207 image_desc.pixel_format = SG_PIXELFORMAT_RGBA8;
208 image_desc.data.mip_levels[0].ptr = desc->pixels;
209- image_desc.data.mip_levels[0].size =
210- (size_t)desc->width * (size_t)desc->height * 4;
211+ image_desc.data.mip_levels[0].size = (size_t)desc->width * (size_t)desc->height * 4;
212
213 texture->image = sg_make_image(&image_desc);
214 if (sg_query_image_state(texture->image) != SG_RESOURCESTATE_VALID) {
+4,
-3
1@@ -32,16 +32,17 @@ void mg_log(LogType lt, const char* fmt, ...)
2 #else
3 int debug = 0;
4 #endif
5- FILE* fd;
6+ FILE* fd;
7 va_list ap;
8
9 if (lt == LOG_DBG && !debug)
10 return;
11
12- if (lt == LOG_DBG || lt == LOG_ERR)
13+ if (lt == LOG_DBG || lt == LOG_ERR) {
14 fd = stderr;
15- else
16+ } else {
17 fd = stdout;
18+ }
19
20 va_start(ap, fmt);
21 vlog(fd, fmt, ap);
+28,
-42
1@@ -6,22 +6,16 @@
2
3 #define MAX_MESH_VERTICES 65535U
4
5-static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count,
6- u32* index_count, i32 face, i32 x, i32 y, i32 z);
7+static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count,
8+ i32 face, i32 x, i32 y, i32 z);
9
10 /* 6 = number of faces on a cube */
11-static const i32 face_offsets[6][3] = {
12- { 0, 0, -1 },
13- { 0, 0, 1 },
14- { -1, 0, 0 },
15- { 1, 0, 0 },
16- { 0, -1, 0 },
17- { 0, 1, 0 }
18-};
19+static const i32 face_offsets[6][3] = { { 0, 0, -1 }, { 0, 0, 1 }, { -1, 0, 0 },
20+ { 1, 0, 0 }, { 0, -1, 0 }, { 0, 1, 0 } };
21
22 static const MGVertex face_vertices[24] = {
23 /* north: -z */
24- { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, RGBA(255, 0, 0, 255) },
25+ { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, RGBA(255, 0, 0, 255) },
26 { 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, RGBA(255, 0, 0, 255) },
27 { 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, RGBA(255, 0, 0, 255) },
28 { 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, RGBA(255, 0, 0, 255) },
29@@ -57,12 +51,12 @@ static const MGVertex face_vertices[24] = {
30 { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, RGBA(0, 255, 255, 255) }
31 };
32
33-static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count,
34- u32* index_count, i32 face, i32 x, i32 y, i32 z)
35+static void add_face(MGVertex* vertices, u16* indices, u32* vertex_count, u32* index_count,
36+ i32 face, i32 x, i32 y, i32 z)
37 {
38 MGVertex vtx;
39- u32 base;
40- i32 i;
41+ u32 base;
42+ i32 i;
43
44 base = *vertex_count;
45
46@@ -146,17 +140,17 @@ void chunk_set(Chunk* chunk, i32 x, i32 y, i32 z, BlockType block)
47
48 i8 chunk_mesh_create(Chunk* chunk)
49 {
50- MGVertex* vertices[BLOCK_LAST];
51- u16* indices[BLOCK_LAST];
52- u32 face_counts[BLOCK_LAST];
53- u32 vertex_counts[BLOCK_LAST];
54- u32 index_counts[BLOCK_LAST];
55+ MGVertex* vertices[BLOCK_LAST];
56+ u16* indices[BLOCK_LAST];
57+ u32 face_counts[BLOCK_LAST];
58+ u32 vertex_counts[BLOCK_LAST];
59+ u32 index_counts[BLOCK_LAST];
60 MGMeshDesc desc;
61- BlockType block;
62- i32 face;
63- i32 x;
64- i32 y;
65- i32 z;
66+ BlockType block;
67+ i32 face;
68+ i32 x;
69+ i32 y;
70+ i32 z;
71
72 if (!chunk)
73 return 0;
74@@ -180,11 +174,9 @@ i8 chunk_mesh_create(Chunk* chunk)
75 continue;
76
77 for (face = 0; face < 6; face++) {
78- if (chunk_get(
79- chunk, x + face_offsets[face][0],
80- y + face_offsets[face][1],
81- z + face_offsets[face][2]
82- ) == BLOCK_AIR)
83+ if (chunk_get(chunk, x + face_offsets[face][0],
84+ y + face_offsets[face][1],
85+ z + face_offsets[face][2]) == BLOCK_AIR)
86 face_counts[block]++;
87 }
88 }
89@@ -219,19 +211,14 @@ i8 chunk_mesh_create(Chunk* chunk)
90 continue;
91
92 for (face = 0; face < 6; face++) {
93- if (chunk_get(
94- chunk,
95- x + face_offsets[face][0],
96- y + face_offsets[face][1],
97- z + face_offsets[face][2]
98- ) != BLOCK_AIR)
99+ if (chunk_get(chunk, x + face_offsets[face][0],
100+ y + face_offsets[face][1],
101+ z + face_offsets[face][2]) != BLOCK_AIR)
102 continue;
103
104- add_face(
105- vertices[block], indices[block],
106- &vertex_counts[block], &index_counts[block],
107- face, x, y, z
108- );
109+ add_face(vertices[block], indices[block],
110+ &vertex_counts[block], &index_counts[block], face,
111+ x, y, z);
112 }
113 }
114 }
115@@ -284,4 +271,3 @@ void chunk_mesh_destroy(Chunk* chunk)
116 chunk->meshes[block] = MGMESH_INVALID;
117 }
118 }
119-