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