1
/*
2
 * Copyright (c) 2018 naehrwert
3
 * Copyright (c) 2018-2022 CTCaer
4
 *
5
 * This program is free software; you can redistribute it and/or modify it
6
 * under the terms and conditions of the GNU General Public License,
7
 * version 2, as published by the Free Software Foundation.
8
 *
9
 * This program is distributed in the hope it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12
 * more details.
13
 *
14
 * You should have received a copy of the GNU General Public License
15
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16
 */
17

18
#include <stdarg.h>
19
#include <string.h>
20
#include "gfx.h"
21

22
#define COLUMN2_X 640
23

24
// Global gfx console and context.
25
gfx_ctxt_t gfx_ctxt;
26
gfx_con_t gfx_con;
27

28
static bool gfx_con_init_done = false;
29

30
static const u8 _gfx_font[] = {
31
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 032 ( )
32
	0x00, 0x30, 0x30, 0x18, 0x18, 0x00, 0x0C, 0x00, // Char 033 (!)
33
	0x00, 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, // Char 034 (")
34
	0x00, 0x66, 0x66, 0xFF, 0x66, 0xFF, 0x66, 0x66, // Char 035 (#)
35
	0x00, 0x18, 0x7C, 0x06, 0x3C, 0x60, 0x3E, 0x18, // Char 036 ($)
36
	0x00, 0x46, 0x66, 0x30, 0x18, 0x0C, 0x66, 0x62, // Char 037 (%)
37
	0x00, 0x3C, 0x66, 0x3C, 0x1C, 0xE6, 0x66, 0xFC, // Char 038 (&)
38
	0x00, 0x18, 0x0C, 0x06, 0x00, 0x00, 0x00, 0x00, // Char 039 (')
39
	0x00, 0x30, 0x18, 0x0C, 0x0C, 0x18, 0x30, 0x00, // Char 040 (()
40
	0x00, 0x0C, 0x18, 0x30, 0x30, 0x18, 0x0C, 0x00, // Char 041 ())
41
	0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00, // Char 042 (*)
42
	0x00, 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x00, // Char 043 (+)
43
	0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x0C, 0x00, // Char 044 (,)
44
	0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x00, // Char 045 (-)
45
	0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, // Char 046 (.)
46
	0x00, 0x40, 0x60, 0x30, 0x18, 0x0C, 0x06, 0x00, // Char 047 (/)
47
	0x00, 0x3C, 0x66, 0x76, 0x6E, 0x66, 0x3C, 0x00, // Char 048 (0)
48
	0x00, 0x18, 0x1C, 0x18, 0x18, 0x18, 0x7E, 0x00, // Char 049 (1)
49
	0x00, 0x3C, 0x62, 0x30, 0x0C, 0x06, 0x7E, 0x00, // Char 050 (2)
50
	0x00, 0x3C, 0x62, 0x38, 0x60, 0x66, 0x3C, 0x00, // Char 051 (3)
51
	0x00, 0x6C, 0x6C, 0x66, 0xFE, 0x60, 0x60, 0x00, // Char 052 (4)
52
	0x00, 0x7E, 0x06, 0x7E, 0x60, 0x66, 0x3C, 0x00, // Char 053 (5)
53
	0x00, 0x3C, 0x06, 0x3E, 0x66, 0x66, 0x3C, 0x00, // Char 054 (6)
54
	0x00, 0x7E, 0x30, 0x30, 0x18, 0x18, 0x18, 0x00, // Char 055 (7)
55
	0x00, 0x3C, 0x66, 0x3C, 0x66, 0x66, 0x3C, 0x00, // Char 056 (8)
56
	0x00, 0x3C, 0x66, 0x7C, 0x60, 0x66, 0x3C, 0x00, // Char 057 (9)
57
	0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x18, 0x00, // Char 058 (:)
58
	0x00, 0x00, 0x18, 0x00, 0x18, 0x18, 0x0C, 0x00, // Char 059 (;)
59
	0x00, 0x70, 0x1C, 0x06, 0x06, 0x1C, 0x70, 0x00, // Char 060 (<)
60
	0x00, 0x00, 0x3E, 0x00, 0x3E, 0x00, 0x00, 0x00, // Char 061 (=)
61
	0x00, 0x0E, 0x38, 0x60, 0x60, 0x38, 0x0E, 0x00, // Char 062 (>)
62
	0x00, 0x3C, 0x66, 0x30, 0x18, 0x00, 0x18, 0x00, // Char 063 (?)
63
	0x00, 0x3C, 0x66, 0x76, 0x76, 0x06, 0x46, 0x3C, // Char 064 (@)
64
	0x00, 0x3C, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, // Char 065 (A)
65
	0x00, 0x3E, 0x66, 0x3E, 0x66, 0x66, 0x3E, 0x00, // Char 066 (B)
66
	0x00, 0x3C, 0x66, 0x06, 0x06, 0x66, 0x3C, 0x00, // Char 067 (C)
67
	0x00, 0x1E, 0x36, 0x66, 0x66, 0x36, 0x1E, 0x00, // Char 068 (D)
68
	0x00, 0x7E, 0x06, 0x1E, 0x06, 0x06, 0x7E, 0x00, // Char 069 (E)
69
	0x00, 0x3E, 0x06, 0x1E, 0x06, 0x06, 0x06, 0x00, // Char 070 (F)
70
	0x00, 0x3C, 0x66, 0x06, 0x76, 0x66, 0x3C, 0x00, // Char 071 (G)
71
	0x00, 0x66, 0x66, 0x7E, 0x66, 0x66, 0x66, 0x00, // Char 072 (H)
72
	0x00, 0x3C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 073 (I)
73
	0x00, 0x78, 0x30, 0x30, 0x30, 0x36, 0x1C, 0x00, // Char 074 (J)
74
	0x00, 0x66, 0x36, 0x1E, 0x1E, 0x36, 0x66, 0x00, // Char 075 (K)
75
	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x7E, 0x00, // Char 076 (L)
76
	0x00, 0x46, 0x6E, 0x7E, 0x56, 0x46, 0x46, 0x00, // Char 077 (M)
77
	0x00, 0x66, 0x6E, 0x7E, 0x76, 0x66, 0x66, 0x00, // Char 078 (N)
78
	0x00, 0x3C, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, // Char 079 (O)
79
	0x00, 0x3E, 0x66, 0x3E, 0x06, 0x06, 0x06, 0x00, // Char 080 (P)
80
	0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x70, 0x00, // Char 081 (Q)
81
	0x00, 0x3E, 0x66, 0x3E, 0x1E, 0x36, 0x66, 0x00, // Char 082 (R)
82
	0x00, 0x3C, 0x66, 0x0C, 0x30, 0x66, 0x3C, 0x00, // Char 083 (S)
83
	0x00, 0x7E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, // Char 084 (T)
84
	0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x00, // Char 085 (U)
85
	0x00, 0x66, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, // Char 086 (V)
86
	0x00, 0x46, 0x46, 0x56, 0x7E, 0x6E, 0x46, 0x00, // Char 087 (W)
87
	0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x66, 0x00, // Char 088 (X)
88
	0x00, 0x66, 0x66, 0x3C, 0x18, 0x18, 0x18, 0x00, // Char 089 (Y)
89
	0x00, 0x7E, 0x30, 0x18, 0x0C, 0x06, 0x7E, 0x00, // Char 090 (Z)
90
	0x00, 0x3C, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x3C, // Char 091 ([)
91
	0x00, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00, // Char 092 (\)
92
	0x00, 0x3C, 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, // Char 093 (])
93
	0x00, 0x18, 0x3C, 0x66, 0x00, 0x00, 0x00, 0x00, // Char 094 (^)
94
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, // Char 095 (_)
95
	0x00, 0x0C, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, // Char 096 (`)
96
	0x00, 0x00, 0x3C, 0x60, 0x7C, 0x66, 0x7C, 0x00, // Char 097 (a)
97
	0x00, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3E, 0x00, // Char 098 (b)
98
	0x00, 0x00, 0x3C, 0x06, 0x06, 0x06, 0x3C, 0x00, // Char 099 (c)
99
	0x00, 0x60, 0x60, 0x7C, 0x66, 0x66, 0x7C, 0x00, // Char 100 (d)
100
	0x00, 0x00, 0x3C, 0x66, 0x7E, 0x06, 0x3C, 0x00, // Char 101 (e)
101
	0x00, 0x38, 0x0C, 0x3E, 0x0C, 0x0C, 0x0C, 0x00, // Char 102 (f)
102
	0x00, 0x00, 0x7C, 0x66, 0x7C, 0x40, 0x3C, 0x00, // Char 103 (g)
103
	0x00, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x66, 0x00, // Char 104 (h)
104
	0x00, 0x18, 0x00, 0x1C, 0x18, 0x18, 0x3C, 0x00, // Char 105 (i)
105
	0x00, 0x30, 0x00, 0x30, 0x30, 0x30, 0x1E, 0x00, // Char 106 (j)
106
	0x00, 0x06, 0x06, 0x36, 0x1E, 0x36, 0x66, 0x00, // Char 107 (k)
107
	0x00, 0x1C, 0x18, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 108 (l)
108
	0x00, 0x00, 0x66, 0xFE, 0xFE, 0xD6, 0xC6, 0x00, // Char 109 (m)
109
	0x00, 0x00, 0x3E, 0x66, 0x66, 0x66, 0x66, 0x00, // Char 110 (n)
110
	0x00, 0x00, 0x3C, 0x66, 0x66, 0x66, 0x3C, 0x00, // Char 111 (o)
111
	0x00, 0x00, 0x3E, 0x66, 0x66, 0x3E, 0x06, 0x00, // Char 112 (p)
112
	0x00, 0x00, 0x7C, 0x66, 0x66, 0x7C, 0x60, 0x00, // Char 113 (q)
113
	0x00, 0x00, 0x3E, 0x66, 0x06, 0x06, 0x06, 0x00, // Char 114 (r)
114
	0x00, 0x00, 0x7C, 0x06, 0x3C, 0x60, 0x3E, 0x00, // Char 115 (s)
115
	0x00, 0x18, 0x7E, 0x18, 0x18, 0x18, 0x70, 0x00, // Char 116 (t)
116
	0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x7C, 0x00, // Char 117 (u)
117
	0x00, 0x00, 0x66, 0x66, 0x66, 0x3C, 0x18, 0x00, // Char 118 (v)
118
	0x00, 0x00, 0xC6, 0xD6, 0xFE, 0x7C, 0x6C, 0x00, // Char 119 (w)
119
	0x00, 0x00, 0x66, 0x3C, 0x18, 0x3C, 0x66, 0x00, // Char 120 (x)
120
	0x00, 0x00, 0x66, 0x66, 0x7C, 0x60, 0x3C, 0x00, // Char 121 (y)
121
	0x00, 0x00, 0x7E, 0x30, 0x18, 0x0C, 0x7E, 0x00, // Char 122 (z)
122
	0x00, 0x18, 0x08, 0x08, 0x04, 0x08, 0x08, 0x18, // Char 123 ({)
123
	0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, // Char 124 (|)
124
	0x00, 0x0C, 0x08, 0x08, 0x10, 0x08, 0x08, 0x0C, // Char 125 (})
125
	0x00, 0x00, 0x00, 0x4C, 0x32, 0x00, 0x00, 0x00  // Char 126 (~)
126
};
127

128
void gfx_clear_grey(u8 color)
129
{
130
	memset(gfx_ctxt.fb, color, gfx_ctxt.width * gfx_ctxt.height * 4);
131
}
132

133
void gfx_clear_color(u32 color)
134
{
135
	for (u32 i = 0; i < gfx_ctxt.width * gfx_ctxt.height; i++)
136
		gfx_ctxt.fb[i] = color;
137
}
138

139
void gfx_init_ctxt(u32 *fb, u32 width, u32 height, u32 stride)
140
{
141
	gfx_ctxt.fb = fb;
142
	gfx_ctxt.width = width;
143
	gfx_ctxt.height = height;
144
	gfx_ctxt.stride = stride;
145

146
	gfx_clear_grey(0);
147
}
148

149
void gfx_con_init()
150
{
151
	gfx_con.gfx_ctxt = &gfx_ctxt;
152
	gfx_con.fntsz = 16;
153
	gfx_con.x = 0;
154
	gfx_con.y = 0;
155
	gfx_con.col = 0;
156
	gfx_con.savedx = 0;
157
	gfx_con.savedy = 0;
158
	gfx_con.fgcol = TXT_CLR_DEFAULT;
159
	gfx_con.fillbg = 1;
160
	gfx_con.bgcol = TXT_CLR_BG;
161
	gfx_con.mute = 0;
162

163
	gfx_con_init_done = true;
164
}
165

166
void gfx_con_setcol(u32 fgcol, int fillbg, u32 bgcol)
167
{
168
	gfx_con.fgcol = fgcol;
169
	gfx_con.fillbg = fillbg;
170
	gfx_con.bgcol = bgcol;
171
}
172

173
void gfx_con_getpos(u32 *x, u32 *y, u32 *c)
174
{
175
	*x = gfx_con.x;
176
	*y = gfx_con.y;
177
	*c = gfx_con.col;
178
}
179

180
void gfx_con_setpos(u32 x, u32 y, u32 c)
181
{
182
	gfx_con.x = x;
183
	gfx_con.y = y;
184

185
	switch (c)
186
	{
187
	case GFX_COL_KEEP:
188
		break;
189
	case GFX_COL_AUTO:
190
		if (x < COLUMN2_X)
191
			gfx_con.col = 0;
192
		else
193
			gfx_con.col = COLUMN2_X;
194
		break;
195
	default:
196
		gfx_con.col = c;
197
		break;
198
	}
199
}
200

201
void gfx_putc(char c)
202
{
203
	// Duplicate code for performance reasons.
204
	switch (gfx_con.fntsz)
205
	{
206
	case 16:
207
		if (c >= 32 && c <= 126)
208
		{
209
			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
210
			for (u32 i = 0; i < 16; i += 2)
211
			{
212
				u8 v = *cbuf;
213
				for (u32 k = 0; k < 2; k++)
214
				{
215
					u32 fb_off = gfx_con.y + i + k + (gfx_ctxt.width - gfx_con.x) * gfx_ctxt.stride;
216
					for (u32 j = 0; j < 16; j += 2)
217
					{
218
						for (u32 l = 0; l < 2; l++)
219
						{
220
							if (v & 1)
221
								gfx_ctxt.fb[fb_off - (j + l) * gfx_ctxt.stride] = gfx_con.fgcol;
222
							else if (gfx_con.fillbg)
223
								gfx_ctxt.fb[fb_off - (j + l) * gfx_ctxt.stride] = gfx_con.bgcol;
224
						}
225
						v >>= 1;
226
					}
227
					v = *cbuf;
228
				}
229
				cbuf++;
230
			}
231
			gfx_con.x += 16;
232
			if (gfx_con.x > gfx_ctxt.width - 16)
233
			{
234
				gfx_con.x = gfx_con.col;
235
				gfx_con.y += 16;
236
				if (gfx_con.y > gfx_ctxt.height - 33)
237
				{
238
					gfx_con.y = 0;
239

240
					if (!gfx_con.col)
241
						gfx_con.col = COLUMN2_X;
242
					else
243
						gfx_con.col = 0;
244
					gfx_con.x = gfx_con.col;
245
				}
246
			}
247
		}
248
		else if (c == '\n')
249
		{
250
			gfx_con.x = gfx_con.col;
251
			gfx_con.y += 16;
252
			if (gfx_con.y > gfx_ctxt.height - 33)
253
			{
254
				gfx_con.y = 0;
255

256
				if (!gfx_con.col)
257
					gfx_con.col = COLUMN2_X;
258
				else
259
					gfx_con.col = 0;
260
				gfx_con.x = gfx_con.col;
261
			}
262
		}
263
		break;
264
	case 8:
265
	default:
266
		if (c >= 32 && c <= 126)
267
		{
268
			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
269
			for (u32 i = 0; i < 8; i++)
270
			{
271
				u8 v = *cbuf++;
272
				u32 fb_off = gfx_con.y + i + (gfx_ctxt.width - gfx_con.x) * gfx_ctxt.stride;
273
				for (u32 j = 0; j < 8; j++)
274
				{
275
					if (v & 1)
276
						gfx_ctxt.fb[fb_off - (j * gfx_ctxt.stride)] = gfx_con.fgcol;
277
					else if (gfx_con.fillbg)
278
						gfx_ctxt.fb[fb_off - (j * gfx_ctxt.stride)] = gfx_con.bgcol;
279
					v >>= 1;
280
				}
281
			}
282
			gfx_con.x += 8;
283
			if (gfx_con.x > gfx_ctxt.width / 2 + gfx_con.col - 8)
284
			{
285
				gfx_con.x = gfx_con.col;
286
				gfx_con.y += 8;
287
				if (gfx_con.y > gfx_ctxt.height - 33)
288
				{
289
					gfx_con.y = 0;
290

291
					if (!gfx_con.col)
292
						gfx_con.col = COLUMN2_X;
293
					else
294
						gfx_con.col = 0;
295
					gfx_con.x = gfx_con.col;
296
				}
297
			}
298
		}
299
		else if (c == '\n')
300
		{
301
			gfx_con.x = gfx_con.col;
302
			gfx_con.y += 8;
303
			if (gfx_con.y > gfx_ctxt.height - 33)
304
			{
305
				gfx_con.y = 0;
306

307
				if (!gfx_con.col)
308
					gfx_con.col = COLUMN2_X;
309
				else
310
					gfx_con.col = 0;
311
				gfx_con.x = gfx_con.col;
312
			}
313
		}
314
		break;
315
	}
316
}
317

318
void gfx_puts(const char *s)
319
{
320
	if (!s || !gfx_con_init_done || gfx_con.mute)
321
		return;
322

323
	for (; *s; s++)
324
		gfx_putc(*s);
325
}
326

327
static void _gfx_putn(u32 v, int base, char fill, int fcnt)
328
{
329
	static const char digits[] = "0123456789ABCDEF";
330

331
	char *p;
332
	char buf[65];
333
	int c = fcnt;
334
	bool negative = false;
335

336
	if (base != 10 && base != 16)
337
		return;
338

339
	// Account for negative numbers.
340
	if (base == 10 && v & 0x80000000)
341
	{
342
		negative = true;
343
		v = (int)v * -1;
344
		c--;
345
	}
346

347
	p = buf + 64;
348
	*p = 0;
349
	do
350
	{
351
		c--;
352
		*--p = digits[v % base];
353
		v /= base;
354
	} while (v);
355

356
	if (negative)
357
		*--p = '-';
358

359
	if (fill != 0)
360
	{
361
		while (c > 0 && p > buf)
362
		{
363
			*--p = fill;
364
			c--;
365
		}
366
	}
367

368
	gfx_puts(p);
369
}
370

371
void gfx_printf(const char *fmt, ...)
372
{
373
	if (!gfx_con_init_done || gfx_con.mute)
374
		return;
375

376
	va_list ap;
377
	int fill, fcnt;
378

379
	va_start(ap, fmt);
380
	while (*fmt)
381
	{
382
		if (*fmt == '%')
383
		{
384
			fmt++;
385
			fill = 0;
386
			fcnt = 0;
387
			if ((*fmt >= '0' && *fmt <= '9') || *fmt == ' ')
388
			{
389
				fcnt = *fmt;
390
				fmt++;
391
				if (*fmt >= '0' && *fmt <= '9')
392
				{
393
					fill = fcnt;
394
					fcnt = *fmt - '0';
395
					fmt++;
396
				}
397
				else
398
				{
399
					fill = ' ';
400
					fcnt -= '0';
401
				}
402
			}
403
			switch(*fmt)
404
			{
405
			case 'c':
406
				gfx_putc(va_arg(ap, u32));
407
				break;
408
			case 's':
409
				gfx_puts(va_arg(ap, char *));
410
				break;
411
			case 'd':
412
				_gfx_putn(va_arg(ap, u32), 10, fill, fcnt);
413
				break;
414
			case 'p':
415
			case 'P':
416
			case 'x':
417
			case 'X':
418
				_gfx_putn(va_arg(ap, u32), 16, fill, fcnt);
419
				break;
420
			case 'k':
421
				gfx_con.fgcol = va_arg(ap, u32);
422
				break;
423
			case 'K':
424
				gfx_con.bgcol = va_arg(ap, u32);
425
				gfx_con.fillbg = 1;
426
				break;
427
			case '%':
428
				gfx_putc('%');
429
				break;
430
			case '\0':
431
				goto out;
432
			default:
433
				gfx_putc('%');
434
				gfx_putc(*fmt);
435
				break;
436
			}
437
		}
438
		else
439
			gfx_putc(*fmt);
440
		fmt++;
441
	}
442

443
	out:
444
	va_end(ap);
445
}
446

447
static void _gfx_cputs(u32 color, const char *s)
448
{
449
	gfx_con.fgcol = color;
450
	gfx_puts(s);
451
	gfx_putc('\n');
452
	gfx_con.fgcol = TXT_CLR_DEFAULT;
453
}
454

455
void gfx_wputs(const char *s) { _gfx_cputs(TXT_CLR_WARNING, s); }
456
void gfx_eputs(const char *s) { _gfx_cputs(TXT_CLR_ERROR,   s); }
457

458
void gfx_hexdump(u32 base, const void *buf, u32 len)
459
{
460
	if (!gfx_con_init_done || gfx_con.mute)
461
		return;
462

463
	u8 *buff = (u8 *)buf;
464

465
	u8 prevFontSize = gfx_con.fntsz;
466
	gfx_con.fntsz = 8;
467
	for (u32 i = 0; i < len; i++)
468
	{
469
		if (i % 0x10 == 0)
470
		{
471
			if (i != 0)
472
			{
473
				gfx_puts("| ");
474
				for (u32 j = 0; j < 0x10; j++)
475
				{
476
					u8 c = buff[i - 0x10 + j];
477
					if (c >= 32 && c <= 126)
478
						gfx_putc(c);
479
					else
480
						gfx_putc('.');
481
				}
482
				gfx_putc('\n');
483
			}
484
			gfx_printf("%08x: ", base + i);
485
		}
486
		gfx_printf("%02x ", buff[i]);
487
		if (i == len - 1)
488
		{
489
			int ln = len % 0x10 != 0;
490
			u32 k = 0x10 - 1;
491
			if (ln)
492
			{
493
				k = (len & 0xF) - 1;
494
				for (u32 j = 0; j < 0x10 - k; j++)
495
					gfx_puts("   ");
496
			}
497
			gfx_puts("| ");
498
			for (u32 j = 0; j < (ln ? k : k + 1); j++)
499
			{
500
				u8 c = buff[i - k + j];
501
				if (c >= 32 && c <= 126)
502
					gfx_putc(c);
503
				else
504
					gfx_putc('.');
505
			}
506
			gfx_putc('\n');
507
		}
508
	}
509
	gfx_putc('\n');
510
	gfx_con.fntsz = prevFontSize;
511
}
512

513
void gfx_set_pixel(u32 x, u32 y, u32 color)
514
{
515
	gfx_ctxt.fb[y + (gfx_ctxt.width - x) * gfx_ctxt.stride] = color;
516
}
517

518
void gfx_set_rect_pitch(u32 *fb, const u32 *buf, u32 stride, u32 pos_x, u32 pos_y, u32 pos_x2, u32 pos_y2)
519
{
520
	u32 *ptr = (u32 *)buf;
521
	u32 line_size = pos_x2 - pos_x + 1;
522
	//ptr = gfx_debug_rect(buf, pos_x, pos_y, pos_x2, pos_y2);
523
	for (u32 y = pos_y; y <= pos_y2; y++)
524
	{
525
		memcpy(&fb[pos_x + y * stride], ptr, line_size * sizeof(u32));
526
		ptr += line_size;
527
	}
528
}
529

530
void gfx_set_rect_land_pitch(u32 *fb, const u32 *buf, u32 stride, u32 pos_x, u32 pos_y, u32 pos_x2, u32 pos_y2)
531
{
532
	u32 *ptr = (u32 *)buf;
533

534
	u32 pixels_w = pos_x2 - pos_x + 1;
535

536
	if (!(pixels_w % 8))
537
	{
538
		for (u32 y = pos_y; y <= pos_y2; y++)
539
			for (u32 x = pos_x; x <= pos_x2; x += 8)
540
			{
541
				u32 *fbx = &fb[x * stride + y];
542

543
				fbx[0]          = *ptr++;
544
				fbx[stride]     = *ptr++;
545
				fbx[stride * 2] = *ptr++;
546
				fbx[stride * 3] = *ptr++;
547
				fbx[stride * 4] = *ptr++;
548
				fbx[stride * 5] = *ptr++;
549
				fbx[stride * 6] = *ptr++;
550
				fbx[stride * 7] = *ptr++;
551
			}
552
	}
553
	else
554
	{
555
		for (u32 y = pos_y; y < (pos_y2 + 1); y++)
556
			for (u32 x = pos_x; x < (pos_x2 + 1); x++)
557
				fb[x * stride + y] = *ptr++;
558
	}
559
}
560

561
void gfx_set_rect_land_block(u32 *fb, const u32 *buf, u32 pos_x, u32 pos_y, u32 pos_x2, u32 pos_y2)
562
{
563
	u32 *ptr = (u32 *)buf;
564
	u32 GOB_address = 0;
565
	u32 addr = 0;
566
	u32 x2 = 0;
567

568
	// Optimized
569
	u32 image_width_in_gobs = 655360; //1280
570
	for (u32 y = pos_y; y <= pos_y2; y++)
571
	{
572
		for (u32 x = pos_x; x <= pos_x2; x++)
573
		{
574
			GOB_address = (y >> 7) * image_width_in_gobs + ((x >> 4) << 13) + (((y % 128) >> 3) << 9);
575

576
			x2 = x << 2;
577
			addr = GOB_address
578
				+ (((x2 % 64) >> 5) << 8)
579
				+ (((y % 8) >> 1) << 6)
580
				+ (((x2 % 32) >> 4) << 5)
581
				+ ((y % 2) << 4) + (x2 % 16);
582

583
			*(u32 *)(fb + (addr >> 2)) = *ptr++;
584
		}
585
	}
586

587
	// Proper
588
	// u32 block_height = 16;
589
	// u32 image_width_in_gobs = (512 * block_height * 1280 * 4) / 64;
590
	// for (u32 y = pos_y; y <= pos_y2; y++)
591
	// {
592
	// 	for (int x = pos_x; x <= pos_x2; x++)
593
	// 	{
594
	// 		GOB_address = (y / (8 * block_height)) * image_width_in_gobs + ((x * 4 / 64) * 512 * block_height) + ((y % (8 * block_height) / 8) * 512);
595

596
	// 		x2 = x << 2;
597
	// 		addr = GOB_address
598
	// 			+ (((x2 % 64) >> 5) << 8)
599
	// 			+ (((y % 8) >> 1) << 6)
600
	// 			+ (((x2 % 32) >> 4) << 5)
601
	// 			+ ((y % 2) << 4) + (x2 % 16);
602

603
	// 		*(u32 *)(gfx_ctxt.fb + (addr >> 2)) = *ptr++;
604
	// 	}
605
	// }
606
}
607

608