src/gba/renderers/video-software.c (view raw)
1/* Copyright (c) 2013-2015 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "software-private.h"
7
8#include "gba/gba.h"
9#include "gba/io.h"
10#include "gba/renderers/tile-cache.h"
11
12#include "util/arm-algo.h"
13#include "util/memory.h"
14
15static void GBAVideoSoftwareRendererInit(struct GBAVideoRenderer* renderer);
16static void GBAVideoSoftwareRendererDeinit(struct GBAVideoRenderer* renderer);
17static void GBAVideoSoftwareRendererReset(struct GBAVideoRenderer* renderer);
18static void GBAVideoSoftwareRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address);
19static void GBAVideoSoftwareRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam);
20static void GBAVideoSoftwareRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
21static uint16_t GBAVideoSoftwareRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value);
22static void GBAVideoSoftwareRendererDrawScanline(struct GBAVideoRenderer* renderer, int y);
23static void GBAVideoSoftwareRendererFinishFrame(struct GBAVideoRenderer* renderer);
24static void GBAVideoSoftwareRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels);
25static void GBAVideoSoftwareRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels);
26
27static void GBAVideoSoftwareRendererUpdateDISPCNT(struct GBAVideoSoftwareRenderer* renderer);
28static void GBAVideoSoftwareRendererWriteBGCNT(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* bg, uint16_t value);
29static void GBAVideoSoftwareRendererWriteBGPA(struct GBAVideoSoftwareBackground* bg, uint16_t value);
30static void GBAVideoSoftwareRendererWriteBGPB(struct GBAVideoSoftwareBackground* bg, uint16_t value);
31static void GBAVideoSoftwareRendererWriteBGPC(struct GBAVideoSoftwareBackground* bg, uint16_t value);
32static void GBAVideoSoftwareRendererWriteBGPD(struct GBAVideoSoftwareBackground* bg, uint16_t value);
33static void GBAVideoSoftwareRendererWriteBGX_LO(struct GBAVideoSoftwareBackground* bg, uint16_t value);
34static void GBAVideoSoftwareRendererWriteBGX_HI(struct GBAVideoSoftwareBackground* bg, uint16_t value);
35static void GBAVideoSoftwareRendererWriteBGY_LO(struct GBAVideoSoftwareBackground* bg, uint16_t value);
36static void GBAVideoSoftwareRendererWriteBGY_HI(struct GBAVideoSoftwareBackground* bg, uint16_t value);
37static void GBAVideoSoftwareRendererWriteBLDCNT(struct GBAVideoSoftwareRenderer* renderer, uint16_t value);
38
39static void _cleanOAM(struct GBAVideoSoftwareRenderer* renderer);
40static void _drawScanline(struct GBAVideoSoftwareRenderer* renderer, int y);
41
42static void _updatePalettes(struct GBAVideoSoftwareRenderer* renderer);
43
44static void _breakWindow(struct GBAVideoSoftwareRenderer* softwareRenderer, struct WindowN* win, int y);
45static void _breakWindowInner(struct GBAVideoSoftwareRenderer* softwareRenderer, struct WindowN* win);
46
47void GBAVideoSoftwareRendererCreate(struct GBAVideoSoftwareRenderer* renderer) {
48 renderer->d.init = GBAVideoSoftwareRendererInit;
49 renderer->d.reset = GBAVideoSoftwareRendererReset;
50 renderer->d.deinit = GBAVideoSoftwareRendererDeinit;
51 renderer->d.writeVideoRegister = GBAVideoSoftwareRendererWriteVideoRegister;
52 renderer->d.writeVRAM = GBAVideoSoftwareRendererWriteVRAM;
53 renderer->d.writeOAM = GBAVideoSoftwareRendererWriteOAM;
54 renderer->d.writePalette = GBAVideoSoftwareRendererWritePalette;
55 renderer->d.drawScanline = GBAVideoSoftwareRendererDrawScanline;
56 renderer->d.finishFrame = GBAVideoSoftwareRendererFinishFrame;
57 renderer->d.getPixels = GBAVideoSoftwareRendererGetPixels;
58 renderer->d.putPixels = GBAVideoSoftwareRendererPutPixels;
59
60 renderer->d.disableBG[0] = false;
61 renderer->d.disableBG[1] = false;
62 renderer->d.disableBG[2] = false;
63 renderer->d.disableBG[3] = false;
64 renderer->d.disableOBJ = false;
65
66 renderer->temporaryBuffer = 0;
67}
68
69static void GBAVideoSoftwareRendererInit(struct GBAVideoRenderer* renderer) {
70 GBAVideoSoftwareRendererReset(renderer);
71
72 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
73
74 int y;
75 for (y = 0; y < VIDEO_VERTICAL_PIXELS; ++y) {
76 color_t* row = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * y];
77 int x;
78 for (x = 0; x < VIDEO_HORIZONTAL_PIXELS; ++x) {
79 row[x] = GBA_COLOR_WHITE;
80 }
81 }
82}
83
84static void GBAVideoSoftwareRendererReset(struct GBAVideoRenderer* renderer) {
85 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
86 int i;
87
88 softwareRenderer->dispcnt = 0x0080;
89
90 softwareRenderer->target1Obj = 0;
91 softwareRenderer->target1Bd = 0;
92 softwareRenderer->target2Obj = 0;
93 softwareRenderer->target2Bd = 0;
94 softwareRenderer->blendEffect = BLEND_NONE;
95 for (i = 0; i < 1024; i += 2) {
96 uint16_t entry;
97 LOAD_16(entry, i, softwareRenderer->d.palette);
98 GBAVideoSoftwareRendererWritePalette(renderer, i, entry);
99 }
100 _updatePalettes(softwareRenderer);
101
102 softwareRenderer->blda = 0;
103 softwareRenderer->bldb = 0;
104 softwareRenderer->bldy = 0;
105
106 softwareRenderer->winN[0] = (struct WindowN) { .control = { .priority = 0 } };
107 softwareRenderer->winN[1] = (struct WindowN) { .control = { .priority = 1 } };
108 softwareRenderer->objwin = (struct WindowControl) { .priority = 2 };
109 softwareRenderer->winout = (struct WindowControl) { .priority = 3 };
110 softwareRenderer->oamMax = 0;
111
112 softwareRenderer->mosaic = 0;
113
114 for (i = 0; i < 4; ++i) {
115 struct GBAVideoSoftwareBackground* bg = &softwareRenderer->bg[i];
116 bg->index = i;
117 bg->enabled = 0;
118 bg->priority = 0;
119 bg->charBase = 0;
120 bg->mosaic = 0;
121 bg->multipalette = 0;
122 bg->screenBase = 0;
123 bg->overflow = 0;
124 bg->size = 0;
125 bg->target1 = 0;
126 bg->target2 = 0;
127 bg->x = 0;
128 bg->y = 0;
129 bg->refx = 0;
130 bg->refy = 0;
131 bg->dx = 256;
132 bg->dmx = 0;
133 bg->dy = 0;
134 bg->dmy = 256;
135 bg->sx = 0;
136 bg->sy = 0;
137 }
138}
139
140static void GBAVideoSoftwareRendererDeinit(struct GBAVideoRenderer* renderer) {
141 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
142 UNUSED(softwareRenderer);
143}
144
145static uint16_t GBAVideoSoftwareRendererWriteVideoRegister(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
146 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
147 switch (address) {
148 case REG_DISPCNT:
149 softwareRenderer->dispcnt = value;
150 GBAVideoSoftwareRendererUpdateDISPCNT(softwareRenderer);
151 break;
152 case REG_BG0CNT:
153 value &= 0xDFFF;
154 GBAVideoSoftwareRendererWriteBGCNT(softwareRenderer, &softwareRenderer->bg[0], value);
155 break;
156 case REG_BG1CNT:
157 value &= 0xDFFF;
158 GBAVideoSoftwareRendererWriteBGCNT(softwareRenderer, &softwareRenderer->bg[1], value);
159 break;
160 case REG_BG2CNT:
161 value &= 0xFFFF;
162 GBAVideoSoftwareRendererWriteBGCNT(softwareRenderer, &softwareRenderer->bg[2], value);
163 break;
164 case REG_BG3CNT:
165 value &= 0xFFFF;
166 GBAVideoSoftwareRendererWriteBGCNT(softwareRenderer, &softwareRenderer->bg[3], value);
167 break;
168 case REG_BG0HOFS:
169 value &= 0x01FF;
170 softwareRenderer->bg[0].x = value;
171 break;
172 case REG_BG0VOFS:
173 value &= 0x01FF;
174 softwareRenderer->bg[0].y = value;
175 break;
176 case REG_BG1HOFS:
177 value &= 0x01FF;
178 softwareRenderer->bg[1].x = value;
179 break;
180 case REG_BG1VOFS:
181 value &= 0x01FF;
182 softwareRenderer->bg[1].y = value;
183 break;
184 case REG_BG2HOFS:
185 value &= 0x01FF;
186 softwareRenderer->bg[2].x = value;
187 break;
188 case REG_BG2VOFS:
189 value &= 0x01FF;
190 softwareRenderer->bg[2].y = value;
191 break;
192 case REG_BG3HOFS:
193 value &= 0x01FF;
194 softwareRenderer->bg[3].x = value;
195 break;
196 case REG_BG3VOFS:
197 value &= 0x01FF;
198 softwareRenderer->bg[3].y = value;
199 break;
200 case REG_BG2PA:
201 GBAVideoSoftwareRendererWriteBGPA(&softwareRenderer->bg[2], value);
202 break;
203 case REG_BG2PB:
204 GBAVideoSoftwareRendererWriteBGPB(&softwareRenderer->bg[2], value);
205 break;
206 case REG_BG2PC:
207 GBAVideoSoftwareRendererWriteBGPC(&softwareRenderer->bg[2], value);
208 break;
209 case REG_BG2PD:
210 GBAVideoSoftwareRendererWriteBGPD(&softwareRenderer->bg[2], value);
211 break;
212 case REG_BG2X_LO:
213 GBAVideoSoftwareRendererWriteBGX_LO(&softwareRenderer->bg[2], value);
214 break;
215 case REG_BG2X_HI:
216 GBAVideoSoftwareRendererWriteBGX_HI(&softwareRenderer->bg[2], value);
217 break;
218 case REG_BG2Y_LO:
219 GBAVideoSoftwareRendererWriteBGY_LO(&softwareRenderer->bg[2], value);
220 break;
221 case REG_BG2Y_HI:
222 GBAVideoSoftwareRendererWriteBGY_HI(&softwareRenderer->bg[2], value);
223 break;
224 case REG_BG3PA:
225 GBAVideoSoftwareRendererWriteBGPA(&softwareRenderer->bg[3], value);
226 break;
227 case REG_BG3PB:
228 GBAVideoSoftwareRendererWriteBGPB(&softwareRenderer->bg[3], value);
229 break;
230 case REG_BG3PC:
231 GBAVideoSoftwareRendererWriteBGPC(&softwareRenderer->bg[3], value);
232 break;
233 case REG_BG3PD:
234 GBAVideoSoftwareRendererWriteBGPD(&softwareRenderer->bg[3], value);
235 break;
236 case REG_BG3X_LO:
237 GBAVideoSoftwareRendererWriteBGX_LO(&softwareRenderer->bg[3], value);
238 break;
239 case REG_BG3X_HI:
240 GBAVideoSoftwareRendererWriteBGX_HI(&softwareRenderer->bg[3], value);
241 break;
242 case REG_BG3Y_LO:
243 GBAVideoSoftwareRendererWriteBGY_LO(&softwareRenderer->bg[3], value);
244 break;
245 case REG_BG3Y_HI:
246 GBAVideoSoftwareRendererWriteBGY_HI(&softwareRenderer->bg[3], value);
247 break;
248 case REG_BLDCNT:
249 GBAVideoSoftwareRendererWriteBLDCNT(softwareRenderer, value);
250 value &= 0x3FFF;
251 break;
252 case REG_BLDALPHA:
253 softwareRenderer->blda = value & 0x1F;
254 if (softwareRenderer->blda > 0x10) {
255 softwareRenderer->blda = 0x10;
256 }
257 softwareRenderer->bldb = (value >> 8) & 0x1F;
258 if (softwareRenderer->bldb > 0x10) {
259 softwareRenderer->bldb = 0x10;
260 }
261 value &= 0x1F1F;
262 break;
263 case REG_BLDY:
264 softwareRenderer->bldy = value & 0x1F;
265 if (softwareRenderer->bldy > 0x10) {
266 softwareRenderer->bldy = 0x10;
267 }
268 _updatePalettes(softwareRenderer);
269 break;
270 case REG_WIN0H:
271 softwareRenderer->winN[0].h.end = value;
272 softwareRenderer->winN[0].h.start = value >> 8;
273 if (softwareRenderer->winN[0].h.start > VIDEO_HORIZONTAL_PIXELS && softwareRenderer->winN[0].h.start > softwareRenderer->winN[0].h.end) {
274 softwareRenderer->winN[0].h.start = 0;
275 }
276 if (softwareRenderer->winN[0].h.end > VIDEO_HORIZONTAL_PIXELS) {
277 softwareRenderer->winN[0].h.end = VIDEO_HORIZONTAL_PIXELS;
278 if (softwareRenderer->winN[0].h.start > VIDEO_HORIZONTAL_PIXELS) {
279 softwareRenderer->winN[0].h.start = VIDEO_HORIZONTAL_PIXELS;
280 }
281 }
282 break;
283 case REG_WIN1H:
284 softwareRenderer->winN[1].h.end = value;
285 softwareRenderer->winN[1].h.start = value >> 8;
286 if (softwareRenderer->winN[1].h.start > VIDEO_HORIZONTAL_PIXELS && softwareRenderer->winN[1].h.start > softwareRenderer->winN[1].h.end) {
287 softwareRenderer->winN[1].h.start = 0;
288 }
289 if (softwareRenderer->winN[1].h.end > VIDEO_HORIZONTAL_PIXELS) {
290 softwareRenderer->winN[1].h.end = VIDEO_HORIZONTAL_PIXELS;
291 if (softwareRenderer->winN[1].h.start > VIDEO_HORIZONTAL_PIXELS) {
292 softwareRenderer->winN[1].h.start = VIDEO_HORIZONTAL_PIXELS;
293 }
294 }
295 break;
296 case REG_WIN0V:
297 softwareRenderer->winN[0].v.end = value;
298 softwareRenderer->winN[0].v.start = value >> 8;
299 if (softwareRenderer->winN[0].v.start > VIDEO_VERTICAL_PIXELS && softwareRenderer->winN[0].v.start > softwareRenderer->winN[0].v.end) {
300 softwareRenderer->winN[0].v.start = 0;
301 }
302 if (softwareRenderer->winN[0].v.end > VIDEO_VERTICAL_PIXELS) {
303 softwareRenderer->winN[0].v.end = VIDEO_VERTICAL_PIXELS;
304 if (softwareRenderer->winN[0].v.start > VIDEO_VERTICAL_PIXELS) {
305 softwareRenderer->winN[0].v.start = VIDEO_VERTICAL_PIXELS;
306 }
307 }
308 break;
309 case REG_WIN1V:
310 softwareRenderer->winN[1].v.end = value;
311 softwareRenderer->winN[1].v.start = value >> 8;
312 if (softwareRenderer->winN[1].v.start > VIDEO_VERTICAL_PIXELS && softwareRenderer->winN[1].v.start > softwareRenderer->winN[1].v.end) {
313 softwareRenderer->winN[1].v.start = 0;
314 }
315 if (softwareRenderer->winN[1].v.end > VIDEO_VERTICAL_PIXELS) {
316 softwareRenderer->winN[1].v.end = VIDEO_VERTICAL_PIXELS;
317 if (softwareRenderer->winN[1].v.start > VIDEO_VERTICAL_PIXELS) {
318 softwareRenderer->winN[1].v.start = VIDEO_VERTICAL_PIXELS;
319 }
320 }
321 break;
322 case REG_WININ:
323 value &= 0x3F3F;
324 softwareRenderer->winN[0].control.packed = value;
325 softwareRenderer->winN[1].control.packed = value >> 8;
326 break;
327 case REG_WINOUT:
328 value &= 0x3F3F;
329 softwareRenderer->winout.packed = value;
330 softwareRenderer->objwin.packed = value >> 8;
331 break;
332 case REG_MOSAIC:
333 softwareRenderer->mosaic = value;
334 break;
335 case REG_GREENSWP:
336 mLOG(GBA_VIDEO, STUB, "Stub video register write: 0x%03X", address);
337 break;
338 default:
339 mLOG(GBA_VIDEO, GAME_ERROR, "Invalid video register: 0x%03X", address);
340 }
341 return value;
342}
343
344static void GBAVideoSoftwareRendererWriteVRAM(struct GBAVideoRenderer* renderer, uint32_t address) {
345 if (renderer->cache) {
346 GBAVideoTileCacheWriteVRAM(renderer->cache, address);
347 }
348}
349
350static void GBAVideoSoftwareRendererWriteOAM(struct GBAVideoRenderer* renderer, uint32_t oam) {
351 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
352 softwareRenderer->oamDirty = 1;
353 UNUSED(oam);
354}
355
356static void GBAVideoSoftwareRendererWritePalette(struct GBAVideoRenderer* renderer, uint32_t address, uint16_t value) {
357 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
358#ifdef COLOR_16_BIT
359#ifdef COLOR_5_6_5
360 unsigned color = 0;
361 color |= (value & 0x001F) << 11;
362 color |= (value & 0x03E0) << 1;
363 color |= (value & 0x7C00) >> 10;
364#else
365 unsigned color = value;
366#endif
367#else
368 unsigned color = 0;
369 color |= (value << 3) & 0xF8;
370 color |= (value << 6) & 0xF800;
371 color |= (value << 9) & 0xF80000;
372#endif
373 softwareRenderer->normalPalette[address >> 1] = color;
374 if (softwareRenderer->blendEffect == BLEND_BRIGHTEN) {
375 softwareRenderer->variantPalette[address >> 1] = _brighten(color, softwareRenderer->bldy);
376 } else if (softwareRenderer->blendEffect == BLEND_DARKEN) {
377 softwareRenderer->variantPalette[address >> 1] = _darken(color, softwareRenderer->bldy);
378 }
379 if (renderer->cache) {
380 GBAVideoTileCacheWritePalette(renderer->cache, address);
381 }
382}
383
384static void _breakWindow(struct GBAVideoSoftwareRenderer* softwareRenderer, struct WindowN* win, int y) {
385 if (win->v.end >= win->v.start) {
386 if (y >= win->v.end) {
387 return;
388 }
389 if (y < win->v.start) {
390 return;
391 }
392 } else if (y >= win->v.end && y < win->v.start) {
393 return;
394 }
395 if (win->h.end > VIDEO_HORIZONTAL_PIXELS || win->h.end < win->h.start) {
396 struct WindowN splits[2] = { *win, *win };
397 splits[0].h.start = 0;
398 splits[1].h.end = VIDEO_HORIZONTAL_PIXELS;
399 _breakWindowInner(softwareRenderer, &splits[0]);
400 _breakWindowInner(softwareRenderer, &splits[1]);
401 } else {
402 _breakWindowInner(softwareRenderer, win);
403 }
404}
405
406static void _breakWindowInner(struct GBAVideoSoftwareRenderer* softwareRenderer, struct WindowN* win) {
407 int activeWindow;
408 int startX = 0;
409 if (win->h.end > 0) {
410 for (activeWindow = 0; activeWindow < softwareRenderer->nWindows; ++activeWindow) {
411 if (win->h.start < softwareRenderer->windows[activeWindow].endX) {
412 // Insert a window before the end of the active window
413 struct Window oldWindow = softwareRenderer->windows[activeWindow];
414 if (win->h.start > startX) {
415 // And after the start of the active window
416 int nextWindow = softwareRenderer->nWindows;
417 ++softwareRenderer->nWindows;
418 for (; nextWindow > activeWindow; --nextWindow) {
419 softwareRenderer->windows[nextWindow] = softwareRenderer->windows[nextWindow - 1];
420 }
421 softwareRenderer->windows[activeWindow].endX = win->h.start;
422 ++activeWindow;
423 }
424 softwareRenderer->windows[activeWindow].control = win->control;
425 softwareRenderer->windows[activeWindow].endX = win->h.end;
426 if (win->h.end >= oldWindow.endX) {
427 // Trim off extra windows we've overwritten
428 for (++activeWindow; softwareRenderer->nWindows > activeWindow + 1 && win->h.end >= softwareRenderer->windows[activeWindow].endX; ++activeWindow) {
429 if (VIDEO_CHECKS && activeWindow >= MAX_WINDOW) {
430 mLOG(GBA_VIDEO, FATAL, "Out of bounds window write will occur");
431 return;
432 }
433 softwareRenderer->windows[activeWindow] = softwareRenderer->windows[activeWindow + 1];
434 --softwareRenderer->nWindows;
435 }
436 } else {
437 ++activeWindow;
438 int nextWindow = softwareRenderer->nWindows;
439 ++softwareRenderer->nWindows;
440 for (; nextWindow > activeWindow; --nextWindow) {
441 softwareRenderer->windows[nextWindow] = softwareRenderer->windows[nextWindow - 1];
442 }
443 softwareRenderer->windows[activeWindow] = oldWindow;
444 }
445 break;
446 }
447 startX = softwareRenderer->windows[activeWindow].endX;
448 }
449 }
450#ifdef DEBUG
451 if (softwareRenderer->nWindows > MAX_WINDOW) {
452 mLOG(GBA_VIDEO, FATAL, "Out of bounds window write occurred!");
453 }
454#endif
455}
456
457static void _cleanOAM(struct GBAVideoSoftwareRenderer* renderer) {
458 int i;
459 int oamMax = 0;
460 int objwinMax = 0;
461 for (i = 0; i < 128; ++i) {
462 struct GBAObj obj;
463 LOAD_16(obj.a, 0, &renderer->d.oam->obj[i].a);
464 LOAD_16(obj.b, 0, &renderer->d.oam->obj[i].b);
465 LOAD_16(obj.c, 0, &renderer->d.oam->obj[i].c);
466 if (GBAObjAttributesAIsTransformed(obj.a) || !GBAObjAttributesAIsDisable(obj.a)) {
467 int height = GBAVideoObjSizes[GBAObjAttributesAGetShape(obj.a) * 4 + GBAObjAttributesBGetSize(obj.b)][1];
468 if (GBAObjAttributesAIsTransformed(obj.a)) {
469 height <<= GBAObjAttributesAGetDoubleSize(obj.a);
470 }
471 if (GBAObjAttributesAGetY(obj.a) < VIDEO_VERTICAL_PIXELS || GBAObjAttributesAGetY(obj.a) + height >= VIDEO_VERTICAL_TOTAL_PIXELS) {
472 if (GBAObjAttributesAGetMode(obj.a) == OBJ_MODE_OBJWIN) {
473 renderer->objwinSprites[objwinMax].y = GBAObjAttributesAGetY(obj.a);
474 renderer->objwinSprites[objwinMax].endY = GBAObjAttributesAGetY(obj.a) + height;
475 renderer->objwinSprites[objwinMax].obj = obj;
476 ++objwinMax;
477 } else {
478 renderer->sprites[oamMax].y = GBAObjAttributesAGetY(obj.a);
479 renderer->sprites[oamMax].endY = GBAObjAttributesAGetY(obj.a) + height;
480 renderer->sprites[oamMax].obj = obj;
481 ++oamMax;
482 }
483 }
484 }
485 }
486 renderer->oamMax = oamMax;
487 renderer->objwinMax = objwinMax;
488 renderer->oamDirty = 0;
489}
490
491static void GBAVideoSoftwareRendererDrawScanline(struct GBAVideoRenderer* renderer, int y) {
492 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
493
494 color_t* row = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * y];
495 if (GBARegisterDISPCNTIsForcedBlank(softwareRenderer->dispcnt)) {
496 int x;
497 for (x = 0; x < VIDEO_HORIZONTAL_PIXELS; ++x) {
498 row[x] = GBA_COLOR_WHITE;
499 }
500 return;
501 }
502
503 int x;
504 for (x = 0; x < VIDEO_HORIZONTAL_PIXELS; x += 4) {
505 softwareRenderer->spriteLayer[x] = FLAG_UNWRITTEN;
506 softwareRenderer->spriteLayer[x + 1] = FLAG_UNWRITTEN;
507 softwareRenderer->spriteLayer[x + 2] = FLAG_UNWRITTEN;
508 softwareRenderer->spriteLayer[x + 3] = FLAG_UNWRITTEN;
509 }
510
511 softwareRenderer->windows[0].endX = VIDEO_HORIZONTAL_PIXELS;
512 softwareRenderer->nWindows = 1;
513 if (GBARegisterDISPCNTIsWin0Enable(softwareRenderer->dispcnt) || GBARegisterDISPCNTIsWin1Enable(softwareRenderer->dispcnt) || GBARegisterDISPCNTIsObjwinEnable(softwareRenderer->dispcnt)) {
514 softwareRenderer->windows[0].control = softwareRenderer->winout;
515 if (GBARegisterDISPCNTIsWin1Enable(softwareRenderer->dispcnt)) {
516 _breakWindow(softwareRenderer, &softwareRenderer->winN[1], y);
517 }
518 if (GBARegisterDISPCNTIsWin0Enable(softwareRenderer->dispcnt)) {
519 _breakWindow(softwareRenderer, &softwareRenderer->winN[0], y);
520 }
521 } else {
522 softwareRenderer->windows[0].control.packed = 0xFF;
523 }
524
525 GBAVideoSoftwareRendererUpdateDISPCNT(softwareRenderer);
526
527 int w;
528 x = 0;
529 for (w = 0; w < softwareRenderer->nWindows; ++w) {
530 // TOOD: handle objwin on backdrop
531 uint32_t backdrop = FLAG_UNWRITTEN | FLAG_PRIORITY | FLAG_IS_BACKGROUND;
532 if (!softwareRenderer->target1Bd || softwareRenderer->blendEffect == BLEND_NONE || softwareRenderer->blendEffect == BLEND_ALPHA || !GBAWindowControlIsBlendEnable(softwareRenderer->windows[w].control.packed)) {
533 backdrop |= softwareRenderer->normalPalette[0];
534 } else {
535 backdrop |= softwareRenderer->variantPalette[0];
536 }
537 int end = softwareRenderer->windows[w].endX;
538 for (; x < end - 3; x += 4) {
539 softwareRenderer->row[x] = backdrop;
540 softwareRenderer->row[x + 1] = backdrop;
541 softwareRenderer->row[x + 2] = backdrop;
542 softwareRenderer->row[x + 3] = backdrop;
543 }
544 for (; x < end; ++x) {
545 softwareRenderer->row[x] = backdrop;
546 }
547 }
548
549 _drawScanline(softwareRenderer, y);
550
551 if (softwareRenderer->target2Bd) {
552 x = 0;
553 for (w = 0; w < softwareRenderer->nWindows; ++w) {
554 uint32_t backdrop = 0;
555 if (!softwareRenderer->target1Bd || softwareRenderer->blendEffect == BLEND_NONE || softwareRenderer->blendEffect == BLEND_ALPHA || !GBAWindowControlIsBlendEnable(softwareRenderer->windows[w].control.packed)) {
556 backdrop |= softwareRenderer->normalPalette[0];
557 } else {
558 backdrop |= softwareRenderer->variantPalette[0];
559 }
560 int end = softwareRenderer->windows[w].endX;
561 for (; x < end; ++x) {
562 uint32_t color = softwareRenderer->row[x];
563 if (color & FLAG_TARGET_1) {
564 softwareRenderer->row[x] = _mix(softwareRenderer->bldb, backdrop, softwareRenderer->blda, color);
565 }
566 }
567 }
568 }
569 if (softwareRenderer->target1Obj && (softwareRenderer->blendEffect == BLEND_DARKEN || softwareRenderer->blendEffect == BLEND_BRIGHTEN)) {
570 x = 0;
571 for (w = 0; w < softwareRenderer->nWindows; ++w) {
572 if (!GBAWindowControlIsBlendEnable(softwareRenderer->windows[w].control.packed)) {
573 continue;
574 }
575 int end = softwareRenderer->windows[w].endX;
576 if (softwareRenderer->blendEffect == BLEND_DARKEN) {
577 for (; x < end; ++x) {
578 uint32_t color = softwareRenderer->row[x];
579 if ((color & 0xFF000000) == FLAG_REBLEND) {
580 softwareRenderer->row[x] = _darken(color, softwareRenderer->bldy);
581 }
582 }
583 } else if (softwareRenderer->blendEffect == BLEND_BRIGHTEN) {
584 for (; x < end; ++x) {
585 uint32_t color = softwareRenderer->row[x];
586 if ((color & 0xFF000000) == FLAG_REBLEND) {
587 softwareRenderer->row[x] = _brighten(color, softwareRenderer->bldy);
588 }
589 }
590 }
591 }
592 }
593
594#ifdef COLOR_16_BIT
595#if defined(__ARM_NEON) && !defined(__APPLE__)
596 _to16Bit(row, softwareRenderer->row, VIDEO_HORIZONTAL_PIXELS);
597#else
598 for (x = 0; x < VIDEO_HORIZONTAL_PIXELS; ++x) {
599 row[x] = softwareRenderer->row[x];
600 }
601#endif
602#else
603 memcpy(row, softwareRenderer->row, VIDEO_HORIZONTAL_PIXELS * sizeof(*row));
604#endif
605}
606
607static void GBAVideoSoftwareRendererFinishFrame(struct GBAVideoRenderer* renderer) {
608 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
609
610 if (softwareRenderer->temporaryBuffer) {
611 mappedMemoryFree(softwareRenderer->temporaryBuffer, VIDEO_HORIZONTAL_PIXELS * VIDEO_VERTICAL_PIXELS * 4);
612 softwareRenderer->temporaryBuffer = 0;
613 }
614 softwareRenderer->bg[2].sx = softwareRenderer->bg[2].refx;
615 softwareRenderer->bg[2].sy = softwareRenderer->bg[2].refy;
616 softwareRenderer->bg[3].sx = softwareRenderer->bg[3].refx;
617 softwareRenderer->bg[3].sy = softwareRenderer->bg[3].refy;
618}
619
620static void GBAVideoSoftwareRendererGetPixels(struct GBAVideoRenderer* renderer, size_t* stride, const void** pixels) {
621 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
622 *stride = softwareRenderer->outputBufferStride;
623 *pixels = softwareRenderer->outputBuffer;
624}
625
626static void GBAVideoSoftwareRendererPutPixels(struct GBAVideoRenderer* renderer, size_t stride, const void* pixels) {
627 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
628
629 const color_t* colorPixels = pixels;
630 unsigned i;
631 for (i = 0; i < VIDEO_VERTICAL_PIXELS; ++i) {
632 memmove(&softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * i], &colorPixels[stride * i], VIDEO_HORIZONTAL_PIXELS * BYTES_PER_PIXEL);
633 }
634}
635
636static void GBAVideoSoftwareRendererUpdateDISPCNT(struct GBAVideoSoftwareRenderer* renderer) {
637 renderer->bg[0].enabled = GBARegisterDISPCNTGetBg0Enable(renderer->dispcnt) && !renderer->d.disableBG[0];
638 renderer->bg[1].enabled = GBARegisterDISPCNTGetBg1Enable(renderer->dispcnt) && !renderer->d.disableBG[1];
639 renderer->bg[2].enabled = GBARegisterDISPCNTGetBg2Enable(renderer->dispcnt) && !renderer->d.disableBG[2];
640 renderer->bg[3].enabled = GBARegisterDISPCNTGetBg3Enable(renderer->dispcnt) && !renderer->d.disableBG[3];
641}
642
643static void GBAVideoSoftwareRendererWriteBGCNT(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* bg, uint16_t value) {
644 UNUSED(renderer);
645 bg->priority = GBARegisterBGCNTGetPriority(value);
646 bg->charBase = GBARegisterBGCNTGetCharBase(value) << 14;
647 bg->mosaic = GBARegisterBGCNTGetMosaic(value);
648 bg->multipalette = GBARegisterBGCNTGet256Color(value);
649 bg->screenBase = GBARegisterBGCNTGetScreenBase(value) << 11;
650 bg->overflow = GBARegisterBGCNTGetOverflow(value);
651 bg->size = GBARegisterBGCNTGetSize(value);
652}
653
654static void GBAVideoSoftwareRendererWriteBGPA(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
655 bg->dx = value;
656}
657
658static void GBAVideoSoftwareRendererWriteBGPB(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
659 bg->dmx = value;
660}
661
662static void GBAVideoSoftwareRendererWriteBGPC(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
663 bg->dy = value;
664}
665
666static void GBAVideoSoftwareRendererWriteBGPD(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
667 bg->dmy = value;
668}
669
670static void GBAVideoSoftwareRendererWriteBGX_LO(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
671 bg->refx = (bg->refx & 0xFFFF0000) | value;
672 bg->sx = bg->refx;
673}
674
675static void GBAVideoSoftwareRendererWriteBGX_HI(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
676 bg->refx = (bg->refx & 0x0000FFFF) | (value << 16);
677 bg->refx <<= 4;
678 bg->refx >>= 4;
679 bg->sx = bg->refx;
680}
681
682static void GBAVideoSoftwareRendererWriteBGY_LO(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
683 bg->refy = (bg->refy & 0xFFFF0000) | value;
684 bg->sy = bg->refy;
685}
686
687static void GBAVideoSoftwareRendererWriteBGY_HI(struct GBAVideoSoftwareBackground* bg, uint16_t value) {
688 bg->refy = (bg->refy & 0x0000FFFF) | (value << 16);
689 bg->refy <<= 4;
690 bg->refy >>= 4;
691 bg->sy = bg->refy;
692}
693
694static void GBAVideoSoftwareRendererWriteBLDCNT(struct GBAVideoSoftwareRenderer* renderer, uint16_t value) {
695 enum BlendEffect oldEffect = renderer->blendEffect;
696
697 renderer->bg[0].target1 = GBARegisterBLDCNTGetTarget1Bg0(value);
698 renderer->bg[1].target1 = GBARegisterBLDCNTGetTarget1Bg1(value);
699 renderer->bg[2].target1 = GBARegisterBLDCNTGetTarget1Bg2(value);
700 renderer->bg[3].target1 = GBARegisterBLDCNTGetTarget1Bg3(value);
701 renderer->bg[0].target2 = GBARegisterBLDCNTGetTarget2Bg0(value);
702 renderer->bg[1].target2 = GBARegisterBLDCNTGetTarget2Bg1(value);
703 renderer->bg[2].target2 = GBARegisterBLDCNTGetTarget2Bg2(value);
704 renderer->bg[3].target2 = GBARegisterBLDCNTGetTarget2Bg3(value);
705
706 renderer->blendEffect = GBARegisterBLDCNTGetEffect(value);
707 renderer->target1Obj = GBARegisterBLDCNTGetTarget1Obj(value);
708 renderer->target1Bd = GBARegisterBLDCNTGetTarget1Bd(value);
709 renderer->target2Obj = GBARegisterBLDCNTGetTarget2Obj(value);
710 renderer->target2Bd = GBARegisterBLDCNTGetTarget2Bd(value);
711
712 if (oldEffect != renderer->blendEffect) {
713 _updatePalettes(renderer);
714 }
715}
716
717#define TEST_LAYER_ENABLED(X) \
718 (renderer->bg[X].enabled && \
719 (GBAWindowControlIsBg ## X ## Enable(renderer->currentWindow.packed) || \
720 (GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt) && GBAWindowControlIsBg ## X ## Enable (renderer->objwin.packed))) && \
721 renderer->bg[X].priority == priority)
722
723static void _drawScanline(struct GBAVideoSoftwareRenderer* renderer, int y) {
724 int w;
725 renderer->end = 0;
726 int spriteLayers = 0;
727 if (GBARegisterDISPCNTIsObjEnable(renderer->dispcnt) && !renderer->d.disableOBJ) {
728 if (renderer->oamDirty) {
729 _cleanOAM(renderer);
730 }
731 renderer->spriteCyclesRemaining = GBARegisterDISPCNTIsHblankIntervalFree(renderer->dispcnt) ? OBJ_HBLANK_FREE_LENGTH : OBJ_LENGTH;
732 int mosaicV = GBAMosaicControlGetObjV(renderer->mosaic) + 1;
733 int mosaicY = y - (y % mosaicV);
734 for (w = 0; w < renderer->nWindows; ++w) {
735 renderer->start = renderer->end;
736 renderer->end = renderer->windows[w].endX;
737 renderer->currentWindow = renderer->windows[w].control;
738 if (!GBAWindowControlIsObjEnable(renderer->currentWindow.packed) && !GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt)) {
739 continue;
740 }
741 int i;
742 int drawn;
743 for (i = 0; i < renderer->objwinMax; ++i) {
744 int localY = y;
745 if (renderer->spriteCyclesRemaining <= 0) {
746 break;
747 }
748 struct GBAVideoSoftwareSprite* sprite = &renderer->objwinSprites[i];
749 if (GBAObjAttributesAIsMosaic(sprite->obj.a)) {
750 localY = mosaicY;
751 }
752 if ((localY < sprite->y && (sprite->endY - 256 < 0 || localY >= sprite->endY - 256)) || localY >= sprite->endY) {
753 continue;
754 }
755 GBAVideoSoftwareRendererPreprocessSprite(renderer, &sprite->obj, localY);
756 }
757 for (i = 0; i < renderer->oamMax; ++i) {
758 int localY = y;
759 if (renderer->spriteCyclesRemaining <= 0) {
760 break;
761 }
762 struct GBAVideoSoftwareSprite* sprite = &renderer->sprites[i];
763 if (GBAObjAttributesAIsMosaic(sprite->obj.a)) {
764 localY = mosaicY;
765 }
766 if ((localY < sprite->y && (sprite->endY - 256 < 0 || localY >= sprite->endY - 256)) || localY >= sprite->endY) {
767 continue;
768 }
769 drawn = GBAVideoSoftwareRendererPreprocessSprite(renderer, &sprite->obj, localY);
770 spriteLayers |= drawn << GBAObjAttributesCGetPriority(sprite->obj.c);
771 }
772 }
773 }
774
775 unsigned priority;
776 for (priority = 0; priority < 4; ++priority) {
777 renderer->end = 0;
778 for (w = 0; w < renderer->nWindows; ++w) {
779 renderer->start = renderer->end;
780 renderer->end = renderer->windows[w].endX;
781 renderer->currentWindow = renderer->windows[w].control;
782 if (spriteLayers & (1 << priority)) {
783 GBAVideoSoftwareRendererPostprocessSprite(renderer, priority);
784 }
785 if (TEST_LAYER_ENABLED(0) && GBARegisterDISPCNTGetMode(renderer->dispcnt) < 2) {
786 GBAVideoSoftwareRendererDrawBackgroundMode0(renderer, &renderer->bg[0], y);
787 }
788 if (TEST_LAYER_ENABLED(1) && GBARegisterDISPCNTGetMode(renderer->dispcnt) < 2) {
789 GBAVideoSoftwareRendererDrawBackgroundMode0(renderer, &renderer->bg[1], y);
790 }
791 if (TEST_LAYER_ENABLED(2)) {
792 switch (GBARegisterDISPCNTGetMode(renderer->dispcnt)) {
793 case 0:
794 GBAVideoSoftwareRendererDrawBackgroundMode0(renderer, &renderer->bg[2], y);
795 break;
796 case 1:
797 case 2:
798 GBAVideoSoftwareRendererDrawBackgroundMode2(renderer, &renderer->bg[2], y);
799 break;
800 case 3:
801 GBAVideoSoftwareRendererDrawBackgroundMode3(renderer, &renderer->bg[2], y);
802 break;
803 case 4:
804 GBAVideoSoftwareRendererDrawBackgroundMode4(renderer, &renderer->bg[2], y);
805 break;
806 case 5:
807 GBAVideoSoftwareRendererDrawBackgroundMode5(renderer, &renderer->bg[2], y);
808 break;
809 }
810 }
811 if (TEST_LAYER_ENABLED(3)) {
812 switch (GBARegisterDISPCNTGetMode(renderer->dispcnt)) {
813 case 0:
814 GBAVideoSoftwareRendererDrawBackgroundMode0(renderer, &renderer->bg[3], y);
815 break;
816 case 2:
817 GBAVideoSoftwareRendererDrawBackgroundMode2(renderer, &renderer->bg[3], y);
818 break;
819 }
820 }
821 }
822 }
823 renderer->bg[2].sx += renderer->bg[2].dmx;
824 renderer->bg[2].sy += renderer->bg[2].dmy;
825 renderer->bg[3].sx += renderer->bg[3].dmx;
826 renderer->bg[3].sy += renderer->bg[3].dmy;
827}
828
829static void _updatePalettes(struct GBAVideoSoftwareRenderer* renderer) {
830 int i;
831 if (renderer->blendEffect == BLEND_BRIGHTEN) {
832 for (i = 0; i < 512; ++i) {
833 renderer->variantPalette[i] = _brighten(renderer->normalPalette[i], renderer->bldy);
834 }
835 } else if (renderer->blendEffect == BLEND_DARKEN) {
836 for (i = 0; i < 512; ++i) {
837 renderer->variantPalette[i] = _darken(renderer->normalPalette[i], renderer->bldy);
838 }
839 } else {
840 for (i = 0; i < 512; ++i) {
841 renderer->variantPalette[i] = renderer->normalPalette[i];
842 }
843 }
844}