src/ds/gx/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/gx/software.h>
7
8#include <mgba-util/memory.h>
9#include <mgba/internal/ds/io.h>
10#include "gba/renderers/software-private.h"
11
12DEFINE_VECTOR(DSGXSoftwarePolygonList, struct DSGXSoftwarePolygon);
13DEFINE_VECTOR(DSGXSoftwareEdgeList, struct DSGXSoftwareEdge);
14
15static void DSGXSoftwareRendererInit(struct DSGXRenderer* renderer);
16static void DSGXSoftwareRendererReset(struct DSGXRenderer* renderer);
17static void DSGXSoftwareRendererDeinit(struct DSGXRenderer* renderer);
18static void DSGXSoftwareRendererInvalidateTex(struct DSGXRenderer* renderer, int slot);
19static void DSGXSoftwareRendererSetRAM(struct DSGXRenderer* renderer, struct DSGXVertex* verts, struct DSGXPolygon* polys, unsigned polyCount, bool wSort);
20static void DSGXSoftwareRendererDrawScanline(struct DSGXRenderer* renderer, int y);
21static void DSGXSoftwareRendererGetScanline(struct DSGXRenderer* renderer, int y, const color_t** output);
22static void DSGXSoftwareRendererWriteRegister(struct DSGXRenderer* renderer, uint32_t address, uint16_t value);
23
24static void _expandColor(uint16_t c15, uint8_t* r, uint8_t* g, uint8_t* b) {
25 *r = ((c15 << 1) & 0x3E) | 1;
26 *g = ((c15 >> 4) & 0x3E) | 1;
27 *b = ((c15 >> 9) & 0x3E) | 1;
28}
29
30static color_t _finishColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
31#ifndef COLOR_16_BIT
32 color_t rgba = (r << 2) & 0xFC;
33 rgba |= (g << 10) & 0xFC00;
34 rgba |= (b << 18) & 0xFC0000;
35 rgba |= (a << 26) & 0xF8000000;
36 return rgba;
37#else
38#error Unsupported color depth
39#endif
40}
41
42static unsigned _mix32(int weightA, unsigned colorA, int weightB, unsigned colorB) {
43 unsigned c = 0;
44 unsigned a, b;
45#ifdef COLOR_16_BIT
46#error Unsupported color depth
47#else
48 a = colorA & 0xFF;
49 b = colorB & 0xFF;
50 c |= ((a * weightA + b * weightB) / 32) & 0x1FF;
51 if (c & 0x00000100) {
52 c = 0x000000FF;
53 }
54
55 a = colorA & 0xFF00;
56 b = colorB & 0xFF00;
57 c |= ((a * weightA + b * weightB) / 32) & 0x1FF00;
58 if (c & 0x00010000) {
59 c = (c & 0x000000FF) | 0x0000FF00;
60 }
61
62 a = colorA & 0xFF0000;
63 b = colorB & 0xFF0000;
64 c |= ((a * weightA + b * weightB) / 32) & 0x1FF0000;
65 if (c & 0x01000000) {
66 c = (c & 0x0000FFFF) | 0x00FF0000;
67 }
68#endif
69 return c;
70}
71
72static unsigned _mixTexels(int weightA, unsigned colorA, int weightB, unsigned colorB) {
73 unsigned c = 0;
74 unsigned a, b;
75 a = colorA & 0x7C1F;
76 b = colorB & 0x7C1F;
77 a |= (colorA & 0x3E0) << 16;
78 b |= (colorB & 0x3E0) << 16;
79 c = ((a * weightA + b * weightB) / 8);
80 if (c & 0x04000000) {
81 c = (c & ~0x07E00000) | 0x03E00000;
82 }
83 if (c & 0x0020) {
84 c = (c & ~0x003F) | 0x001F;
85 }
86 if (c & 0x8000) {
87 c = (c & ~0xF800) | 0x7C00;
88 }
89 c = (c & 0x7C1F) | ((c >> 16) & 0x03E0);
90 return c;
91}
92
93static color_t _lookupColor(struct DSGXSoftwareRenderer* renderer, struct DSGXSoftwareEndpoint* ep, struct DSGXSoftwarePolygon* poly) {
94 if (!poly->texBase && poly->texFormat) {
95 return 0;
96 }
97 // TODO: Optimize
98 uint16_t texel;
99
100 int16_t s = ep->s >> 4;
101 int16_t t = ep->t >> 4;
102 if (!DSGXTexParamsIsSRepeat(poly->texParams)) {
103 if (s < 0) {
104 s = 0;
105 } else if (s >= poly->texW) {
106 s = poly->texW - 1;
107 }
108 } else if (DSGXTexParamsIsSMirror(poly->texParams)) {
109 if (s & poly->texW) {
110 s = poly->texW - s - 1;
111 }
112 s &= poly->texW - 1;
113 } else {
114 s &= poly->texW - 1;
115 }
116 if (!DSGXTexParamsIsTRepeat(poly->texParams)) {
117 if (t < 0) {
118 t = 0;
119 } else if (t >= poly->texH) {
120 t = poly->texW - 1;
121 }
122 } else if (DSGXTexParamsIsTMirror(poly->texParams)) {
123 if (t & poly->texH) {
124 t = poly->texH - t - 1;
125 }
126 t &= poly->texH - 1;
127 } else {
128 t &= poly->texH - 1;
129 }
130
131 uint16_t texelCoord = s + t * poly->texW;
132 uint8_t ta = 0x1F;
133 uint8_t pa = DSGXPolygonAttrsGetAlpha(poly->polyParams);
134 if (pa) {
135 pa = (pa << 1) + 1;
136 }
137 switch (poly->texFormat) {
138 case 0:
139 default:
140 return _finishColor(ep->cr, ep->cg, ep->cb, pa);
141 case 1:
142 texel = ((uint8_t*) poly->texBase)[texelCoord];
143 ta = (texel >> 5) & 0x7;
144 ta = (ta << 2) + (ta >> 1);
145 texel &= 0x1F;
146 break;
147 case 2:
148 texel = ((uint8_t*) poly->texBase)[texelCoord >> 2];
149 if (texelCoord & 0x3) {
150 texel >>= 2 * texel & 3;
151 }
152 texel &= 0x3;
153 break;
154 case 3:
155 texel = ((uint8_t*) poly->texBase)[texelCoord >> 1];
156 if (texelCoord & 0x1) {
157 texel >>= 4;
158 }
159 texel &= 0xF;
160 break;
161 case 4:
162 texel = ((uint8_t*) poly->texBase)[texelCoord];
163 break;
164 case 5:
165 texelCoord = (s & ~3) + (t & 3) + (t >> 2) * poly->texW;
166 texel = ((uint8_t*) poly->texBase)[texelCoord];
167 texel >>= (s & 3) * 2;
168 texel &= 3;
169 break;
170 case 6:
171 texel = ((uint8_t*) poly->texBase)[texelCoord];
172 ta = (texel >> 3) & 0x1F;
173 texel &= 0x7;
174 break;
175 case 7:
176 texel = poly->texBase[texelCoord];
177 break;
178 }
179 uint8_t r, g, b;
180 unsigned wr, wg, wb, wa;
181 if (poly->texFormat == 5) {
182 if (!renderer->d.tex[1]) {
183 return 0;
184 }
185 uint16_t half = DSGXTexParamsGetVRAMBase(poly->texParams) & 0x8000;
186 uint32_t slot1Base = (DSGXTexParamsGetVRAMBase(poly->texParams) << 1) + (texelCoord >> 2) + half;
187 uint16_t texel2 = renderer->d.tex[1][slot1Base];
188 uint16_t texel2Base = (texel2 & 0x3FFF) << 1;
189 int a = 0x8;
190 int b = 0;
191 switch (texel2 >> 14) {
192 case 0:
193 if (texel == 3) {
194 ta = 0;
195 }
196 texel = poly->palBase[texel + texel2Base];
197 break;
198 case 1:
199 if (texel == 3) {
200 ta = 0;
201 }
202 if (texel != 2) {
203 texel = poly->palBase[texel + texel2Base];
204 } else {
205 texel = poly->palBase[texel2Base];
206 texel2 = poly->palBase[texel2Base + 1];
207 a = 4;
208 b = 4;
209 }
210 break;
211 case 2:
212 texel = poly->palBase[texel + texel2Base];
213 break;
214 case 3:
215 switch (texel) {
216 case 0:
217 case 1:
218 texel = poly->palBase[texel + texel2Base];
219 break;
220 case 2:
221 texel = poly->palBase[texel2Base];
222 texel2 = poly->palBase[texel2Base + 1];
223 a = 5;
224 b = 3;
225 break;
226 case 3:
227 texel = poly->palBase[texel2Base];
228 texel2 = poly->palBase[texel2Base + 1];
229 a = 3;
230 b = 5;
231 break;
232 }
233 break;
234 }
235 if (b) {
236 texel = _mixTexels(a, texel, b, texel2);
237 }
238 } else if (poly->texFormat != 7) {
239 if (poly->texFormat < 5 && poly->texFormat > 1 && DSGXTexParamsIs0Transparent(poly->texParams) && !texel) {
240 return 0;
241 }
242 texel = poly->palBase[texel];
243 }
244 _expandColor(texel, &r, &g, &b);
245 if (ta) {
246 ta = (ta << 1) + 1;
247 }
248 switch (poly->blendFormat) {
249 default:
250 case 0:
251 wr = ((r + 1) * (ep->cr + 1) - 1) >> 6;
252 wg = ((g + 1) * (ep->cg + 1) - 1) >> 6;
253 wb = ((b + 1) * (ep->cb + 1) - 1) >> 6;
254 wa = ((ta + 1) * (pa + 1) - 1) >> 6;
255 return _finishColor(wr, wg, wb, wa);
256 case 1:
257 wr = (r * ta + ep->cr * (63 - ta)) >> 6;
258 wg = (g * ta + ep->cg * (63 - ta)) >> 6;
259 wb = (b * ta + ep->cb * (63 - ta)) >> 6;
260 return _finishColor(wr, wg, wb, pa);
261 case 3:
262 return _finishColor(r, g, b, pa);
263 }
264}
265
266static inline int32_t _interpolate(int32_t x0, int32_t x1, int64_t w0, int64_t w1, int64_t w, int32_t qr) {
267 // 32-bit -> 96-bit
268 int64_t x0b = (w0 & 0xFFFFFFFF) * x0;
269 int64_t x0t = (w0 >> 32) * x0;
270 int64_t x1b = (w1 & 0xFFFFFFFF) * x1;
271 int64_t x1t = (w1 >> 32) * x1;
272 // 96-bit -> 64-bit
273 int64_t xx0 = (x0t << 32) + x0b;
274 int64_t xx1 = (x1t << 32) + x1b;
275 xx1 -= xx0;
276 xx1 >>= 12;
277
278 int64_t qrb = xx1 * qr;
279 qrb += xx0;
280
281 return qrb / w;
282}
283
284static inline int32_t _divideBy(int64_t x, int32_t recip) {
285 int64_t x0 = (x & 0xFFFFFFFF) * recip;
286 int64_t x1 = (x >> 32) * recip;
287 x1 += x0 >> 32;
288 return x1 >> 31;
289}
290
291static bool _edgeToSpan(struct DSGXSoftwareSpan* span, const struct DSGXSoftwareEdge* edge, int index, int32_t y) {
292 int32_t height = edge->y1 - edge->y0;
293 int64_t yw = y - edge->y0;
294 if (!height) {
295 return false;
296 }
297 // Clamp to bounds
298 if (yw < 0) {
299 return false;
300 } else if (yw > height) {
301 return false;
302 }
303
304 span->ep[index].coord[0] = (((int64_t) (edge->x1 - edge->x0) * yw) / height) + edge->x0;
305
306 if (index) {
307 if (span->ep[0].coord[0] == span->ep[index].coord[0]) {
308 return false;
309 }
310 if (span->ep[0].coord[0] > span->ep[index].coord[0]) {
311 int32_t temp = span->ep[index].coord[0];
312 span->ep[index] = span->ep[0];
313 span->ep[0].coord[0] = temp;
314 index = 0;
315 }
316 }
317
318 int64_t w0 = edge->wr0;
319 int64_t w1 = edge->wr1;
320 int64_t w = w1 - w0;
321
322 // Losslessly interpolate two 64-bit values
323 int64_t wb = (w & 0xFFFFFFFF) * yw;
324 int64_t wt = (w >> 32) * yw;
325 int64_t div = wt / height;
326 int64_t rem = wt % height;
327 w = div << 32;
328 wb += rem << 32;
329 div = wb / height;
330 w += div;
331 w += w0;
332
333 span->ep[index].coord[3] = (0x7FFFFFFFFFFFFFFF / w) + 1;
334 span->ep[index].wRecip = w;
335 int32_t qr = (yw << 12) / height;
336
337 span->ep[index].coord[2] = _interpolate(edge->z0, edge->z1, w0, w1, w, qr);
338 span->ep[index].cr = _interpolate(edge->cr0, edge->cr1, w0, w1, w, qr);
339 span->ep[index].cg = _interpolate(edge->cg0, edge->cg1, w0, w1, w, qr);
340 span->ep[index].cb = _interpolate(edge->cb0, edge->cb1, w0, w1, w, qr);
341 span->ep[index].s = _interpolate(edge->s0, edge->s1, w0, w1, w, qr);
342 span->ep[index].t = _interpolate(edge->t0, edge->t1, w0, w1, w, qr);
343
344 return true;
345}
346
347static void _createStep(struct DSGXSoftwareSpan* span) {
348 int32_t width = (span->ep[1].coord[0] - span->ep[0].coord[0]) >> 7;
349
350 span->ep[0].stepW = span->ep[0].wRecip;
351 span->ep[0].stepZ = span->ep[0].coord[2] * span->ep[0].wRecip;
352 span->ep[0].stepR = span->ep[0].cr * span->ep[0].wRecip;
353 span->ep[0].stepG = span->ep[0].cg * span->ep[0].wRecip;
354 span->ep[0].stepB = span->ep[0].cb * span->ep[0].wRecip;
355 span->ep[0].stepS = span->ep[0].s * span->ep[0].wRecip;
356 span->ep[0].stepT = span->ep[0].t * span->ep[0].wRecip;
357
358 span->ep[1].stepW = span->ep[1].wRecip;
359 span->ep[1].stepZ = span->ep[1].coord[2] * span->ep[1].wRecip;
360 span->ep[1].stepR = span->ep[1].cr * span->ep[1].wRecip;
361 span->ep[1].stepG = span->ep[1].cg * span->ep[1].wRecip;
362 span->ep[1].stepB = span->ep[1].cb * span->ep[1].wRecip;
363 span->ep[1].stepS = span->ep[1].s * span->ep[1].wRecip;
364 span->ep[1].stepT = span->ep[1].t * span->ep[1].wRecip;
365
366 if (!width) {
367 return;
368 }
369 span->step.coord[0] = span->ep[1].coord[0] - span->ep[0].coord[0];
370 span->step.stepW = ((span->ep[1].stepW - span->ep[0].stepW) / width) << 5;
371 span->step.stepZ = ((span->ep[1].stepZ - span->ep[0].stepZ) / width) << 5;
372 span->step.stepR = ((span->ep[1].stepR - span->ep[0].stepR) / width) << 5;
373 span->step.stepG = ((span->ep[1].stepG - span->ep[0].stepG) / width) << 5;
374 span->step.stepB = ((span->ep[1].stepB - span->ep[0].stepB) / width) << 5;
375 span->step.stepS = ((span->ep[1].stepS - span->ep[0].stepS) / width) << 5;
376 span->step.stepT = ((span->ep[1].stepT - span->ep[0].stepT) / width) << 5;
377}
378
379static void _stepEndpoint(struct DSGXSoftwareSpan* span) {
380 int32_t nextX = (span->ep[0].coord[0] & ~0xFFF) + 0x1000;
381 span->ep[0].coord[0] = nextX;
382
383 span->ep[0].wRecip += span->step.stepW;
384 span->ep[0].coord[3] = (0x7FFFFFFFFFFFFFFF / span->ep[0].wRecip) + 1;
385
386 span->ep[0].stepZ += span->step.stepZ;
387 span->ep[0].coord[2] = _divideBy(span->ep[0].stepZ, span->ep[0].coord[3]);
388
389 span->ep[0].stepR += span->step.stepR;
390 span->ep[0].stepG += span->step.stepG;
391 span->ep[0].stepB += span->step.stepB;
392 span->ep[0].stepS += span->step.stepS;
393 span->ep[0].stepT += span->step.stepT;
394}
395
396static void _resolveEndpoint(struct DSGXSoftwareSpan* span) {
397 span->ep[0].cr = _divideBy(span->ep[0].stepR, span->ep[0].coord[3]);
398 span->ep[0].cg = _divideBy(span->ep[0].stepG, span->ep[0].coord[3]);
399 span->ep[0].cb = _divideBy(span->ep[0].stepB, span->ep[0].coord[3]);
400 span->ep[0].s = _divideBy(span->ep[0].stepS, span->ep[0].coord[3]);
401 span->ep[0].t = _divideBy(span->ep[0].stepT, span->ep[0].coord[3]);
402}
403
404void DSGXSoftwareRendererCreate(struct DSGXSoftwareRenderer* renderer) {
405 renderer->d.init = DSGXSoftwareRendererInit;
406 renderer->d.reset = DSGXSoftwareRendererReset;
407 renderer->d.deinit = DSGXSoftwareRendererDeinit;
408 renderer->d.invalidateTex = DSGXSoftwareRendererInvalidateTex;
409 renderer->d.setRAM = DSGXSoftwareRendererSetRAM;
410 renderer->d.drawScanline = DSGXSoftwareRendererDrawScanline;
411 renderer->d.getScanline = DSGXSoftwareRendererGetScanline;
412 renderer->d.writeRegister = DSGXSoftwareRendererWriteRegister;
413}
414
415static void DSGXSoftwareRendererInit(struct DSGXRenderer* renderer) {
416 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
417 DSGXSoftwarePolygonListInit(&softwareRenderer->activePolys, DS_GX_POLYGON_BUFFER_SIZE / 4);
418 DSGXSoftwareEdgeListInit(&softwareRenderer->activeEdges, 16);
419 softwareRenderer->scanlineCache = anonymousMemoryMap(sizeof(color_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
420 softwareRenderer->depthBuffer = anonymousMemoryMap(sizeof(int32_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
421 softwareRenderer->stencilBuffer = anonymousMemoryMap(sizeof(uint8_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
422}
423
424static void DSGXSoftwareRendererReset(struct DSGXRenderer* renderer) {
425 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
426 softwareRenderer->clearColor = 0;
427 softwareRenderer->clearStencil = 0;
428}
429
430static void DSGXSoftwareRendererDeinit(struct DSGXRenderer* renderer) {
431 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
432 DSGXSoftwarePolygonListDeinit(&softwareRenderer->activePolys);
433 DSGXSoftwareEdgeListDeinit(&softwareRenderer->activeEdges);
434 mappedMemoryFree(softwareRenderer->scanlineCache, sizeof(color_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
435 mappedMemoryFree(softwareRenderer->depthBuffer, sizeof(int32_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
436 mappedMemoryFree(softwareRenderer->stencilBuffer, sizeof(uint8_t) * DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS);
437}
438
439static void DSGXSoftwareRendererInvalidateTex(struct DSGXRenderer* renderer, int slot) {
440 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
441 // TODO
442}
443
444static void _preparePoly(struct DSGXRenderer* renderer, struct DSGXVertex* verts, struct DSGXSoftwarePolygon* poly) {
445 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
446 struct DSGXSoftwareEdge* edge = DSGXSoftwareEdgeListAppend(&softwareRenderer->activeEdges);
447 poly->texParams = poly->poly->texParams;
448 poly->polyParams = poly->poly->polyParams;
449 poly->texFormat = DSGXTexParamsGetFormat(poly->texParams);
450 poly->blendFormat = DSGXPolygonAttrsGetMode(poly->polyParams);
451 poly->texW = 8 << DSGXTexParamsGetSSize(poly->texParams);
452 poly->texH = 8 << DSGXTexParamsGetTSize(poly->texParams);
453 if (!renderer->tex[DSGXTexParamsGetVRAMBase(poly->texParams) >> VRAM_BLOCK_OFFSET]) {
454 poly->texBase = NULL;
455 poly->palBase = NULL;
456 } else {
457 switch (poly->texFormat) {
458 case 0:
459 poly->texBase = NULL;
460 poly->palBase = NULL;
461 break;
462 case 2:
463 poly->texBase = &renderer->tex[DSGXTexParamsGetVRAMBase(poly->poly->texParams) >> VRAM_BLOCK_OFFSET][(DSGXTexParamsGetVRAMBase(poly->poly->texParams) << 2) & 0xFFFF];
464 poly->palBase = &renderer->texPal[poly->poly->palBase >> 11][(poly->poly->palBase << 2) & 0x1FFF];
465 break;
466 default:
467 poly->texBase = &renderer->tex[DSGXTexParamsGetVRAMBase(poly->poly->texParams) >> VRAM_BLOCK_OFFSET][(DSGXTexParamsGetVRAMBase(poly->poly->texParams) << 2) & 0xFFFF];
468 poly->palBase = &renderer->texPal[poly->poly->palBase >> 10][(poly->poly->palBase << 3) & 0x1FFF];
469 break;
470 }
471 }
472 edge->polyId = poly->polyId;
473 poly->minY = DS_VIDEO_VERTICAL_PIXELS - 1;
474 poly->maxY = 0;
475
476 struct DSGXVertex* v0 = &verts[poly->poly->vertIds[0]];
477 struct DSGXVertex* v1;
478
479 int32_t v0w = v0->viewCoord[3];
480 if (!v0w) {
481 v0w = 1;
482 }
483
484 int32_t v0x = (v0->viewCoord[0] + v0w) * (int64_t) (renderer->viewportWidth << 12) / (v0w * 2) + (renderer->viewportX << 12);
485 int32_t v0y = (-v0->viewCoord[1] + v0w) * (int64_t) (renderer->viewportHeight << 12) / (v0w * 2) + (renderer->viewportY << 12);
486 if (poly->minY > v0y >> 12) {
487 poly->minY = v0y >> 12;
488 }
489 if (poly->maxY < v0y >> 12) {
490 poly->maxY = v0y >> 12;
491 }
492
493 int v;
494 for (v = 1; v < poly->poly->verts; ++v) {
495 v1 = &verts[poly->poly->vertIds[v]];
496
497 int32_t v1w = v1->viewCoord[3];
498 if (!v1w) {
499 v1w = 1;
500 }
501 int32_t v1x = (v1->viewCoord[0] + v1w) * (int64_t) (renderer->viewportWidth << 12) / (v1w * 2) + (renderer->viewportX << 12);
502 int32_t v1y = (-v1->viewCoord[1] + v1w) * (int64_t) (renderer->viewportHeight << 12) / (v1w * 2) + (renderer->viewportY << 12);
503 if (poly->minY > v1y >> 12) {
504 poly->minY = v1y >> 12;
505 }
506 if (poly->maxY < v1y >> 12) {
507 poly->maxY = v1y >> 12;
508 }
509
510 if (v0y <= v1y) {
511 edge->y0 = v0y;
512 edge->x0 = v0x;
513 edge->z0 = v0->viewCoord[2];
514 edge->w0 = v0w;
515 _expandColor(v0->color, &edge->cr0, &edge->cg0, &edge->cb0);
516 edge->s0 = v0->vs;
517 edge->t0 = v0->vt;
518
519 edge->y1 = v1y;
520 edge->x1 = v1x;
521 edge->z1 = v1->viewCoord[2];
522 edge->w1 = v1w;
523 _expandColor(v1->color, &edge->cr1, &edge->cg1, &edge->cb1);
524 edge->s1 = v1->vs;
525 edge->t1 = v1->vt;
526 } else {
527 edge->y0 = v1y;
528 edge->x0 = v1x;
529 edge->z0 = v1->viewCoord[2];
530 edge->w0 = v1w;
531 _expandColor(v1->color, &edge->cr0, &edge->cg0, &edge->cb0);
532 edge->s0 = v1->vs;
533 edge->t0 = v1->vt;
534
535 edge->y1 = v0y;
536 edge->x1 = v0x;
537 edge->z1 = v0->viewCoord[2];
538 edge->w1 = v0w;
539 _expandColor(v0->color, &edge->cr1, &edge->cg1, &edge->cb1);
540 edge->s1 = v0->vs;
541 edge->t1 = v0->vt;
542 }
543 edge->wr0 = 0x7FFFFFFFFFFFFFFF / edge->w0;
544 edge->wr1 = 0x7FFFFFFFFFFFFFFF / edge->w1;
545
546 edge = DSGXSoftwareEdgeListAppend(&softwareRenderer->activeEdges);
547 edge->polyId = poly->polyId;
548 v0 = v1;
549 v0x = v1x;
550 v0y = v1y;
551 v0w = v1w;
552 }
553
554 v1 = &verts[poly->poly->vertIds[0]];
555
556 int32_t v1w = v1->viewCoord[3];
557 if (!v1w) {
558 v1w = 1;
559 }
560 int32_t v1x = (v1->viewCoord[0] + v1w) * (int64_t) (renderer->viewportWidth << 12) / (v1w * 2) + (renderer->viewportX << 12);
561 int32_t v1y = (-v1->viewCoord[1] + v1w) * (int64_t) (renderer->viewportHeight << 12) / (v1w * 2) + (renderer->viewportY << 12);
562
563 if (poly->minY > v1y >> 12) {
564 poly->minY = v1y >> 12;
565 }
566 if (poly->maxY < v1y >> 12) {
567 poly->maxY = v1y >> 12;
568 }
569
570 if (v0y <= v1y) {
571 edge->y0 = v0y;
572 edge->x0 = v0x;
573 edge->z0 = v0->viewCoord[2];
574 edge->w0 = v0w;
575 _expandColor(v0->color, &edge->cr0, &edge->cg0, &edge->cb0);
576 edge->s0 = v0->vs;
577 edge->t0 = v0->vt;
578
579 edge->y1 = v1y;
580 edge->x1 = v1x;
581 edge->z1 = v1->viewCoord[2];
582 edge->w1 = v1w;
583 _expandColor(v1->color, &edge->cr1, &edge->cg1, &edge->cb1);
584 edge->s1 = v1->vs;
585 edge->t1 = v1->vt;
586 } else {
587 edge->y0 = v1y;
588 edge->x0 = v1x;
589 edge->z0 = v1->viewCoord[2];
590 edge->w0 = v1w;
591 _expandColor(v1->color, &edge->cr0, &edge->cg0, &edge->cb0);
592 edge->s0 = v1->vs;
593 edge->t0 = v1->vt;
594
595 edge->y1 = v0y;
596 edge->x1 = v0x;
597 edge->z1 = v0->viewCoord[2];
598 edge->w1 = v0w;
599 _expandColor(v0->color, &edge->cr1, &edge->cg1, &edge->cb1);
600 edge->s1 = v0->vs;
601 edge->t1 = v0->vt;
602 }
603 edge->wr0 = 0x7FFFFFFFFFFFFFFF / edge->w0;
604 edge->wr1 = 0x7FFFFFFFFFFFFFFF / edge->w1;
605
606 if (poly->maxY >= DS_VIDEO_VERTICAL_PIXELS) {
607 poly->maxY = DS_VIDEO_VERTICAL_PIXELS - 1;
608 }
609 if (poly->minY < 0) {
610 poly->minY = 0;
611 }
612}
613
614static void _drawSpan(struct DSGXSoftwareRenderer* softwareRenderer, struct DSGXSoftwareSpan* span, int y) {
615 color_t* scanline = &softwareRenderer->scanlineCache[DS_VIDEO_HORIZONTAL_PIXELS * y];
616 int32_t* depth = &softwareRenderer->depthBuffer[DS_VIDEO_HORIZONTAL_PIXELS * y];
617 uint8_t* stencil = &softwareRenderer->stencilBuffer[DS_VIDEO_HORIZONTAL_PIXELS * y];
618 int32_t x = span->ep[0].coord[0] >> 12;
619 if (x < 0) {
620 x = 0;
621 }
622 unsigned stencilValue = span->polyId;
623 if (span->poly->blendFormat == 3) {
624 stencilValue |= 0x40;
625 }
626 for (; x < (span->ep[1].coord[0] >> 12) && x < DS_VIDEO_HORIZONTAL_PIXELS; ++x) {
627 if (span->ep[0].coord[softwareRenderer->sort] < depth[x]) {
628 _resolveEndpoint(span);
629 color_t color = _lookupColor(softwareRenderer, &span->ep[0], span->poly);
630 unsigned a = color >> 27;
631 unsigned current = scanline[x];
632 unsigned b = current >> 27;
633 unsigned ab = a;
634 unsigned s = stencilValue;
635 if (b > ab) {
636 ab = b;
637 }
638 if (a == 0x1F) {
639 if (!(s & 0x40) || (s & 0x3F && !(stencil[x] & 0x40))) {
640 depth[x] = span->ep[0].coord[softwareRenderer->sort];
641 scanline[x] = color;
642 s &= ~0x40;
643 }
644 stencil[x] = s;
645 } else if (a) {
646 // TODO: Disable alpha?
647 if (b) {
648 color = _mix32(a, color, 0x1F - a, current);
649 color |= ab << 27;
650 }
651 if (stencil[x] != s) {
652 if (!(s & 0x40) || (s & 0x3F && !(stencil[x] & 0x40))) {
653 if (DSGXPolygonAttrsIsUpdateDepth(span->poly->poly->polyParams)) {
654 depth[x] = span->ep[0].coord[softwareRenderer->sort];
655 }
656 scanline[x] = color;
657 s &= ~0x40;
658 }
659 stencil[x] = s;
660 }
661 }
662 }
663 _stepEndpoint(span);
664 }
665}
666
667static void DSGXSoftwareRendererSetRAM(struct DSGXRenderer* renderer, struct DSGXVertex* verts, struct DSGXPolygon* polys, unsigned polyCount, bool wSort) {
668 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
669
670 softwareRenderer->sort = wSort ? 3 : 2;
671 softwareRenderer->verts = verts;
672 DSGXSoftwarePolygonListClear(&softwareRenderer->activePolys);
673 size_t i;
674 // Pass 1: Opaque
675 for (i = 0; i < polyCount; ++i) {
676 struct DSGXSoftwarePolygon* poly = NULL;
677 switch (DSGXTexParamsGetFormat(polys[i].texParams)) {
678 default:
679 if (DSGXPolygonAttrsGetAlpha(polys[i].polyParams) == 0x1F) {
680 poly = DSGXSoftwarePolygonListAppend(&softwareRenderer->activePolys);
681 break;
682 }
683 case 1:
684 case 6:
685 break;
686 }
687 if (!poly) {
688 continue;
689 }
690 poly->poly = &polys[i];
691 poly->polyId = DSGXSoftwarePolygonListSize(&softwareRenderer->activePolys) - 1;
692 }
693 // Pass 2: Translucent
694 for (i = 0; i < polyCount; ++i) {
695 struct DSGXSoftwarePolygon* poly = NULL;
696 switch (DSGXTexParamsGetFormat(polys[i].texParams)) {
697 default:
698 if (DSGXPolygonAttrsGetAlpha(polys[i].polyParams) == 0x1F) {
699 break;
700 }
701 case 1:
702 case 6:
703 poly = DSGXSoftwarePolygonListAppend(&softwareRenderer->activePolys);
704 break;
705 }
706 if (!poly) {
707 continue;
708 }
709 poly->poly = &polys[i];
710 poly->polyId = DSGXSoftwarePolygonListSize(&softwareRenderer->activePolys) - 1;
711 }
712
713 color_t clearColor = softwareRenderer->clearColor;
714 uint16_t clearStencil = softwareRenderer->clearStencil;
715
716 for (i = 0; i < DS_VIDEO_VERTICAL_PIXELS * DS_VIDEO_HORIZONTAL_PIXELS ; i += 4) {
717 softwareRenderer->depthBuffer[i] = INT32_MAX;
718 softwareRenderer->depthBuffer[i + 1] = INT32_MAX;
719 softwareRenderer->depthBuffer[i + 2] = INT32_MAX;
720 softwareRenderer->depthBuffer[i + 3] = INT32_MAX;
721 softwareRenderer->scanlineCache[i] = clearColor;
722 softwareRenderer->scanlineCache[i + 1] = clearColor;
723 softwareRenderer->scanlineCache[i + 2] = clearColor;
724 softwareRenderer->scanlineCache[i + 3] = clearColor;
725 softwareRenderer->stencilBuffer[i] = clearStencil;
726 softwareRenderer->stencilBuffer[i + 1] = clearStencil;
727 softwareRenderer->stencilBuffer[i + 2] = clearStencil;
728 softwareRenderer->stencilBuffer[i + 3] = clearStencil;
729 }
730 softwareRenderer->flushPending = true;
731}
732
733static void DSGXSoftwareRendererDrawScanline(struct DSGXRenderer* renderer, int y) {
734 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
735 if (!softwareRenderer->flushPending || y) {
736 return;
737 }
738
739 size_t p;
740 for (p = 0; p < DSGXSoftwarePolygonListSize(&softwareRenderer->activePolys); ++p) {
741 struct DSGXSoftwarePolygon* poly = DSGXSoftwarePolygonListGetPointer(&softwareRenderer->activePolys, p);
742 DSGXSoftwareEdgeListClear(&softwareRenderer->activeEdges);
743 _preparePoly(renderer, softwareRenderer->verts, poly);
744 int y;
745 for (y = poly->minY; y <= poly->maxY; ++y) {
746 struct DSGXSoftwareSpan span = {
747 .poly = poly,
748 .polyId = DSGXPolygonAttrsGetId(poly->polyParams),
749 };
750 size_t i;
751 for (i = 0; i < DSGXSoftwareEdgeListSize(&softwareRenderer->activeEdges); ++i) {
752 struct DSGXSoftwareEdge* edge = DSGXSoftwareEdgeListGetPointer(&softwareRenderer->activeEdges, i);
753 if (edge->y1 < (y << 12)) {
754 continue;
755 } else if (edge->y0 > (y << 12)) {
756 continue;
757 }
758
759 if (span.ep[0].coord[3]) {
760 if (_edgeToSpan(&span, edge, 1, y << 12)) {
761 _createStep(&span);
762 _drawSpan(softwareRenderer, &span, y);
763 }
764 } else if (!_edgeToSpan(&span, edge, 0, y << 12)) {
765 // Horizontal line
766 continue;
767 }
768 }
769 }
770 }
771 softwareRenderer->flushPending = false;
772}
773
774static void DSGXSoftwareRendererGetScanline(struct DSGXRenderer* renderer, int y, const color_t** output) {
775 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
776 *output = &softwareRenderer->scanlineCache[DS_VIDEO_HORIZONTAL_PIXELS * y];
777}
778
779static void DSGXSoftwareRendererWriteRegister(struct DSGXRenderer* renderer, uint32_t address, uint16_t value) {
780 struct DSGXSoftwareRenderer* softwareRenderer = (struct DSGXSoftwareRenderer*) renderer;
781 switch (address) {
782 case DS9_REG_CLEAR_COLOR_LO:
783 softwareRenderer->clearColor &= 0xFF000000;
784 softwareRenderer->clearColor |= (value & 0x001F) << 3;
785 softwareRenderer->clearColor |= (value & 0x03E0) << 6;
786 softwareRenderer->clearColor |= (value & 0x7C00) << 9;
787 break;
788 case DS9_REG_CLEAR_COLOR_HI:
789 softwareRenderer->clearColor &= 0x00FFFFFF;
790 softwareRenderer->clearColor |= (value & 0x001F) << 27;
791 softwareRenderer->clearStencil = (value & 0x3F00) >> 8;
792 break;
793 }
794}