src/ds/renderers/software.c (view raw)
1/* Copyright (c) 2013-2017 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 <mgba/internal/ds/renderers/software.h>
7#include "gba/renderers/software-private.h"
8
9#include <mgba/internal/arm/macros.h>
10#include <mgba/internal/ds/gx.h>
11#include <mgba/internal/ds/io.h>
12
13static void DSVideoSoftwareRendererInit(struct DSVideoRenderer* renderer);
14static void DSVideoSoftwareRendererDeinit(struct DSVideoRenderer* renderer);
15static void DSVideoSoftwareRendererReset(struct DSVideoRenderer* renderer);
16static uint16_t DSVideoSoftwareRendererWriteVideoRegister(struct DSVideoRenderer* renderer, uint32_t address, uint16_t value);
17static void DSVideoSoftwareRendererWritePalette(struct DSVideoRenderer* renderer, uint32_t address, uint16_t value);
18static void DSVideoSoftwareRendererWriteOAM(struct DSVideoRenderer* renderer, uint32_t oam);
19static void DSVideoSoftwareRendererInvalidateExtPal(struct DSVideoRenderer* renderer, bool obj, bool engB, int slot);
20static void DSVideoSoftwareRendererDrawScanline(struct DSVideoRenderer* renderer, int y);
21static void DSVideoSoftwareRendererDrawScanlineDirectly(struct DSVideoRenderer* renderer, int y, color_t* scanline);
22static void DSVideoSoftwareRendererFinishFrame(struct DSVideoRenderer* renderer);
23static void DSVideoSoftwareRendererGetPixels(struct DSVideoRenderer* renderer, size_t* stride, const void** pixels);
24static void DSVideoSoftwareRendererPutPixels(struct DSVideoRenderer* renderer, size_t stride, const void* pixels);
25
26static void DSVideoSoftwareRendererDrawBackgroundExt0(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY);
27static void DSVideoSoftwareRendererDrawBackgroundExt1(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY);
28static void DSVideoSoftwareRendererDrawBackgroundExt2(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY);
29
30static bool _regenerateExtPalette(struct DSVideoSoftwareRenderer* renderer, bool obj, bool engB, int slot) {
31 color_t* palette;
32 color_t* variantPalette;
33 struct GBAVideoSoftwareRenderer* softwareRenderer;
34 uint16_t* vram;
35 if (!obj) {
36 if (!engB) {
37 palette = &renderer->extPaletteA[slot * 4096];
38 variantPalette = &renderer->variantPaletteA[slot * 4096];
39 softwareRenderer = &renderer->engA;
40 vram = renderer->d.vramABGExtPal[slot];
41 } else {
42 palette = &renderer->extPaletteB[slot * 4096];
43 variantPalette = &renderer->variantPaletteB[slot * 4096];
44 softwareRenderer = &renderer->engB;
45 vram = renderer->d.vramBBGExtPal[slot];
46 }
47 } else {
48 if (!engB) {
49 palette = renderer->objExtPaletteA;
50 variantPalette = renderer->variantPaletteA;
51 softwareRenderer = &renderer->engA;
52 vram = renderer->d.vramAOBJExtPal;
53 } else {
54 palette = renderer->objExtPaletteB;
55 variantPalette = renderer->variantPaletteB;
56 softwareRenderer = &renderer->engB;
57 vram = renderer->d.vramBOBJExtPal;
58 }
59 }
60 if (!vram) {
61 return false;
62 }
63 int i;
64 for (i = 0; i < 4096; ++i) {
65 uint16_t value = vram[i];
66#ifdef COLOR_16_BIT
67#ifdef COLOR_5_6_5
68 unsigned color = 0;
69 color |= (value & 0x001F) << 11;
70 color |= (value & 0x03E0) << 1;
71 color |= (value & 0x7C00) >> 10;
72#else
73 unsigned color = value;
74#endif
75#else
76 unsigned color = 0;
77 color |= (value << 3) & 0xF8;
78 color |= (value << 6) & 0xF800;
79 color |= (value << 9) & 0xF80000;
80 color |= (color >> 5) & 0x070707;
81#endif
82 palette[i] = color;
83 if (softwareRenderer->blendEffect == BLEND_BRIGHTEN) {
84 variantPalette[i] = _brighten(color, softwareRenderer->bldy);
85 } else if (softwareRenderer->blendEffect == BLEND_DARKEN) {
86 variantPalette[i] = _darken(color, softwareRenderer->bldy);
87 }
88 }
89 if (obj) {
90 softwareRenderer->objExtPalette = palette;
91 softwareRenderer->objExtVariantPalette = variantPalette;
92 } else {
93 if (slot >= 2) {
94 if (GBARegisterBGCNTIsExtPaletteSlot(softwareRenderer->bg[slot - 2].control)) {
95 softwareRenderer->bg[slot - 2].extPalette = palette;
96 softwareRenderer->bg[slot - 2].variantPalette = variantPalette;
97 }
98 } else if (slot < 2 && !GBARegisterBGCNTIsExtPaletteSlot(softwareRenderer->bg[slot].control) ) {
99 softwareRenderer->bg[slot].extPalette = palette;
100 softwareRenderer->bg[slot].variantPalette = variantPalette;
101 }
102 softwareRenderer->bg[slot].extPalette = palette;
103 softwareRenderer->bg[slot].variantPalette = variantPalette;
104 }
105 return true;
106}
107
108static void _updateCharBase(struct DSVideoSoftwareRenderer* softwareRenderer, bool engB) {
109 struct GBAVideoSoftwareRenderer* eng;
110 if (!engB) {
111 eng = &softwareRenderer->engA;
112 } else {
113 eng = &softwareRenderer->engB;
114 }
115 int i;
116 uint32_t charBase = DSRegisterDISPCNTGetCharBase(softwareRenderer->dispcntA) << 16;
117 uint32_t screenBase = DSRegisterDISPCNTGetScreenBase(softwareRenderer->dispcntA) << 16;
118 for (i = 0; i < 4; ++i) {
119 if (!engB) {
120 uint32_t control = eng->bg[i].control;
121 eng->d.writeVideoRegister(&eng->d, DS9_REG_A_BG0CNT + i * 2, control);
122 eng->bg[i].control = control;
123 }
124
125 eng->bg[i].charBase = GBARegisterBGCNTGetCharBase(eng->bg[i].control) << 14;
126
127 if (!engB) {
128 softwareRenderer->engA.bg[i].charBase += charBase;
129 softwareRenderer->engA.bg[i].screenBase &= ~0x70000;
130 softwareRenderer->engA.bg[i].screenBase |= screenBase;
131 }
132 }
133}
134
135void DSVideoSoftwareRendererCreate(struct DSVideoSoftwareRenderer* renderer) {
136 renderer->d.init = DSVideoSoftwareRendererInit;
137 renderer->d.reset = DSVideoSoftwareRendererReset;
138 renderer->d.deinit = DSVideoSoftwareRendererDeinit;
139 renderer->d.writeVideoRegister = DSVideoSoftwareRendererWriteVideoRegister;
140 renderer->d.writePalette = DSVideoSoftwareRendererWritePalette;
141 renderer->d.writeOAM = DSVideoSoftwareRendererWriteOAM;
142 renderer->d.invalidateExtPal = DSVideoSoftwareRendererInvalidateExtPal;
143 renderer->d.drawScanline = DSVideoSoftwareRendererDrawScanline;
144 renderer->d.drawScanlineDirectly = DSVideoSoftwareRendererDrawScanlineDirectly;
145 renderer->d.finishFrame = DSVideoSoftwareRendererFinishFrame;
146 renderer->d.getPixels = DSVideoSoftwareRendererGetPixels;
147 renderer->d.putPixels = DSVideoSoftwareRendererPutPixels;
148
149 renderer->engA.d.cache = NULL;
150 GBAVideoSoftwareRendererCreate(&renderer->engA);
151 renderer->engB.d.cache = NULL;
152 GBAVideoSoftwareRendererCreate(&renderer->engB);
153}
154
155static void DSVideoSoftwareRendererInit(struct DSVideoRenderer* renderer) {
156 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
157 softwareRenderer->engA.d.palette = &renderer->palette[0];
158 softwareRenderer->engA.d.oam = &renderer->oam->oam[0];
159 softwareRenderer->engA.masterEnd = DS_VIDEO_HORIZONTAL_PIXELS;
160 softwareRenderer->engA.masterHeight = DS_VIDEO_VERTICAL_PIXELS;
161 softwareRenderer->engA.masterScanlines = DS_VIDEO_VERTICAL_TOTAL_PIXELS;
162 softwareRenderer->engA.outputBufferStride = softwareRenderer->outputBufferStride;
163 softwareRenderer->engB.d.palette = &renderer->palette[512];
164 softwareRenderer->engB.d.oam = &renderer->oam->oam[1];
165 softwareRenderer->engB.masterEnd = DS_VIDEO_HORIZONTAL_PIXELS;
166 softwareRenderer->engB.masterHeight = DS_VIDEO_VERTICAL_PIXELS;
167 softwareRenderer->engB.masterScanlines = DS_VIDEO_VERTICAL_TOTAL_PIXELS;
168 softwareRenderer->engB.outputBufferStride = softwareRenderer->outputBufferStride;
169
170 DSVideoSoftwareRendererReset(renderer);
171}
172
173static void DSVideoSoftwareRendererReset(struct DSVideoRenderer* renderer) {
174 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
175 softwareRenderer->engA.d.reset(&softwareRenderer->engA.d);
176 softwareRenderer->engB.d.reset(&softwareRenderer->engB.d);
177 softwareRenderer->powcnt = 0;
178 softwareRenderer->dispcntA = 0;
179 softwareRenderer->dispcntB = 0;
180}
181
182static void DSVideoSoftwareRendererDeinit(struct DSVideoRenderer* renderer) {
183 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
184 softwareRenderer->engA.d.deinit(&softwareRenderer->engA.d);
185 softwareRenderer->engB.d.deinit(&softwareRenderer->engB.d);
186}
187
188static void DSVideoSoftwareRendererUpdateDISPCNT(struct DSVideoSoftwareRenderer* softwareRenderer, bool engB) {
189 uint32_t dispcnt;
190 struct GBAVideoSoftwareRenderer* eng;
191 if (!engB) {
192 dispcnt = softwareRenderer->dispcntA;
193 eng = &softwareRenderer->engA;
194 } else {
195 dispcnt = softwareRenderer->dispcntB;
196 eng = &softwareRenderer->engB;
197 }
198 uint16_t fakeDispcnt = dispcnt & 0xFF87;
199 if (!DSRegisterDISPCNTIsTileObjMapping(dispcnt)) {
200 eng->tileStride = 0x20;
201 } else {
202 eng->tileStride = 0x20 << DSRegisterDISPCNTGetTileBoundary(dispcnt);
203 fakeDispcnt = GBARegisterDISPCNTFillObjCharacterMapping(fakeDispcnt);
204 }
205 eng->d.writeVideoRegister(&eng->d, DS9_REG_A_DISPCNT_LO, fakeDispcnt);
206 eng->dispcnt |= dispcnt & 0xFFFF0000;
207 if (DSRegisterDISPCNTIsBgExtPalette(dispcnt)) {
208 color_t* extPalette;
209 if (!engB) {
210 extPalette = softwareRenderer->extPaletteA;
211 } else {
212 extPalette = softwareRenderer->extPaletteB;
213 }
214 int i;
215 for (i = 0; i < 4; ++i) {
216 int slot = i;
217 if (i < 2 && GBARegisterBGCNTIsExtPaletteSlot(eng->bg[i].control)) {
218 slot += 2;
219 }
220 if (eng->bg[i].extPalette != &extPalette[slot * 4096]) {
221 _regenerateExtPalette(softwareRenderer, false, engB, slot);
222 }
223 }
224 } else {
225 eng->bg[0].extPalette = NULL;
226 eng->bg[1].extPalette = NULL;
227 eng->bg[2].extPalette = NULL;
228 eng->bg[3].extPalette = NULL;
229 }
230 if (DSRegisterDISPCNTIsObjExtPalette(dispcnt)) {
231 if (!engB) {
232 if (softwareRenderer->engA.objExtPalette != softwareRenderer->objExtPaletteA) {
233 _regenerateExtPalette(softwareRenderer, true, engB, 0);
234 }
235 } else {
236 if (softwareRenderer->engB.objExtPalette != softwareRenderer->objExtPaletteB) {
237 _regenerateExtPalette(softwareRenderer, true, engB, 0);
238 }
239 }
240 } else {
241 if (!engB) {
242 softwareRenderer->engA.objExtPalette = NULL;
243 } else {
244 softwareRenderer->engB.objExtPalette = NULL;
245 }
246 }
247 if (!engB) {
248 eng->dispcnt = DSRegisterDISPCNTClear3D(eng->dispcnt);
249 eng->dispcnt |= DSRegisterDISPCNTIs3D(dispcnt);
250 _updateCharBase(softwareRenderer, engB);
251 }
252}
253
254static uint16_t DSVideoSoftwareRendererWriteVideoRegister(struct DSVideoRenderer* renderer, uint32_t address, uint16_t value) {
255 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
256 if (address >= DS9_REG_A_BG0CNT && address <= DS9_REG_A_BLDY) {
257 softwareRenderer->engA.d.writeVideoRegister(&softwareRenderer->engA.d, address, value);
258 } else if (address >= DS9_REG_B_BG0CNT && address <= DS9_REG_B_BLDY) {
259 softwareRenderer->engB.d.writeVideoRegister(&softwareRenderer->engB.d, address & 0xFF, value);
260 } else {
261 mLOG(DS_VIDEO, STUB, "Stub video register write: %04X:%04X", address, value);
262 }
263 switch (address) {
264 case DS9_REG_A_BG0CNT:
265 case DS9_REG_A_BG1CNT:
266 softwareRenderer->engA.bg[(address - DS9_REG_A_BG0CNT) >> 1].control = value;
267 // Fall through
268 case DS9_REG_A_BG2CNT:
269 case DS9_REG_A_BG3CNT:
270 _updateCharBase(softwareRenderer, false);
271 break;
272 case DS9_REG_B_BG0CNT:
273 case DS9_REG_B_BG1CNT:
274 softwareRenderer->engB.bg[(address - DS9_REG_B_BG0CNT) >> 1].control = value;
275 // Fall through
276 case DS9_REG_B_BG2CNT:
277 case DS9_REG_B_BG3CNT:
278 _updateCharBase(softwareRenderer, true);
279 break;
280 case DS9_REG_A_MASTER_BRIGHT:
281 softwareRenderer->engA.masterBright = DSRegisterMASTER_BRIGHTGetMode(value);
282 softwareRenderer->engA.masterBrightY = DSRegisterMASTER_BRIGHTGetY(value);
283 if (softwareRenderer->engA.masterBrightY > 0x10) {
284 softwareRenderer->engA.masterBrightY = 0x10;
285 }
286 break;
287 case DS9_REG_B_MASTER_BRIGHT:
288 softwareRenderer->engB.masterBright = DSRegisterMASTER_BRIGHTGetMode(value);
289 softwareRenderer->engB.masterBrightY = DSRegisterMASTER_BRIGHTGetY(value);
290 if (softwareRenderer->engB.masterBrightY > 0x10) {
291 softwareRenderer->engB.masterBrightY = 0x10;
292 }
293 break;
294 case DS9_REG_A_BLDCNT:
295 case DS9_REG_A_BLDY:
296 // TODO: Optimize
297 _regenerateExtPalette(softwareRenderer, false, false, 0);
298 _regenerateExtPalette(softwareRenderer, false, false, 1);
299 _regenerateExtPalette(softwareRenderer, false, false, 2);
300 _regenerateExtPalette(softwareRenderer, false, false, 3);
301 _regenerateExtPalette(softwareRenderer, true, false, 0);
302 break;
303 case DS9_REG_B_BLDCNT:
304 case DS9_REG_B_BLDY:
305 // TODO: Optimize
306 _regenerateExtPalette(softwareRenderer, false, true, 0);
307 _regenerateExtPalette(softwareRenderer, false, true, 1);
308 _regenerateExtPalette(softwareRenderer, false, true, 2);
309 _regenerateExtPalette(softwareRenderer, false, true, 3);
310 _regenerateExtPalette(softwareRenderer, true, true, 0);
311 break;
312 case DS9_REG_A_DISPCNT_LO:
313 softwareRenderer->dispcntA &= 0xFFFF0000;
314 softwareRenderer->dispcntA |= value;
315 DSVideoSoftwareRendererUpdateDISPCNT(softwareRenderer, false);
316 break;
317 case DS9_REG_A_DISPCNT_HI:
318 softwareRenderer->dispcntA &= 0x0000FFFF;
319 softwareRenderer->dispcntA |= value << 16;
320 DSVideoSoftwareRendererUpdateDISPCNT(softwareRenderer, false);
321 break;
322 case DS9_REG_B_DISPCNT_LO:
323 softwareRenderer->dispcntB &= 0xFFFF0000;
324 softwareRenderer->dispcntB |= value;
325 DSVideoSoftwareRendererUpdateDISPCNT(softwareRenderer, true);
326 break;
327 case DS9_REG_B_DISPCNT_HI:
328 softwareRenderer->dispcntB &= 0x0000FFFF;
329 softwareRenderer->dispcntB |= value << 16;
330 DSVideoSoftwareRendererUpdateDISPCNT(softwareRenderer, true);
331 break;
332 case DS9_REG_POWCNT1:
333 value &= 0x810F;
334 softwareRenderer->powcnt = value;
335 }
336 return value;
337}
338
339static void DSVideoSoftwareRendererWritePalette(struct DSVideoRenderer* renderer, uint32_t address, uint16_t value) {
340 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
341 if (address < 0x400) {
342 softwareRenderer->engA.d.writePalette(&softwareRenderer->engA.d, address & 0x3FF, value);
343 } else {
344 softwareRenderer->engB.d.writePalette(&softwareRenderer->engB.d, address & 0x3FF, value);
345 }
346}
347
348static void DSVideoSoftwareRendererWriteOAM(struct DSVideoRenderer* renderer, uint32_t oam) {
349 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
350 if (oam < 0x200) {
351 softwareRenderer->engA.d.writeOAM(&softwareRenderer->engA.d, oam & 0x1FF);
352 } else {
353 softwareRenderer->engB.d.writeOAM(&softwareRenderer->engB.d, oam & 0x1FF);
354 }
355}
356
357static void DSVideoSoftwareRendererInvalidateExtPal(struct DSVideoRenderer* renderer, bool obj, bool engB, int slot) {
358 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
359 _regenerateExtPalette(softwareRenderer, obj, engB, slot);
360}
361
362static void DSVideoSoftwareRendererDrawGBAScanline(struct GBAVideoRenderer* renderer, struct DSGX* gx, int y) {
363 struct GBAVideoSoftwareRenderer* softwareRenderer = (struct GBAVideoSoftwareRenderer*) renderer;
364
365 int x;
366 color_t* row = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * y];
367 if (GBARegisterDISPCNTIsForcedBlank(softwareRenderer->dispcnt)) {
368 for (x = 0; x < softwareRenderer->masterEnd; ++x) {
369 row[x] = GBA_COLOR_WHITE;
370 }
371 return;
372 }
373
374 GBAVideoSoftwareRendererPreprocessBuffer(softwareRenderer, y);
375 int spriteLayers = GBAVideoSoftwareRendererPreprocessSpriteLayer(softwareRenderer, y);
376 memset(softwareRenderer->alphaA, softwareRenderer->blda, sizeof(softwareRenderer->alphaA));
377 memset(softwareRenderer->alphaB, softwareRenderer->bldb, sizeof(softwareRenderer->alphaB));
378
379 int w;
380 unsigned priority;
381 for (priority = 0; priority < 4; ++priority) {
382 softwareRenderer->end = 0;
383 for (w = 0; w < softwareRenderer->nWindows; ++w) {
384 softwareRenderer->start = softwareRenderer->end;
385 softwareRenderer->end = softwareRenderer->windows[w].endX;
386 softwareRenderer->currentWindow = softwareRenderer->windows[w].control;
387 if (spriteLayers & (1 << priority)) {
388 GBAVideoSoftwareRendererPostprocessSprite(softwareRenderer, priority);
389 }
390 if (TEST_LAYER_ENABLED(0)) {
391 if (DSRegisterDISPCNTIs3D(softwareRenderer->dispcnt) && gx) {
392 const color_t* scanline;
393 gx->renderer->getScanline(gx->renderer, y, &scanline);
394 uint32_t flags = (softwareRenderer->bg[0].priority << OFFSET_PRIORITY) | FLAG_IS_BACKGROUND;
395 flags |= FLAG_TARGET_2 * softwareRenderer->bg[0].target2;
396 flags |= FLAG_TARGET_1 * (softwareRenderer->bg[0].target1 && softwareRenderer->blendEffect == BLEND_ALPHA && GBAWindowControlIsBlendEnable(softwareRenderer->currentWindow.packed));
397 int x;
398 for (x = softwareRenderer->start; x < softwareRenderer->end; ++x) {
399 if (scanline[x] & 0xFC000000) {
400 if ((scanline[x] >> 28) != 0xF) {
401 // TODO: More precise values
402 softwareRenderer->alphaA[x] = (scanline[x] >> 28) + 1;
403 softwareRenderer->alphaB[x] = 0xF - (scanline[x] >> 28);
404 _compositeBlendNoObjwin(softwareRenderer, x, (scanline[x] & 0x00FFFFFF) | flags | FLAG_TARGET_1, softwareRenderer->row[x]);
405 } else {
406 _compositeNoBlendNoObjwin(softwareRenderer, x, (scanline[x] & 0x00FFFFFF) | flags, softwareRenderer->row[x]);
407 softwareRenderer->alphaA[x] = 0x10;
408 softwareRenderer->alphaB[x] = 0;
409 }
410 }
411 }
412 } else {
413 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[0], y);
414 }
415 }
416 if (TEST_LAYER_ENABLED(1)) {
417 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[1], y);
418 }
419 if (TEST_LAYER_ENABLED(2)) {
420 switch (GBARegisterDISPCNTGetMode(softwareRenderer->dispcnt)) {
421 case 0:
422 case 1:
423 case 3:
424 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[2], y);
425 break;
426 case 2:
427 case 4:
428 GBAVideoSoftwareRendererDrawBackgroundMode2(softwareRenderer, &softwareRenderer->bg[2], y);
429 break;
430 case 5:
431 if (!GBARegisterBGCNTIsExtendedMode1(softwareRenderer->bg[2].control)) {
432 DSVideoSoftwareRendererDrawBackgroundExt0(softwareRenderer, &softwareRenderer->bg[2], y);
433 } else if (!GBARegisterBGCNTIsExtendedMode0(softwareRenderer->bg[2].control)) {
434 DSVideoSoftwareRendererDrawBackgroundExt1(softwareRenderer, &softwareRenderer->bg[2], y);
435 } else {
436 DSVideoSoftwareRendererDrawBackgroundExt2(softwareRenderer, &softwareRenderer->bg[2], y);
437 }
438 break;
439 }
440 }
441 if (TEST_LAYER_ENABLED(3)) {
442 switch (GBARegisterDISPCNTGetMode(softwareRenderer->dispcnt)) {
443 case 0:
444 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[3], y);
445 break;
446 case 1:
447 case 2:
448 GBAVideoSoftwareRendererDrawBackgroundMode2(softwareRenderer, &softwareRenderer->bg[3], y);
449 break;
450 case 3:
451 case 4:
452 case 5:
453 if (!GBARegisterBGCNTIsExtendedMode1(softwareRenderer->bg[3].control)) {
454 DSVideoSoftwareRendererDrawBackgroundExt0(softwareRenderer, &softwareRenderer->bg[3], y);
455 } else if (!GBARegisterBGCNTIsExtendedMode0(softwareRenderer->bg[3].control)) {
456 DSVideoSoftwareRendererDrawBackgroundExt1(softwareRenderer, &softwareRenderer->bg[3], y);
457 } else {
458 DSVideoSoftwareRendererDrawBackgroundExt2(softwareRenderer, &softwareRenderer->bg[3], y);
459 }
460 break;
461 }
462 }
463 }
464 }
465 softwareRenderer->bg[2].sx += softwareRenderer->bg[2].dmx;
466 softwareRenderer->bg[2].sy += softwareRenderer->bg[2].dmy;
467 softwareRenderer->bg[3].sx += softwareRenderer->bg[3].dmx;
468 softwareRenderer->bg[3].sy += softwareRenderer->bg[3].dmy;
469
470 GBAVideoSoftwareRendererPostprocessBuffer(softwareRenderer);
471}
472
473static void _drawScanlineA(struct DSVideoSoftwareRenderer* softwareRenderer, int y) {
474 memcpy(softwareRenderer->engA.d.vramBG, softwareRenderer->d.vramABG, sizeof(softwareRenderer->engA.d.vramBG));
475 memcpy(softwareRenderer->engA.d.vramOBJ, softwareRenderer->d.vramAOBJ, sizeof(softwareRenderer->engA.d.vramOBJ));
476 color_t* row = &softwareRenderer->engA.outputBuffer[softwareRenderer->outputBufferStride * y];
477
478 int x;
479 switch (DSRegisterDISPCNTGetDispMode(softwareRenderer->dispcntA)) {
480 case 0:
481 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
482 row[x] = GBA_COLOR_WHITE;
483 }
484 return;
485 case 1:
486 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engA.d, softwareRenderer->d.gx, y);
487 break;
488 case 2: {
489 uint16_t* vram = &softwareRenderer->d.vram[0x10000 * DSRegisterDISPCNTGetVRAMBlock(softwareRenderer->dispcntA)];
490 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
491 color_t color;
492 LOAD_16(color, (x + y * DS_VIDEO_HORIZONTAL_PIXELS) * 2, vram);
493#ifndef COLOR_16_BIT
494 unsigned color32 = 0;
495 color32 |= (color << 9) & 0xF80000;
496 color32 |= (color << 3) & 0xF8;
497 color32 |= (color << 6) & 0xF800;
498 color32 |= (color32 >> 5) & 0x070707;
499 color = color32;
500#elif COLOR_5_6_5
501 uint16_t color16 = 0;
502 color16 |= (color & 0x001F) << 11;
503 color16 |= (color & 0x03E0) << 1;
504 color16 |= (color & 0x7C00) >> 10;
505 color = color16;
506#endif
507 softwareRenderer->engA.row[x] = color;
508 }
509 break;
510 }
511 case 3:
512 break;
513 }
514
515#ifdef COLOR_16_BIT
516#if defined(__ARM_NEON) && !defined(__APPLE__)
517 _to16Bit(row, softwareRenderer->engA.row, DS_VIDEO_HORIZONTAL_PIXELS);
518#else
519 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
520 row[x] = softwareRenderer->engA.row[x];
521 }
522#endif
523#else
524 switch (softwareRenderer->engA.masterBright) {
525 case 0:
526 default:
527 memcpy(row, softwareRenderer->engA.row, softwareRenderer->engA.masterEnd * sizeof(*row));
528 break;
529 case 1:
530 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
531 row[x] = _brighten(softwareRenderer->engA.row[x], softwareRenderer->engA.masterBrightY);
532 }
533 break;
534 case 2:
535 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
536 row[x] = _darken(softwareRenderer->engA.row[x], softwareRenderer->engA.masterBrightY);
537 }
538 break;
539 }
540#endif
541}
542
543static void _drawScanlineB(struct DSVideoSoftwareRenderer* softwareRenderer, int y) {
544 memcpy(softwareRenderer->engB.d.vramBG, softwareRenderer->d.vramBBG, sizeof(softwareRenderer->engB.d.vramBG));
545 memcpy(softwareRenderer->engB.d.vramOBJ, softwareRenderer->d.vramBOBJ, sizeof(softwareRenderer->engB.d.vramOBJ));
546 color_t* row = &softwareRenderer->engB.outputBuffer[softwareRenderer->outputBufferStride * y];
547
548 int x;
549 switch (DSRegisterDISPCNTGetDispMode(softwareRenderer->dispcntB)) {
550 case 0:
551 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
552 row[x] = GBA_COLOR_WHITE;
553 }
554 return;
555 case 1:
556 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engB.d, NULL, y);
557 break;
558 }
559
560#ifdef COLOR_16_BIT
561#if defined(__ARM_NEON) && !defined(__APPLE__)
562 _to16Bit(row, softwareRenderer->engB.row, DS_VIDEO_HORIZONTAL_PIXELS);
563#else
564 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
565 row[x] = softwareRenderer->engB.row[x];
566 }
567#endif
568#else
569 switch (softwareRenderer->engB.masterBright) {
570 case 0:
571 default:
572 memcpy(row, softwareRenderer->engB.row, softwareRenderer->engB.masterEnd * sizeof(*row));
573 break;
574 case 1:
575 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
576 row[x] = _brighten(softwareRenderer->engB.row[x], softwareRenderer->engB.masterBrightY);
577 }
578 break;
579 case 2:
580 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
581 row[x] = _darken(softwareRenderer->engB.row[x], softwareRenderer->engB.masterBrightY);
582 }
583 break;
584 }
585#endif
586}
587
588static void DSVideoSoftwareRendererDrawScanline(struct DSVideoRenderer* renderer, int y) {
589 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
590 if (!DSRegisterPOWCNT1IsSwap(softwareRenderer->powcnt)) {
591 softwareRenderer->engA.outputBuffer = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * DS_VIDEO_VERTICAL_PIXELS];
592 softwareRenderer->engB.outputBuffer = softwareRenderer->outputBuffer;
593 } else {
594 softwareRenderer->engA.outputBuffer = softwareRenderer->outputBuffer;
595 softwareRenderer->engB.outputBuffer = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * DS_VIDEO_VERTICAL_PIXELS];
596 }
597
598 _drawScanlineA(softwareRenderer, y);
599 _drawScanlineB(softwareRenderer, y);
600}
601
602static void DSVideoSoftwareRendererDrawScanlineDirectly(struct DSVideoRenderer* renderer, int y, color_t* scanline) {
603 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
604 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engA.d, softwareRenderer->d.gx, y);
605 memcpy(scanline, softwareRenderer->engA.row, softwareRenderer->engA.masterEnd * sizeof(*scanline));
606}
607
608static void DSVideoSoftwareRendererFinishFrame(struct DSVideoRenderer* renderer) {
609 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
610 softwareRenderer->engA.d.finishFrame(&softwareRenderer->engA.d);
611 softwareRenderer->engB.d.finishFrame(&softwareRenderer->engB.d);
612}
613
614static void DSVideoSoftwareRendererGetPixels(struct DSVideoRenderer* renderer, size_t* stride, const void** pixels) {
615 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
616#ifdef COLOR_16_BIT
617#error Not yet supported
618#else
619 *stride = softwareRenderer->outputBufferStride;
620 *pixels = softwareRenderer->outputBuffer;
621#endif
622}
623
624static void DSVideoSoftwareRendererPutPixels(struct DSVideoRenderer* renderer, size_t stride, const void* pixels) {
625}
626
627#define EXT_0_COORD_OVERFLOW \
628 localX = x & (sizeAdjusted - 1); \
629 localY = y & (sizeAdjusted - 1); \
630
631#define EXT_0_COORD_NO_OVERFLOW \
632 if ((x | y) & ~(sizeAdjusted - 1)) { \
633 continue; \
634 } \
635 localX = x; \
636 localY = y;
637
638#define EXT_0_NO_MOSAIC(COORD) \
639 COORD \
640 uint32_t screenBase = background->screenBase + (localX >> 10) + (((localY >> 6) & 0xFE0) << background->size); \
641 uint16_t* screenBlock = renderer->d.vramBG[screenBase >> VRAM_BLOCK_OFFSET]; \
642 if (UNLIKELY(!screenBlock)) { \
643 continue; \
644 } \
645 LOAD_16(mapData, screenBase & (VRAM_BLOCK_MASK - 1), screenBlock); \
646 paletteData = GBA_TEXT_MAP_PALETTE(mapData) << 8; \
647 palette = &mainPalette[paletteData]; \
648 if (GBA_TEXT_MAP_VFLIP(mapData)) { \
649 localY = 0x7FF - localY; \
650 } \
651 if (GBA_TEXT_MAP_HFLIP(mapData)) { \
652 localX = 0x7FF - localX; \
653 } \
654 uint32_t charBase = (background->charBase + (GBA_TEXT_MAP_TILE(mapData) << 6)) + ((localY & 0x700) >> 5) + ((localX & 0x700) >> 8); \
655 uint16_t* vram = renderer->d.vramBG[charBase >> VRAM_BLOCK_OFFSET]; \
656 if (UNLIKELY(!vram)) { \
657 continue; \
658 } \
659 pixelData = ((uint8_t*) vram)[charBase & VRAM_BLOCK_MASK];
660
661#define EXT_0_MOSAIC(COORD) \
662 if (!mosaicWait) { \
663 EXT_0_NO_MOSAIC(COORD) \
664 mosaicWait = mosaicH; \
665 } else { \
666 --mosaicWait; \
667 }
668
669#define EXT_0_LOOP(MOSAIC, COORD, BLEND, OBJWIN) \
670 for (outX = renderer->start, pixel = &renderer->row[outX]; outX < renderer->end; ++outX, ++pixel) { \
671 x += background->dx; \
672 y += background->dy; \
673 \
674 uint32_t current = *pixel; \
675 MOSAIC(COORD) \
676 if (pixelData) { \
677 COMPOSITE_256_ ## OBJWIN (BLEND, 0); \
678 } \
679 }
680
681#define DRAW_BACKGROUND_EXT_0(BLEND, OBJWIN) \
682 if (background->overflow) { \
683 if (mosaicH > 1) { \
684 EXT_0_LOOP(EXT_0_MOSAIC, EXT_0_COORD_OVERFLOW, BLEND, OBJWIN); \
685 } else { \
686 EXT_0_LOOP(EXT_0_NO_MOSAIC, EXT_0_COORD_OVERFLOW, BLEND, OBJWIN); \
687 } \
688 } else { \
689 if (mosaicH > 1) { \
690 EXT_0_LOOP(EXT_0_MOSAIC, EXT_0_COORD_NO_OVERFLOW, BLEND, OBJWIN); \
691 } else { \
692 EXT_0_LOOP(EXT_0_NO_MOSAIC, EXT_0_COORD_NO_OVERFLOW, BLEND, OBJWIN); \
693 } \
694 }
695
696void DSVideoSoftwareRendererDrawBackgroundExt0(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
697 int sizeAdjusted = 0x8000 << background->size;
698
699 BACKGROUND_BITMAP_INIT;
700
701 color_t* mainPalette = background->extPalette;
702 if (variant) {
703 mainPalette = background->variantPalette;
704 }
705 if (!mainPalette) {
706 return;
707 }
708 int paletteData;
709
710 uint16_t mapData;
711 uint8_t pixelData = 0;
712
713 int outX;
714 uint32_t* pixel;
715
716 if (!objwinSlowPath) {
717 if (!(flags & FLAG_TARGET_2)) {
718 DRAW_BACKGROUND_EXT_0(NoBlend, NO_OBJWIN);
719 } else {
720 DRAW_BACKGROUND_EXT_0(Blend, NO_OBJWIN);
721 }
722 } else {
723 if (!(flags & FLAG_TARGET_2)) {
724 DRAW_BACKGROUND_EXT_0(NoBlend, OBJWIN);
725 } else {
726 DRAW_BACKGROUND_EXT_0(Blend, OBJWIN);
727 }
728 }
729}
730
731void DSVideoSoftwareRendererDrawBackgroundExt1(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
732 BACKGROUND_BITMAP_INIT;
733
734 uint8_t color;
735 int width, height;
736 switch (background->size) {
737 case 0:
738 width = 128;
739 height = 128;
740 break;
741 case 1:
742 width = 256;
743 height = 256;
744 break;
745 case 2:
746 width = 512;
747 height = 256;
748 break;
749 case 3:
750 width = 512;
751 height = 512;
752 break;
753 }
754
755 int outX;
756 for (outX = renderer->start; outX < renderer->end; ++outX) {
757 BACKGROUND_BITMAP_ITERATE(width, height);
758
759 if (!mosaicWait) {
760 uint32_t address = (localX >> 8) + (localY >> 8) * width;
761 uint8_t* vram = (uint8_t*) renderer->d.vramBG[address >> 17];
762 if (UNLIKELY(!vram)) {
763 continue;
764 }
765 color = vram[address];
766 mosaicWait = mosaicH;
767 } else {
768 --mosaicWait;
769 }
770
771 uint32_t current = renderer->row[outX];
772 if (color && IS_WRITABLE(current)) {
773 if (!objwinSlowPath) {
774 _compositeBlendNoObjwin(renderer, outX, palette[color] | flags, current);
775 } else if (objwinForceEnable || (!(current & FLAG_OBJWIN)) == objwinOnly) {
776 color_t* currentPalette = (current & FLAG_OBJWIN) ? objwinPalette : palette;
777 unsigned mergedFlags = flags;
778 if (current & FLAG_OBJWIN) {
779 mergedFlags = objwinFlags;
780 }
781 _compositeBlendObjwin(renderer, outX, currentPalette[color] | mergedFlags, current);
782 }
783 }
784 }
785}
786
787void DSVideoSoftwareRendererDrawBackgroundExt2(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
788 BACKGROUND_BITMAP_INIT;
789
790 uint32_t color;
791 int width, height;
792 switch (background->size) {
793 case 0:
794 width = 128;
795 height = 128;
796 break;
797 case 1:
798 width = 256;
799 height = 256;
800 break;
801 case 2:
802 width = 512;
803 height = 256;
804 break;
805 case 3:
806 width = 512;
807 height = 512;
808 break;
809 }
810
811 int outX;
812 for (outX = renderer->start; outX < renderer->end; ++outX) {
813 BACKGROUND_BITMAP_ITERATE(width, height);
814
815 if (!mosaicWait) {
816 uint32_t address = ((localX >> 8) + (localY >> 8) * width) << 1;
817 uint16_t* vram = renderer->d.vramBG[address >> 17];
818 if (UNLIKELY(!vram)) {
819 continue;
820 }
821 LOAD_16(color, address & 0x1FFFE, vram);
822#ifndef COLOR_16_BIT
823 unsigned color32;
824 color32 = 0;
825 color32 |= (color << 3) & 0xF8;
826 color32 |= (color << 6) & 0xF800;
827 color32 |= (color << 9) & 0xF80000;
828 color32 |= (color32 >> 5) & 0x070707;
829 color = color32;
830#elif COLOR_5_6_5
831 uint16_t color16 = 0;
832 color16 |= (color & 0x001F) << 11;
833 color16 |= (color & 0x03E0) << 1;
834 color16 |= (color & 0x7C00) >> 10;
835 color = color16;
836#endif
837 mosaicWait = mosaicH;
838 } else {
839 --mosaicWait;
840 }
841
842 uint32_t current = renderer->row[outX];
843 if (!objwinSlowPath || (!(current & FLAG_OBJWIN)) != objwinOnly) {
844 unsigned mergedFlags = flags;
845 if (current & FLAG_OBJWIN) {
846 mergedFlags = objwinFlags;
847 }
848 if (!variant) {
849 _compositeBlendObjwin(renderer, outX, color | mergedFlags, current);
850 } else if (renderer->blendEffect == BLEND_BRIGHTEN) {
851 _compositeBlendObjwin(renderer, outX, _brighten(color, renderer->bldy) | mergedFlags, current);
852 } else if (renderer->blendEffect == BLEND_DARKEN) {
853 _compositeBlendObjwin(renderer, outX, _darken(color, renderer->bldy) | mergedFlags, current);
854 }
855 }
856 }
857}