commit cdabf96
uint
·
2026-08-04 15:59:13 +0000 UTC
parent 38139ba
add more error codes, error codes to mc errors
11 files changed,
+112,
-56
+34,
-0
1@@ -21,6 +21,39 @@ typedef struct {
2 size_t size;
3 } MCPacket;
4
5+typedef enum {
6+ MC_EC_OK,
7+ MC_EC_INVALID_ADDRESS,
8+ MC_EC_RESOLVE_FAILED,
9+ MC_EC_CONNECT_FAILED,
10+ MC_EC_SOCKET_READ,
11+ MC_EC_SOCKET_WRITE,
12+ MC_EC_INVALID_PACKET_LENGTH,
13+ MC_EC_INVALID_COMPRESSED_PACKET,
14+ MC_EC_ZLIB,
15+ MC_EC_MALFORMED_PACKET,
16+ MC_EC_OUT_OF_MEMORY,
17+ MC_EC_INVALID_PUBLIC_KEY,
18+ MC_EC_RSA_MESSAGE_TOO_LARGE,
19+ MC_EC_RSA_ENCRYPT,
20+ MC_EC_RANDOM,
21+ MC_EC_TLS_INIT,
22+ MC_EC_TLS_CONFIG,
23+ MC_EC_TLS_CONNECT,
24+ MC_EC_TLS_WRITE,
25+ MC_EC_TLS_READ,
26+ MC_EC_SESSION_REJECTED,
27+ MC_EC_LOGIN_DISCONNECT,
28+ MC_EC_UNEXPECTED_LOGIN_PACKET,
29+ MC_EC_INVALID_CLIENT,
30+ MC_EC_POLL,
31+ MC_EC_CONNECTION_CLOSED,
32+ MC_EC_LOGIN_START,
33+ MC_EC_INVALID_ACCOUNT,
34+
35+ MC_EC_LAST
36+} MCErrorCode;
37+
38 int mc_client_login(MCClient** out, const char* address, const MCAccount* account, char* error, size_t error_size);
39 void mc_client_interrupt(MCClient* client);
40 void mc_client_destroy(MCClient* client);
41@@ -42,5 +75,6 @@ int mc_client_send_position_look(MCClient* client, double x, double feet_y, doub
42
43 const char* mc_client_username(const MCClient* client);
44 const char* mc_client_uuid(const MCClient* client);
45+MCErrorCode mc_last_error_code(void);
46
47 #endif /* MC_PROTO_H */
+7,
-2
1@@ -3,7 +3,6 @@
2
3 #define RGBA(r, g, b, a) (((u32)(r)) | ((u32)(g) << 8) | ((u32)(b) << 16) | ((u32)(a) << 24))
4
5-/* TODO: rename to MG_EC_... */
6 typedef enum {
7 MG_EC_EXIT_SUCCESS,
8 MG_EC_EXIT_FAILURE,
9@@ -14,12 +13,16 @@ typedef enum {
10
11 MG_EC_SDL_INIT,
12 MG_EC_SDL_CREATE_WIN,
13+ MG_EC_SDL_CREATE_RENDERER,
14
15+ MG_EC_MAUS_INIT,
16 MG_EC_MAUS_CREATE_WIN,
17+ MG_EC_MAUS_RESIZE,
18
19 MG_EC_GL_CTX_CREATE,
20 MG_EC_GL_CTX_ACTIVATE,
21
22+ MG_EC_SOKOL_INIT,
23 MG_EC_SHADER_CREATE,
24
25 MG_EC_PIPELINE_CREATE,
26@@ -31,7 +34,9 @@ typedef enum {
27 MG_EC_SAMPLER_CREATE,
28 MG_EC_VIEW_CREATE,
29
30- MG_EC_REN_CREATE,
31+ MG_EC_SMALL3D_FRAMEBUFFER_LIMIT,
32+ MG_EC_SMALL3D_FRAMEBUFFER_ALLOC,
33+ MG_EC_SMALL3D_SCREEN_TEXTURE_CREATE,
34
35 MG_EC_LAST
36 } MGErrorCodes;
+13,
-11
1@@ -132,7 +132,7 @@ int mc_join_server(const MCAccount* account, const char* server_id, const u8 sha
2
3 if (!account->access_token || !account->access_token[0] || !account->profile_uuid ||
4 !account->profile_uuid[0]) {
5- mc_set_error(error, error_size,
6+ mc_set_error(MC_EC_INVALID_ACCOUNT, error, error_size,
7 "online-mode server requires "
8 "MANGOLIA_ACCESS_TOKEN and MANGOLIA_PROFILE_UUID");
9 return 0;
10@@ -145,26 +145,26 @@ int mc_join_server(const MCAccount* account, const char* server_id, const u8 sha
11 if (!bufwrite(&json, "{\"accessToken\":", 15) || !json_string(&json, account->access_token) ||
12 !bufwrite(&json, ",\"selectedProfile\":", 19) || !json_string(&json, account->profile_uuid) ||
13 !bufwrite(&json, ",\"serverId\":", 12) || !json_string(&json, hash) || !bufwrite_u8(&json, '}')) {
14- mc_set_error(error, error_size, "out of memory building session request");
15+ mc_set_error(MC_EC_OUT_OF_MEMORY, error, error_size, "out of memory building session request");
16 goto cleanup;
17 }
18
19 if (tls_init() != 0) {
20- mc_set_error(error, error_size, "libtls initialization failed");
21+ mc_set_error(MC_EC_TLS_INIT, error, error_size, "libtls initialization failed");
22 goto cleanup;
23 }
24 config = tls_config_new();
25 tls = tls_client();
26 if (!config || !tls) {
27- mc_set_error(error, error_size, "libtls request initialization failed");
28+ mc_set_error(MC_EC_TLS_INIT, error, error_size, "libtls request initialization failed");
29 goto cleanup;
30 }
31 if (tls_configure(tls, config) != 0) {
32- mc_set_error(error, error_size, "libtls configure failed: %s", tls_error(tls));
33+ mc_set_error(MC_EC_TLS_CONFIG, error, error_size, "libtls configure failed: %s", tls_error(tls));
34 goto cleanup;
35 }
36 if (tls_connect(tls, MC_JOIN_HOST, MC_JOIN_PORT) != 0) {
37- mc_set_error(error, error_size, "session TLS connect failed: %s", tls_error(tls));
38+ mc_set_error(MC_EC_TLS_CONNECT, error, error_size, "session TLS connect failed: %s", tls_error(tls));
39 goto cleanup;
40 }
41 snprintf(headers, sizeof(headers),
42@@ -177,22 +177,24 @@ int mc_join_server(const MCAccount* account, const char* server_id, const u8 sha
43 "\r\n",
44 (unsigned long)json.size);
45 if (!bufwrite(&request, headers, strlen(headers)) || !bufwrite(&request, json.data, json.size)) {
46- mc_set_error(error, error_size, "out of memory building session HTTP request");
47+ mc_set_error(MC_EC_OUT_OF_MEMORY, error, error_size, "out of memory building session HTTP request");
48 goto cleanup;
49 }
50 if (!tls_write_all(tls, request.data, request.size)) {
51- mc_set_error(error, error_size, "session join request write failed: %s", tls_error(tls));
52+ mc_set_error(MC_EC_TLS_WRITE, error, error_size, "session join request write failed: %s",
53+ tls_error(tls));
54 goto cleanup;
55 }
56 if (!tls_read_response(tls, &response)) {
57- mc_set_error(error, error_size, "session join response read failed: %s", tls_error(tls));
58+ mc_set_error(MC_EC_TLS_READ, error, error_size, "session join response read failed: %s",
59+ tls_error(tls));
60 goto cleanup;
61 }
62 status = http_status(&response);
63 if (status != 204) {
64 size_t show = response.size < 400 ? response.size : 400;
65- mc_set_error(error, error_size, "session server rejected join (HTTP %ld): %.*s", status, (int)show,
66- response.data ? (char*)response.data : "");
67+ mc_set_error(MC_EC_SESSION_REJECTED, error, error_size, "session server rejected join (HTTP %ld): %.*s",
68+ status, (int)show, response.data ? (char*)response.data : "");
69 goto cleanup;
70 }
71 ok = 1;
+9,
-1
1@@ -5,10 +5,18 @@
2
3 #include "mc_internal.h"
4
5-void mc_set_error(char* error, size_t error_size, const char* fmt, ...)
6+static MCErrorCode mc_last_error = MC_EC_OK;
7+
8+MCErrorCode mc_last_error_code(void)
9+{
10+ return mc_last_error;
11+}
12+
13+void mc_set_error(MCErrorCode code, char* error, size_t error_size, const char* fmt, ...)
14 {
15 va_list args;
16
17+ mc_last_error = code;
18 if (!error || error_size == 0)
19 return;
20 va_start(args, fmt);
+33,
-27
1@@ -30,7 +30,7 @@ static int split_address(const char* address, char* host, size_t host_size, u16*
2 if (address[0] == '[') {
3 const char* close = strchr(address, ']');
4 if (!close) {
5- mc_set_error(error, error_size, "invalid bracketed IPv6 address");
6+ mc_set_error(MC_EC_INVALID_ADDRESS, error, error_size, "invalid bracketed IPv6 address");
7 return 0;
8 }
9 length = (size_t)(close - address - 1);
10@@ -39,7 +39,7 @@ static int split_address(const char* address, char* host, size_t host_size, u16*
11 parsed_port = strtol(close + 2, &port_end, 10);
12 }
13 else if (close[1] != '\0') {
14- mc_set_error(error, error_size, "invalid address suffix");
15+ mc_set_error(MC_EC_INVALID_ADDRESS, error, error_size, "invalid address suffix");
16 return 0;
17 }
18 }
19@@ -51,7 +51,7 @@ static int split_address(const char* address, char* host, size_t host_size, u16*
20 length = (size_t)(end - address);
21 }
22 if ((port_end && *port_end) || length == 0 || length >= host_size || parsed_port < 1 || parsed_port > 65535) {
23- mc_set_error(error, error_size, "invalid server address");
24+ mc_set_error(MC_EC_INVALID_ADDRESS, error, error_size, "invalid server address");
25 return 0;
26 }
27 memcpy(host, address, length);
28@@ -76,7 +76,8 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
29
30 result = getaddrinfo(client->host, service, &hints, &addresses);
31 if (result != 0) {
32- mc_set_error(error, error_size, "could not resolve %s: %s", client->host, gai_strerror(result));
33+ mc_set_error(MC_EC_RESOLVE_FAILED, error, error_size, "could not resolve %s: %s", client->host,
34+ gai_strerror(result));
35 return 0;
36 }
37
38@@ -92,8 +93,8 @@ static int tcp_connect(MCClient* client, char* error, size_t error_size)
39 freeaddrinfo(addresses);
40
41 if (client->socket_fd < 0) {
42- mc_set_error(error, error_size, "could not connect to %s:%u: %s", client->host, client->port,
43- strerror(errno));
44+ mc_set_error(MC_EC_CONNECT_FAILED, error, error_size, "could not connect to %s:%u: %s", client->host,
45+ client->port, strerror(errno));
46 return 0;
47 }
48 return 1;
49@@ -240,22 +241,23 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
50 bufinit(&frame);
51 bufinit(&decoded);
52 if (!socket_read_varint(client, &frame_length)) {
53- mc_set_error(error, error_size, "connection closed while reading packet length");
54+ mc_set_error(MC_EC_SOCKET_READ, error, error_size, "connection closed while reading packet length");
55 goto cleanup;
56 }
57 if (frame_length <= 0 || (u32)frame_length > MC_MAX_PACKET_SIZE || !bufreserve(&frame, (size_t)frame_length)) {
58- mc_set_error(error, error_size, "invalid packet length: %d", frame_length);
59+ mc_set_error(MC_EC_INVALID_PACKET_LENGTH, error, error_size, "invalid packet length: %d", frame_length);
60 goto cleanup;
61 }
62 frame.size = (size_t)frame_length;
63 if (!socket_read(client, frame.data, frame.size)) {
64- mc_set_error(error, error_size, "connection closed while reading packet");
65+ mc_set_error(MC_EC_SOCKET_READ, error, error_size, "connection closed while reading packet");
66 goto cleanup;
67 }
68 if (client->compression_threshold >= 0) {
69 /* same as before data length 0 means no compression */
70 if (!bufread_varint(&frame, &data_length) || data_length < 0 || (u32)data_length > MC_MAX_PACKET_SIZE) {
71- mc_set_error(error, error_size, "invalid compressed packet header");
72+ mc_set_error(MC_EC_INVALID_COMPRESSED_PACKET, error, error_size,
73+ "invalid compressed packet header");
74 goto cleanup;
75 }
76 if (data_length == 0) {
77@@ -268,7 +270,7 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
78 uncompress(decoded.data, &output_size, frame.data + frame.cursor,
79 (uLong)(frame.size - frame.cursor)) != Z_OK ||
80 output_size != (uLongf)data_length) {
81- mc_set_error(error, error_size, "invalid zlib packet");
82+ mc_set_error(MC_EC_ZLIB, error, error_size, "invalid zlib packet");
83 goto cleanup;
84 }
85 decoded_allocated = 1;
86@@ -280,13 +282,13 @@ int mc_client_read(MCClient* client, MCPacket* packet, char* error, size_t error
87 decoded.size = frame.size;
88 }
89 if (!bufread_varint(&decoded, &packet_id)) {
90- mc_set_error(error, error_size, "packet has no valid id");
91+ mc_set_error(MC_EC_MALFORMED_PACKET, error, error_size, "packet has no valid id");
92 goto cleanup;
93 }
94 packet->size = decoded.size - decoded.cursor;
95 packet->data = (u8*)malloc(packet->size ? packet->size : 1);
96 if (!packet->data) {
97- mc_set_error(error, error_size, "out of memory reading packet");
98+ mc_set_error(MC_EC_OUT_OF_MEMORY, error, error_size, "out of memory reading packet");
99 goto cleanup;
100 }
101 memcpy(packet->data, decoded.data + decoded.cursor, packet->size);
102@@ -358,12 +360,12 @@ static int handle_encryption(MCClient* client, const MCAccount* account, MCPacke
103 if (!bufread_string(&input, server_id, sizeof(server_id)) ||
104 !bufread_bytes(&input, &public_key, &public_key_size) ||
105 !bufread_bytes(&input, &verify_token, &verify_token_size)) {
106- mc_set_error(error, error_size, "malformed encryption request");
107+ mc_set_error(MC_EC_MALFORMED_PACKET, error, error_size, "malformed encryption request");
108 return 0;
109 }
110 /* create the AES shared secret for the connection */
111 if (!mg_random_bytes(shared_secret, sizeof(shared_secret))) {
112- mc_set_error(error, error_size, "could not obtain secure random bytes");
113+ mc_set_error(MC_EC_RANDOM, error, error_size, "could not obtain secure random bytes");
114 return 0;
115 }
116 /* join the mojang session, encrypt the secret, verify token */
117@@ -387,7 +389,7 @@ static int handle_encryption(MCClient* client, const MCAccount* account, MCPacke
118 ok = 1;
119 }
120 else {
121- mc_set_error(error, error_size, "could not send encryption response");
122+ mc_set_error(MC_EC_SOCKET_WRITE, error, error_size, "could not send encryption response");
123 }
124 buffree(&response);
125
126@@ -421,7 +423,8 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
127 char reason[1024];
128 if (!bufread_string(&input, reason, sizeof(reason)))
129 strcpy(reason, "malformed disconnect reason");
130- mc_set_error(error, error_size, "server disconnected during login: %s", reason);
131+ mc_set_error(MC_EC_LOGIN_DISCONNECT, error, error_size, "server disconnected during login: %s",
132+ reason);
133 mc_packet_free(&packet);
134 return 0;
135 }
136@@ -436,7 +439,8 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
137 char username[64];
138 if (!bufread_string(&input, client->uuid, sizeof(client->uuid)) ||
139 !bufread_string(&input, username, sizeof(username))) {
140- mc_set_error(error, error_size, "malformed login success packet");
141+ mc_set_error(MC_EC_MALFORMED_PACKET, error, error_size,
142+ "malformed login success packet");
143 mc_packet_free(&packet);
144 return 0;
145 }
146@@ -447,7 +451,8 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
147 if (packet.id == 0x03) {
148 i32 threshold;
149 if (!bufread_varint(&input, &threshold) || threshold < 0) {
150- mc_set_error(error, error_size, "invalid compression threshold");
151+ mc_set_error(MC_EC_INVALID_COMPRESSED_PACKET, error, error_size,
152+ "invalid compression threshold");
153 mc_packet_free(&packet);
154 return 0;
155 }
156@@ -456,7 +461,8 @@ static int login_loop(MCClient* client, const MCAccount* account, char* error, s
157 mc_packet_free(&packet);
158 continue;
159 }
160- mc_set_error(error, error_size, "unexpected login packet 0x%02x", packet.id);
161+ mc_set_error(MC_EC_UNEXPECTED_LOGIN_PACKET, error, error_size, "unexpected login packet 0x%02x",
162+ packet.id);
163 mc_packet_free(&packet);
164 return 0;
165 }
166@@ -471,17 +477,17 @@ int mc_client_login(MCClient** out, const char* address, const MCAccount* accoun
167 if (error && error_size)
168 error[0] = '\0';
169 if (!address || !account || !account->username) {
170- mc_set_error(error, error_size, "missing server address or account");
171+ mc_set_error(MC_EC_INVALID_ACCOUNT, error, error_size, "missing server address or account");
172 return 0;
173 }
174 username_size = strlen(account->username);
175 if (username_size == 0 || username_size > 16) {
176- mc_set_error(error, error_size, "Minecraft username must be 1 to 16 characters");
177+ mc_set_error(MC_EC_INVALID_ACCOUNT, error, error_size, "Minecraft username must be 1 to 16 characters");
178 return 0;
179 }
180 client = (MCClient*)calloc(1, sizeof(*client));
181 if (!client) {
182- mc_set_error(error, error_size, "out of memory creating client");
183+ mc_set_error(MC_EC_OUT_OF_MEMORY, error, error_size, "out of memory creating client");
184 return 0;
185 }
186 client->socket_fd = -1;
187@@ -493,7 +499,7 @@ int mc_client_login(MCClient** out, const char* address, const MCAccount* accoun
188 /*open tcp */
189 !tcp_connect(client, error, error_size) || !send_handshake(client) || !send_login_start(client)) {
190 if (!error || !error_size || !error[0])
191- mc_set_error(error, error_size, "could not start Minecraft login");
192+ mc_set_error(MC_EC_LOGIN_START, error, error_size, "could not start Minecraft login");
193 mc_client_destroy(client);
194 return 0;
195 }
196@@ -528,7 +534,7 @@ int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error
197 int result;
198
199 if (!client || client->socket_fd < 0) {
200- mc_set_error(error, error_size, "invalid Minecraft client");
201+ mc_set_error(MC_EC_INVALID_CLIENT, error, error_size, "invalid Minecraft client");
202 return -1;
203 }
204
205@@ -541,7 +547,7 @@ int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error
206 } while (result < 0 && errno == EINTR);
207
208 if (result < 0) {
209- mc_set_error(error, error_size, "socket poll failed: %s", strerror(errno));
210+ mc_set_error(MC_EC_POLL, error, error_size, "socket poll failed: %s", strerror(errno));
211 return -1;
212 }
213
214@@ -556,7 +562,7 @@ int mc_client_poll(MCClient* client, MCPacket* packet, char* error, size_t error
215 }
216
217 if (fd.revents & (POLLERR | POLLHUP | POLLNVAL)) {
218- mc_set_error(error, error_size, "Minecraft connection closed");
219+ mc_set_error(MC_EC_CONNECTION_CLOSED, error, error_size, "Minecraft connection closed");
220 return -1;
221 }
222
+7,
-7
1@@ -61,12 +61,12 @@ static int rsa_public_key(const u8* der, size_t der_size, br_rsa_public_key* key
2
3 if (!der_value(&root, 0x30, &spki) || !der_value(&spki, 0x30, &algorithm) || !der_value(&spki, 0x03, &bits) ||
4 bits.size < 1 || bits.data[0] != 0) {
5- mc_set_error(error, error_size, "invalid X.509 RSA public key");
6+ mc_set_error(MC_EC_INVALID_PUBLIC_KEY, error, error_size, "invalid X.509 RSA public key");
7 return 0;
8 }
9 bits.cursor = 1;
10 if (!der_value(&bits, 0x30, &rsa) || !der_value(&rsa, 0x02, &modulus) || !der_value(&rsa, 0x02, &exponent)) {
11- mc_set_error(error, error_size, "invalid RSA public key integers");
12+ mc_set_error(MC_EC_INVALID_PUBLIC_KEY, error, error_size, "invalid RSA public key integers");
13 return 0;
14 }
15 while (modulus.size > 1 && modulus.data[0] == 0) {
16@@ -133,12 +133,12 @@ int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* messa
17 if (!rsa_public_key(public_key, public_key_size, &key, error, error_size))
18 return 0;
19 if (message_size + 11 > key.nlen) {
20- mc_set_error(error, error_size, "message is too large for server RSA key");
21+ mc_set_error(MC_EC_RSA_MESSAGE_TOO_LARGE, error, error_size, "message is too large for server RSA key");
22 return 0;
23 }
24 output = (u8*)malloc(key.nlen);
25 if (!output) {
26- mc_set_error(error, error_size, "out of memory encrypting login response");
27+ mc_set_error(MC_EC_OUT_OF_MEMORY, error, error_size, "out of memory encrypting login response");
28 return 0;
29 }
30 padding_size = key.nlen - message_size - 3;
31@@ -148,14 +148,14 @@ int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* messa
32 nonzero */
33 if (!mg_random_bytes(output + 2, padding_size)) {
34 free(output);
35- mc_set_error(error, error_size, "could not obtain secure random bytes");
36+ mc_set_error(MC_EC_RANDOM, error, error_size, "could not obtain secure random bytes");
37 return 0;
38 }
39 for (i = 0; i < padding_size; ++i) {
40 while (output[2 + i] == 0) {
41 if (!mg_random_bytes(output + 2 + i, 1)) {
42 free(output);
43- mc_set_error(error, error_size, "could not obtain secure random bytes");
44+ mc_set_error(MC_EC_RANDOM, error, error_size, "could not obtain secure random bytes");
45 return 0;
46 }
47 }
48@@ -166,7 +166,7 @@ int mc_rsa_encrypt(const u8* public_key, size_t public_key_size, const u8* messa
49 rsa = br_rsa_public_get_default();
50 if (!rsa || !rsa(output, key.nlen, &key)) {
51 free(output);
52- mc_set_error(error, error_size, "BearSSL RSA encryption failed");
53+ mc_set_error(MC_EC_RSA_ENCRYPT, error, error_size, "BearSSL RSA encryption failed");
54 return 0;
55 }
56 *encrypted = output;
+1,
-1
1@@ -35,7 +35,7 @@ struct MCClient {
2 MCCipher write_cipher;
3 };
4
5-void mc_set_error(char* error, size_t error_size, const char* fmt, ...);
6+void mc_set_error(MCErrorCode code, char* error, size_t error_size, const char* fmt, ...);
7
8 void bufinit(MCBuffer* buffer);
9 void buffree(MCBuffer* buffer);
+2,
-2
1@@ -67,7 +67,7 @@ i32 platform_poll(MGContext* ctx)
2 ctx->width = (i32)ev.resize.width;
3 ctx->height = (i32)ev.resize.height;
4 if (!maus_resize(ctx->win, ev.resize.width, ev.resize.height))
5- mg_die(MG_EC_REN_CREATE, "Failed to resize maus framebuffer");
6+ mg_die(MG_EC_MAUS_RESIZE, "Failed to resize maus framebuffer");
7 break;
8 default:
9 break;
10@@ -113,7 +113,7 @@ void platform_window_create(MGContext* ctx)
11 platform_ctx = ctx;
12 ctx->win = maus_init(ctx->title, ctx->x, ctx->y, ctx->width, ctx->height);
13 if (!ctx->win)
14- mg_die(MG_EC_MAUS_CREATE_WIN, "Failed to initialise maus");
15+ mg_die(MG_EC_MAUS_INIT, "Failed to initialise maus");
16
17 if (!maus_create_window(ctx->win))
18 mg_die(MG_EC_MAUS_CREATE_WIN, "Failed to create maus window");
+1,
-1
1@@ -169,7 +169,7 @@ void platform_window_create(MGContext* ctx)
2 if (!ctx->vbe.renderer)
3 ctx->vbe.renderer = SDL_CreateRenderer(ctx->win, -1, SDL_RENDERER_SOFTWARE);
4 if (!ctx->vbe.renderer)
5- mg_die(MG_EC_REN_CREATE, "Failed to create SDL renderer: %s", SDL_GetError());
6+ mg_die(MG_EC_SDL_CREATE_RENDERER, "Failed to create SDL renderer: %s", SDL_GetError());
7 #endif
8
9 #ifdef MG_RENDERER_SOKOL
1@@ -137,12 +137,13 @@ static void create_screen_texture(i32 width, i32 height)
2 return;
3
4 if (width > S3L_MAX_WIDTH || height > S3L_MAX_HEIGHT)
5- mg_die(MG_EC_REN_CREATE, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH, S3L_MAX_HEIGHT);
6+ mg_die(MG_EC_SMALL3D_FRAMEBUFFER_LIMIT, "small3dlib framebuffer exceeds %dx%d", S3L_MAX_WIDTH,
7+ S3L_MAX_HEIGHT);
8
9 pixel_count = (u64)width * (u64)height;
10 framebuffer = malloc(pixel_count * sizeof(*framebuffer));
11 if (!framebuffer)
12- mg_die(MG_EC_REN_CREATE, "Failed to allocate small3dlib framebuffer");
13+ mg_die(MG_EC_SMALL3D_FRAMEBUFFER_ALLOC, "Failed to allocate small3dlib framebuffer");
14
15 #ifdef MG_PLATFORM_SDL
16 if (ren.screen_texture)
17@@ -152,7 +153,7 @@ static void create_screen_texture(i32 width, i32 height)
18 SDL_TEXTUREACCESS_STREAMING, width, height);
19
20 if (!ren.screen_texture)
21- mg_die(MG_EC_REN_CREATE, "Failed to create small3dlib texture: %s", SDL_GetError());
22+ mg_die(MG_EC_SMALL3D_SCREEN_TEXTURE_CREATE, "Failed to create small3dlib texture: %s", SDL_GetError());
23 #endif
24
25 free(ren.framebuffer);
+1,
-1
1@@ -169,7 +169,7 @@ void renderer_backend_create(MGContext* ctx)
2 sg_setup(&desc);
3
4 if (!sg_isvalid())
5- mg_die(MG_EC_REN_CREATE, "Failed to initialise renderer");
6+ mg_die(MG_EC_SOKOL_INIT, "Failed to initialise renderer");
7
8 create_pipelines();
9 create_sampler();