1
/*
2
 * Copyright (c) 2018 naehrwert
3
 * Copyright (c) 2018-2020 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
// Global gfx console and context.
23
gfx_ctxt_t gfx_ctxt;
24
gfx_con_t gfx_con;
25

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

124
void gfx_clear_grey(u8 color)
125
{
126
	memset(gfx_ctxt.fb, color, gfx_ctxt.width * gfx_ctxt.height * 4);
127
}
128

129
void gfx_clear_partial_grey(u8 color, u32 pos_x, u32 height)
130
{
131
	memset(gfx_ctxt.fb + pos_x * gfx_ctxt.stride, color, height * 4 * gfx_ctxt.stride);
132
}
133

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

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

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

162
void gfx_con_setcol(u32 fgcol, int fillbg, u32 bgcol)
163
{
164
	gfx_con.fgcol = fgcol;
165
	gfx_con.fillbg = fillbg;
166
	gfx_con.bgcol = bgcol;
167
}
168

169
void gfx_con_getpos(u32 *x, u32 *y)
170
{
171
	*x = gfx_con.x;
172
	*y = gfx_con.y;
173
}
174

175
void gfx_con_setpos(u32 x, u32 y)
176
{
177
	gfx_con.x = x;
178
	gfx_con.y = y;
179
}
180

181
void gfx_putc(char c)
182
{
183
	// Duplicate code for performance reasons.
184
	switch (gfx_con.fntsz)
185
	{
186
	case 16:
187
		if (c >= 32 && c <= 126)
188
		{
189
			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
190
			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
191

192
			for (u32 i = 0; i < 16; i += 2)
193
			{
194
				u8 v = *cbuf;
195
				for (u32 k = 0; k < 2; k++)
196
				{
197
					for (u32 j = 0; j < 8; j++)
198
					{
199
						if (v & 1)
200
						{
201
							*fb = gfx_con.fgcol;
202
							fb++;
203
							*fb = gfx_con.fgcol;
204
						}
205
						else if (gfx_con.fillbg)
206
						{
207
							*fb = gfx_con.bgcol;
208
							fb++;
209
							*fb = gfx_con.bgcol;
210
						}
211
						else
212
							fb++;
213
						v >>= 1;
214
						fb++;
215
					}
216
					fb += gfx_ctxt.stride - 16;
217
					v = *cbuf;
218
				}
219
				cbuf++;
220
			}
221
			gfx_con.x += 16;
222
		}
223
		else if (c == '\n')
224
		{
225
			gfx_con.x = 0;
226
			gfx_con.y += 16;
227
			if (gfx_con.y > gfx_ctxt.height - 16)
228
				gfx_con.y = 0;
229
		}
230
		break;
231
	case 8:
232
	default:
233
		if (c >= 32 && c <= 126)
234
		{
235
			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
236
			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
237
			for (u32 i = 0; i < 8; i++)
238
			{
239
				u8 v = *cbuf++;
240
				for (u32 j = 0; j < 8; j++)
241
				{
242
					if (v & 1)
243
						*fb = gfx_con.fgcol;
244
					else if (gfx_con.fillbg)
245
						*fb = gfx_con.bgcol;
246
					v >>= 1;
247
					fb++;
248
				}
249
				fb += gfx_ctxt.stride - 8;
250
			}
251
			gfx_con.x += 8;
252
		}
253
		else if (c == '\n')
254
		{
255
			gfx_con.x = 0;
256
			gfx_con.y += 8;
257
			if (gfx_con.y > gfx_ctxt.height - 8)
258
				gfx_con.y = 0;
259
		}
260
		break;
261
	}
262
}
263

264
void gfx_puts(char *s)
265
{
266
	if (!s || gfx_con.mute)
267
		return;
268

269
	for (; *s; s++)
270
		gfx_putc(*s);
271
}
272

273
static void _gfx_putn(u32 v, int base, char fill, int fcnt)
274
{
275
	char buf[65];
276
	static const char digits[] = "0123456789ABCDEFghijklmnopqrstuvwxyz";
277
	char *p;
278
	int c = fcnt;
279

280
	if (base > 36)
281
		return;
282

283
	p = buf + 64;
284
	*p = 0;
285
	do
286
	{
287
		c--;
288
		*--p = digits[v % base];
289
		v /= base;
290
	} while (v);
291

292
	if (fill != 0)
293
	{
294
		while (c > 0)
295
		{
296
			*--p = fill;
297
			c--;
298
		}
299
	}
300

301
	gfx_puts(p);
302
}
303

304
void gfx_put_small_sep()
305
{
306
	u8 prevFontSize = gfx_con.fntsz;
307
	gfx_con.fntsz = 8;
308
	gfx_putc('\n');
309
	gfx_con.fntsz = prevFontSize;
310
}
311

312
void gfx_put_big_sep()
313
{
314
	u8 prevFontSize = gfx_con.fntsz;
315
	gfx_con.fntsz = 16;
316
	gfx_putc('\n');
317
	gfx_con.fntsz = prevFontSize;
318
}
319

320
void gfx_printf(const char *fmt, ...)
321
{
322
	if (gfx_con.mute)
323
		return;
324

325
	va_list ap;
326
	int fill, fcnt;
327

328
	va_start(ap, fmt);
329
	while (*fmt)
330
	{
331
		if (*fmt == '%')
332
		{
333
			fmt++;
334
			fill = 0;
335
			fcnt = 0;
336
			if ((*fmt >= '0' && *fmt <= '9') || *fmt == ' ')
337
			{
338
				fcnt = *fmt;
339
				fmt++;
340
				if (*fmt >= '0' && *fmt <= '9')
341
				{
342
					fill = fcnt;
343
					fcnt = *fmt - '0';
344
					fmt++;
345
				}
346
				else
347
				{
348
					fill = ' ';
349
					fcnt -= '0';
350
				}
351
			}
352
			switch(*fmt)
353
			{
354
			case 'c':
355
				gfx_putc(va_arg(ap, u32));
356
				break;
357
			case 's':
358
				gfx_puts(va_arg(ap, char *));
359
				break;
360
			case 'd':
361
				_gfx_putn(va_arg(ap, u32), 10, fill, fcnt);
362
				break;
363
			case 'p':
364
			case 'P':
365
			case 'x':
366
			case 'X':
367
				_gfx_putn(va_arg(ap, u32), 16, fill, fcnt);
368
				break;
369
			case 'k':
370
				gfx_con.fgcol = va_arg(ap, u32);
371
				break;
372
			case 'K':
373
				gfx_con.bgcol = va_arg(ap, u32);
374
				gfx_con.fillbg = 1;
375
				break;
376
			case '%':
377
				gfx_putc('%');
378
				break;
379
			case '\0':
380
				goto out;
381
			default:
382
				gfx_putc('%');
383
				gfx_putc(*fmt);
384
				break;
385
			}
386
		}
387
		else
388
			gfx_putc(*fmt);
389
		fmt++;
390
	}
391

392
	out:
393
	va_end(ap);
394
}
395

396
void gfx_hexdump(u32 base, const u8 *buf, u32 len)
397
{
398
	if (gfx_con.mute)
399
		return;
400

401
	u8 prevFontSize = gfx_con.fntsz;
402
	gfx_con.fntsz = 8;
403
	for (u32 i = 0; i < len; i++)
404
	{
405
		if (i % 0x10 == 0)
406
		{
407
			if (i != 0)
408
			{
409
				gfx_puts("| ");
410
				for (u32 j = 0; j < 0x10; j++)
411
				{
412
					u8 c = buf[i - 0x10 + j];
413
					if (c >= 32 && c <= 126)
414
						gfx_putc(c);
415
					else
416
						gfx_putc('.');
417
				}
418
				gfx_putc('\n');
419
			}
420
			gfx_printf("%08x: ", base + i);
421
		}
422
		gfx_printf("%02x ", buf[i]);
423
		if (i == len - 1)
424
		{
425
			int ln = len % 0x10 != 0;
426
			u32 k = 0x10 - 1;
427
			if (ln)
428
			{
429
				k = (len & 0xF) - 1;
430
				for (u32 j = 0; j < 0x10 - k; j++)
431
					gfx_puts("   ");
432
			}
433
			gfx_puts("| ");
434
			for (u32 j = 0; j < (ln ? k : k + 1); j++)
435
			{
436
				u8 c = buf[i - k + j];
437
				if (c >= 32 && c <= 126)
438
					gfx_putc(c);
439
				else
440
					gfx_putc('.');
441
			}
442
			gfx_putc('\n');
443
		}
444
	}
445
	gfx_putc('\n');
446
	gfx_con.fntsz = prevFontSize;
447
}
448

449
static int abs(int x)
450
{
451
	if (x < 0)
452
		return -x;
453
	return x;
454
}
455

456
void gfx_set_pixel(u32 x, u32 y, u32 color)
457
{
458
	gfx_ctxt.fb[x + y * gfx_ctxt.stride] = color;
459
}
460

461
void gfx_line(int x0, int y0, int x1, int y1, u32 color)
462
{
463
	int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
464
	int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
465
	int err = (dx > dy ? dx : -dy) / 2, e2;
466

467
	while (1)
468
	{
469
		gfx_set_pixel(x0, y0, color);
470
		if (x0 == x1 && y0 == y1)
471
			break;
472
		e2 = err;
473
		if (e2 >-dx)
474
		{
475
			err -= dy;
476
			x0 += sx;
477
		}
478
		if (e2 < dy)
479
		{
480
			err += dx;
481
			y0 += sy;
482
		}
483
	}
484
}
485

486
void gfx_set_rect_grey(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
487
{
488
	u32 pos = 0;
489
	for (u32 y = pos_y; y < (pos_y + size_y); y++)
490
	{
491
		for (u32 x = pos_x; x < (pos_x + size_x); x++)
492
		{
493
			memset(&gfx_ctxt.fb[x + y*gfx_ctxt.stride], buf[pos], 4);
494
			pos++;
495
		}
496
	}
497
}
498

499

500
void gfx_set_rect_rgb(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
501
{
502
	u32 pos = 0;
503
	for (u32 y = pos_y; y < (pos_y + size_y); y++)
504
	{
505
		for (u32 x = pos_x; x < (pos_x + size_x); x++)
506
		{
507
			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = buf[pos + 2] | (buf[pos + 1] << 8) | (buf[pos] << 16);
508
			pos+=3;
509
		}
510
	}
511
}
512

513
void gfx_set_rect_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
514
{
515
	u32 *ptr = (u32 *)buf;
516
	for (u32 y = pos_y; y < (pos_y + size_y); y++)
517
		for (u32 x = pos_x; x < (pos_x + size_x); x++)
518
			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = *ptr++;
519
}
520

521
void gfx_render_bmp_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
522
{
523
	for (u32 y = pos_y; y < (pos_y + size_y); y++)
524
	{
525
		for (u32 x = pos_x; x < (pos_x + size_x); x++)
526
			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = buf[(size_y + pos_y - 1 - y ) * size_x + x - pos_x];
527
	}
528
}
529

530