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 color_t color = scanline[x];
400 if (softwareRenderer->bg[0].target1) {
401 if (softwareRenderer->blendEffect == BLEND_DARKEN) {
402 color = _darken(color, softwareRenderer->bldy) | (color & 0xFF000000);
403 } else if (softwareRenderer->blendEffect == BLEND_BRIGHTEN) {
404 color = _brighten(color, softwareRenderer->bldy) | (color & 0xFF000000);
405 }
406 }
407 if (color & 0xFC000000) {
408 if ((scanline[x] >> 28) != 0xF) {
409 // TODO: More precise values
410 softwareRenderer->alphaA[x] = (color >> 28) + 1;
411 softwareRenderer->alphaB[x] = 0xF - (color >> 28);
412 _compositeBlendNoObjwin(softwareRenderer, x, (color & 0x00FFFFFF) | flags | FLAG_TARGET_1, softwareRenderer->row[x]);
413 } else {
414 if (!(flags & FLAG_TARGET_2)) {
415 _compositeNoBlendNoObjwin(softwareRenderer, x, (color & 0x00FFFFFF) | flags, softwareRenderer->row[x]);
416 softwareRenderer->alphaA[x] = 0x10;
417 softwareRenderer->alphaB[x] = 0;
418 } else if (softwareRenderer->row[x] & FLAG_TARGET_1) {
419 _compositeBlendNoObjwin(softwareRenderer, x, (color & 0x00FFFFFF) | flags, softwareRenderer->row[x]);
420 } else {
421 _compositeNoBlendNoObjwin(softwareRenderer, x, (color & 0x00FFFFFF) | flags, softwareRenderer->row[x]);
422 }
423 }
424 }
425 }
426 } else {
427 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[0], y);
428 }
429 }
430 if (TEST_LAYER_ENABLED(1)) {
431 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[1], y);
432 }
433 if (TEST_LAYER_ENABLED(2)) {
434 switch (GBARegisterDISPCNTGetMode(softwareRenderer->dispcnt)) {
435 case 0:
436 case 1:
437 case 3:
438 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[2], y);
439 break;
440 case 2:
441 case 4:
442 GBAVideoSoftwareRendererDrawBackgroundMode2(softwareRenderer, &softwareRenderer->bg[2], y);
443 break;
444 case 5:
445 if (!GBARegisterBGCNTIsExtendedMode1(softwareRenderer->bg[2].control)) {
446 DSVideoSoftwareRendererDrawBackgroundExt0(softwareRenderer, &softwareRenderer->bg[2], y);
447 } else if (!GBARegisterBGCNTIsExtendedMode0(softwareRenderer->bg[2].control)) {
448 DSVideoSoftwareRendererDrawBackgroundExt1(softwareRenderer, &softwareRenderer->bg[2], y);
449 } else {
450 DSVideoSoftwareRendererDrawBackgroundExt2(softwareRenderer, &softwareRenderer->bg[2], y);
451 }
452 break;
453 }
454 }
455 if (TEST_LAYER_ENABLED(3)) {
456 switch (GBARegisterDISPCNTGetMode(softwareRenderer->dispcnt)) {
457 case 0:
458 GBAVideoSoftwareRendererDrawBackgroundMode0(softwareRenderer, &softwareRenderer->bg[3], y);
459 break;
460 case 1:
461 case 2:
462 GBAVideoSoftwareRendererDrawBackgroundMode2(softwareRenderer, &softwareRenderer->bg[3], y);
463 break;
464 case 3:
465 case 4:
466 case 5:
467 if (!GBARegisterBGCNTIsExtendedMode1(softwareRenderer->bg[3].control)) {
468 DSVideoSoftwareRendererDrawBackgroundExt0(softwareRenderer, &softwareRenderer->bg[3], y);
469 } else if (!GBARegisterBGCNTIsExtendedMode0(softwareRenderer->bg[3].control)) {
470 DSVideoSoftwareRendererDrawBackgroundExt1(softwareRenderer, &softwareRenderer->bg[3], y);
471 } else {
472 DSVideoSoftwareRendererDrawBackgroundExt2(softwareRenderer, &softwareRenderer->bg[3], y);
473 }
474 break;
475 }
476 }
477 }
478 }
479 softwareRenderer->bg[2].sx += softwareRenderer->bg[2].dmx;
480 softwareRenderer->bg[2].sy += softwareRenderer->bg[2].dmy;
481 softwareRenderer->bg[3].sx += softwareRenderer->bg[3].dmx;
482 softwareRenderer->bg[3].sy += softwareRenderer->bg[3].dmy;
483
484 GBAVideoSoftwareRendererPostprocessBuffer(softwareRenderer);
485}
486
487static void _drawScanlineA(struct DSVideoSoftwareRenderer* softwareRenderer, int y) {
488 memcpy(softwareRenderer->engA.d.vramBG, softwareRenderer->d.vramABG, sizeof(softwareRenderer->engA.d.vramBG));
489 memcpy(softwareRenderer->engA.d.vramOBJ, softwareRenderer->d.vramAOBJ, sizeof(softwareRenderer->engA.d.vramOBJ));
490 color_t* row = &softwareRenderer->engA.outputBuffer[softwareRenderer->outputBufferStride * y];
491
492 int x;
493 switch (DSRegisterDISPCNTGetDispMode(softwareRenderer->dispcntA)) {
494 case 0:
495 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
496 row[x] = GBA_COLOR_WHITE;
497 }
498 return;
499 case 1:
500 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engA.d, softwareRenderer->d.gx, y);
501 break;
502 case 2: {
503 uint16_t* vram = &softwareRenderer->d.vram[0x10000 * DSRegisterDISPCNTGetVRAMBlock(softwareRenderer->dispcntA)];
504 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
505 color_t color;
506 LOAD_16(color, (x + y * DS_VIDEO_HORIZONTAL_PIXELS) * 2, vram);
507#ifndef COLOR_16_BIT
508 unsigned color32 = 0;
509 color32 |= (color << 9) & 0xF80000;
510 color32 |= (color << 3) & 0xF8;
511 color32 |= (color << 6) & 0xF800;
512 color32 |= (color32 >> 5) & 0x070707;
513 color = color32;
514#elif COLOR_5_6_5
515 uint16_t color16 = 0;
516 color16 |= (color & 0x001F) << 11;
517 color16 |= (color & 0x03E0) << 1;
518 color16 |= (color & 0x7C00) >> 10;
519 color = color16;
520#endif
521 softwareRenderer->engA.row[x] = color;
522 }
523 break;
524 }
525 case 3:
526 break;
527 }
528
529#ifdef COLOR_16_BIT
530#if defined(__ARM_NEON) && !defined(__APPLE__)
531 _to16Bit(row, softwareRenderer->engA.row, DS_VIDEO_HORIZONTAL_PIXELS);
532#else
533 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
534 row[x] = softwareRenderer->engA.row[x];
535 }
536#endif
537#else
538 switch (softwareRenderer->engA.masterBright) {
539 case 0:
540 default:
541 memcpy(row, softwareRenderer->engA.row, softwareRenderer->engA.masterEnd * sizeof(*row));
542 break;
543 case 1:
544 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
545 row[x] = _brighten(softwareRenderer->engA.row[x], softwareRenderer->engA.masterBrightY);
546 }
547 break;
548 case 2:
549 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
550 row[x] = _darken(softwareRenderer->engA.row[x], softwareRenderer->engA.masterBrightY);
551 }
552 break;
553 }
554#endif
555}
556
557static void _drawScanlineB(struct DSVideoSoftwareRenderer* softwareRenderer, int y) {
558 memcpy(softwareRenderer->engB.d.vramBG, softwareRenderer->d.vramBBG, sizeof(softwareRenderer->engB.d.vramBG));
559 memcpy(softwareRenderer->engB.d.vramOBJ, softwareRenderer->d.vramBOBJ, sizeof(softwareRenderer->engB.d.vramOBJ));
560 color_t* row = &softwareRenderer->engB.outputBuffer[softwareRenderer->outputBufferStride * y];
561
562 int x;
563 switch (DSRegisterDISPCNTGetDispMode(softwareRenderer->dispcntB)) {
564 case 0:
565 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
566 row[x] = GBA_COLOR_WHITE;
567 }
568 return;
569 case 1:
570 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engB.d, NULL, y);
571 break;
572 }
573
574#ifdef COLOR_16_BIT
575#if defined(__ARM_NEON) && !defined(__APPLE__)
576 _to16Bit(row, softwareRenderer->engB.row, DS_VIDEO_HORIZONTAL_PIXELS);
577#else
578 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
579 row[x] = softwareRenderer->engB.row[x];
580 }
581#endif
582#else
583 switch (softwareRenderer->engB.masterBright) {
584 case 0:
585 default:
586 memcpy(row, softwareRenderer->engB.row, softwareRenderer->engB.masterEnd * sizeof(*row));
587 break;
588 case 1:
589 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
590 row[x] = _brighten(softwareRenderer->engB.row[x], softwareRenderer->engB.masterBrightY);
591 }
592 break;
593 case 2:
594 for (x = 0; x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
595 row[x] = _darken(softwareRenderer->engB.row[x], softwareRenderer->engB.masterBrightY);
596 }
597 break;
598 }
599#endif
600}
601
602static void DSVideoSoftwareRendererDrawScanline(struct DSVideoRenderer* renderer, int y) {
603 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
604 if (!DSRegisterPOWCNT1IsSwap(softwareRenderer->powcnt)) {
605 softwareRenderer->engA.outputBuffer = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * DS_VIDEO_VERTICAL_PIXELS];
606 softwareRenderer->engB.outputBuffer = softwareRenderer->outputBuffer;
607 } else {
608 softwareRenderer->engA.outputBuffer = softwareRenderer->outputBuffer;
609 softwareRenderer->engB.outputBuffer = &softwareRenderer->outputBuffer[softwareRenderer->outputBufferStride * DS_VIDEO_VERTICAL_PIXELS];
610 }
611
612 _drawScanlineA(softwareRenderer, y);
613 _drawScanlineB(softwareRenderer, y);
614}
615
616static void DSVideoSoftwareRendererDrawScanlineDirectly(struct DSVideoRenderer* renderer, int y, color_t* scanline) {
617 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
618 DSVideoSoftwareRendererDrawGBAScanline(&softwareRenderer->engA.d, softwareRenderer->d.gx, y);
619 memcpy(scanline, softwareRenderer->engA.row, softwareRenderer->engA.masterEnd * sizeof(*scanline));
620}
621
622static void DSVideoSoftwareRendererFinishFrame(struct DSVideoRenderer* renderer) {
623 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
624 softwareRenderer->engA.d.finishFrame(&softwareRenderer->engA.d);
625 softwareRenderer->engB.d.finishFrame(&softwareRenderer->engB.d);
626}
627
628static void DSVideoSoftwareRendererGetPixels(struct DSVideoRenderer* renderer, size_t* stride, const void** pixels) {
629 struct DSVideoSoftwareRenderer* softwareRenderer = (struct DSVideoSoftwareRenderer*) renderer;
630#ifdef COLOR_16_BIT
631#error Not yet supported
632#else
633 *stride = softwareRenderer->outputBufferStride;
634 *pixels = softwareRenderer->outputBuffer;
635#endif
636}
637
638static void DSVideoSoftwareRendererPutPixels(struct DSVideoRenderer* renderer, size_t stride, const void* pixels) {
639}
640
641#define EXT_0_COORD_OVERFLOW \
642 localX = x & (sizeAdjusted - 1); \
643 localY = y & (sizeAdjusted - 1); \
644
645#define EXT_0_COORD_NO_OVERFLOW \
646 if ((x | y) & ~(sizeAdjusted - 1)) { \
647 continue; \
648 } \
649 localX = x; \
650 localY = y;
651
652#define EXT_0_NO_MOSAIC(COORD) \
653 COORD \
654 uint32_t screenBase = background->screenBase + (localX >> 10) + (((localY >> 6) & 0xFE0) << background->size); \
655 uint16_t* screenBlock = renderer->d.vramBG[screenBase >> VRAM_BLOCK_OFFSET]; \
656 if (UNLIKELY(!screenBlock)) { \
657 continue; \
658 } \
659 LOAD_16(mapData, screenBase & (VRAM_BLOCK_MASK - 1), screenBlock); \
660 paletteData = GBA_TEXT_MAP_PALETTE(mapData) << 8; \
661 palette = &mainPalette[paletteData]; \
662 if (GBA_TEXT_MAP_VFLIP(mapData)) { \
663 localY = 0x7FF - localY; \
664 } \
665 if (GBA_TEXT_MAP_HFLIP(mapData)) { \
666 localX = 0x7FF - localX; \
667 } \
668 uint32_t charBase = (background->charBase + (GBA_TEXT_MAP_TILE(mapData) << 6)) + ((localY & 0x700) >> 5) + ((localX & 0x700) >> 8); \
669 uint16_t* vram = renderer->d.vramBG[charBase >> VRAM_BLOCK_OFFSET]; \
670 if (UNLIKELY(!vram)) { \
671 continue; \
672 } \
673 pixelData = ((uint8_t*) vram)[charBase & VRAM_BLOCK_MASK];
674
675#define EXT_0_MOSAIC(COORD) \
676 if (!mosaicWait) { \
677 EXT_0_NO_MOSAIC(COORD) \
678 mosaicWait = mosaicH; \
679 } else { \
680 --mosaicWait; \
681 }
682
683#define EXT_0_LOOP(MOSAIC, COORD, BLEND, OBJWIN) \
684 for (outX = renderer->start, pixel = &renderer->row[outX]; outX < renderer->end; ++outX, ++pixel) { \
685 x += background->dx; \
686 y += background->dy; \
687 \
688 uint32_t current = *pixel; \
689 MOSAIC(COORD) \
690 if (pixelData) { \
691 COMPOSITE_256_ ## OBJWIN (BLEND, 0); \
692 } \
693 }
694
695#define DRAW_BACKGROUND_EXT_0(BLEND, OBJWIN) \
696 if (background->overflow) { \
697 if (mosaicH > 1) { \
698 EXT_0_LOOP(EXT_0_MOSAIC, EXT_0_COORD_OVERFLOW, BLEND, OBJWIN); \
699 } else { \
700 EXT_0_LOOP(EXT_0_NO_MOSAIC, EXT_0_COORD_OVERFLOW, BLEND, OBJWIN); \
701 } \
702 } else { \
703 if (mosaicH > 1) { \
704 EXT_0_LOOP(EXT_0_MOSAIC, EXT_0_COORD_NO_OVERFLOW, BLEND, OBJWIN); \
705 } else { \
706 EXT_0_LOOP(EXT_0_NO_MOSAIC, EXT_0_COORD_NO_OVERFLOW, BLEND, OBJWIN); \
707 } \
708 }
709
710void DSVideoSoftwareRendererDrawBackgroundExt0(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
711 int sizeAdjusted = 0x8000 << background->size;
712
713 BACKGROUND_BITMAP_INIT;
714
715 color_t* mainPalette = background->extPalette;
716 if (variant) {
717 mainPalette = background->variantPalette;
718 }
719 if (!mainPalette) {
720 return;
721 }
722 int paletteData;
723
724 uint16_t mapData;
725 uint8_t pixelData = 0;
726
727 int outX;
728 uint32_t* pixel;
729
730 if (!objwinSlowPath) {
731 if (!(flags & FLAG_TARGET_2)) {
732 DRAW_BACKGROUND_EXT_0(NoBlend, NO_OBJWIN);
733 } else {
734 DRAW_BACKGROUND_EXT_0(Blend, NO_OBJWIN);
735 }
736 } else {
737 if (!(flags & FLAG_TARGET_2)) {
738 DRAW_BACKGROUND_EXT_0(NoBlend, OBJWIN);
739 } else {
740 DRAW_BACKGROUND_EXT_0(Blend, OBJWIN);
741 }
742 }
743}
744
745void DSVideoSoftwareRendererDrawBackgroundExt1(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
746 BACKGROUND_BITMAP_INIT;
747
748 uint8_t color;
749 int width, height;
750 switch (background->size) {
751 case 0:
752 width = 128;
753 height = 128;
754 break;
755 case 1:
756 width = 256;
757 height = 256;
758 break;
759 case 2:
760 width = 512;
761 height = 256;
762 break;
763 case 3:
764 width = 512;
765 height = 512;
766 break;
767 }
768
769 int outX;
770 for (outX = renderer->start; outX < renderer->end; ++outX) {
771 BACKGROUND_BITMAP_ITERATE(width, height);
772
773 if (!mosaicWait) {
774 uint32_t address = (localX >> 8) + (localY >> 8) * width;
775 uint8_t* vram = (uint8_t*) renderer->d.vramBG[address >> 17];
776 if (UNLIKELY(!vram)) {
777 continue;
778 }
779 color = vram[address];
780 mosaicWait = mosaicH;
781 } else {
782 --mosaicWait;
783 }
784
785 uint32_t current = renderer->row[outX];
786 if (color && IS_WRITABLE(current)) {
787 if (!objwinSlowPath) {
788 _compositeBlendNoObjwin(renderer, outX, palette[color] | flags, current);
789 } else if (objwinForceEnable || (!(current & FLAG_OBJWIN)) == objwinOnly) {
790 color_t* currentPalette = (current & FLAG_OBJWIN) ? objwinPalette : palette;
791 unsigned mergedFlags = flags;
792 if (current & FLAG_OBJWIN) {
793 mergedFlags = objwinFlags;
794 }
795 _compositeBlendObjwin(renderer, outX, currentPalette[color] | mergedFlags, current);
796 }
797 }
798 }
799}
800
801void DSVideoSoftwareRendererDrawBackgroundExt2(struct GBAVideoSoftwareRenderer* renderer, struct GBAVideoSoftwareBackground* background, int inY) {
802 BACKGROUND_BITMAP_INIT;
803
804 uint32_t color;
805 int width, height;
806 switch (background->size) {
807 case 0:
808 width = 128;
809 height = 128;
810 break;
811 case 1:
812 width = 256;
813 height = 256;
814 break;
815 case 2:
816 width = 512;
817 height = 256;
818 break;
819 case 3:
820 width = 512;
821 height = 512;
822 break;
823 }
824
825 int outX;
826 for (outX = renderer->start; outX < renderer->end; ++outX) {
827 BACKGROUND_BITMAP_ITERATE(width, height);
828
829 if (!mosaicWait) {
830 uint32_t address = ((localX >> 8) + (localY >> 8) * width) << 1;
831 uint16_t* vram = renderer->d.vramBG[address >> 17];
832 if (UNLIKELY(!vram)) {
833 continue;
834 }
835 LOAD_16(color, address & 0x1FFFE, vram);
836#ifndef COLOR_16_BIT
837 unsigned color32;
838 color32 = 0;
839 color32 |= (color << 3) & 0xF8;
840 color32 |= (color << 6) & 0xF800;
841 color32 |= (color << 9) & 0xF80000;
842 color32 |= (color32 >> 5) & 0x070707;
843 color = color32;
844#elif COLOR_5_6_5
845 uint16_t color16 = 0;
846 color16 |= (color & 0x001F) << 11;
847 color16 |= (color & 0x03E0) << 1;
848 color16 |= (color & 0x7C00) >> 10;
849 color = color16;
850#endif
851 mosaicWait = mosaicH;
852 } else {
853 --mosaicWait;
854 }
855
856 uint32_t current = renderer->row[outX];
857 if (!objwinSlowPath || (!(current & FLAG_OBJWIN)) != objwinOnly) {
858 unsigned mergedFlags = flags;
859 if (current & FLAG_OBJWIN) {
860 mergedFlags = objwinFlags;
861 }
862 if (!variant) {
863 _compositeBlendObjwin(renderer, outX, color | mergedFlags, current);
864 } else if (renderer->blendEffect == BLEND_BRIGHTEN) {
865 _compositeBlendObjwin(renderer, outX, _brighten(color, renderer->bldy) | mergedFlags, current);
866 } else if (renderer->blendEffect == BLEND_DARKEN) {
867 _compositeBlendObjwin(renderer, outX, _darken(color, renderer->bldy) | mergedFlags, current);
868 }
869 }
870 }
871}