src/gba/renderers/software-obj.c (view raw)
1/* Copyright (c) 2013-2015 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "gba/renderers/software-private.h"
7
8#define SPRITE_NORMAL_LOOP(DEPTH, TYPE) \
9 SPRITE_YBASE_ ## DEPTH(inY); \
10 unsigned tileData; \
11 for (; outX < condition; ++outX, inX += xOffset) { \
12 if (!(renderer->row[outX] & FLAG_UNWRITTEN)) { \
13 continue; \
14 } \
15 renderer->spriteCyclesRemaining -= 1; \
16 SPRITE_XBASE_ ## DEPTH(inX); \
17 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(inX); \
18 }
19
20#define SPRITE_MOSAIC_LOOP(DEPTH, TYPE) \
21 SPRITE_YBASE_ ## DEPTH(inY); \
22 unsigned tileData; \
23 if (outX % mosaicH) { \
24 if (!inX && xOffset > 0) { \
25 inX = mosaicH - (outX % mosaicH); \
26 outX += mosaicH - (outX % mosaicH); \
27 } else if (inX == width - xOffset) { \
28 inX = mosaicH + (outX % mosaicH); \
29 outX += mosaicH - (outX % mosaicH); \
30 } \
31 } \
32 for (; outX < condition; ++outX, inX += xOffset) { \
33 if (!(renderer->row[outX] & FLAG_UNWRITTEN)) { \
34 continue; \
35 } \
36 int localX = inX - xOffset * (outX % mosaicH); \
37 if (localX < 0 || localX > width - 1) { \
38 continue; \
39 } \
40 SPRITE_XBASE_ ## DEPTH(localX); \
41 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(localX); \
42 }
43
44#define SPRITE_TRANSFORMED_LOOP(DEPTH, TYPE) \
45 unsigned tileData; \
46 unsigned widthMask = ~(width - 1); \
47 unsigned heightMask = ~(height - 1); \
48 for (; outX < condition; ++outX, ++inX) { \
49 if (!(renderer->row[outX] & FLAG_UNWRITTEN)) { \
50 continue; \
51 } \
52 renderer->spriteCyclesRemaining -= 2; \
53 xAccum += mat.a; \
54 yAccum += mat.c; \
55 int localX = xAccum >> 8; \
56 int localY = yAccum >> 8; \
57 \
58 if (localX & widthMask || localY & heightMask) { \
59 break; \
60 } \
61 \
62 SPRITE_YBASE_ ## DEPTH(localY); \
63 SPRITE_XBASE_ ## DEPTH(localX); \
64 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(localX); \
65 }
66
67#define SPRITE_XBASE_16(localX) unsigned xBase = (localX & ~0x7) * 4 + ((localX >> 1) & 2);
68#define SPRITE_YBASE_16(localY) unsigned yBase = (localY & ~0x7) * stride + (localY & 0x7) * 4;
69
70#define SPRITE_DRAW_PIXEL_16_NORMAL(localX) \
71 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
72 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
73 if (UNLIKELY(!vramBase)) { \
74 return 0; \
75 } \
76 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
77 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
78 current = renderer->spriteLayer[outX]; \
79 if ((current & FLAG_ORDER_MASK) > flags) { \
80 if (tileData) { \
81 renderer->spriteLayer[outX] = palette[tileData] | flags; \
82 } else if (current != FLAG_UNWRITTEN) { \
83 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
84 } \
85 }
86
87#define SPRITE_DRAW_PIXEL_16_NORMAL_OBJWIN(localX) \
88 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
89 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
90 if (UNLIKELY(!vramBase)) { \
91 return 0; \
92 } \
93 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
94 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
95 current = renderer->spriteLayer[outX]; \
96 if ((current & FLAG_ORDER_MASK) > flags) { \
97 if (tileData) { \
98 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
99 renderer->spriteLayer[outX] = color | flags; \
100 } else if (current != FLAG_UNWRITTEN) { \
101 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
102 } \
103 }
104
105#define SPRITE_DRAW_PIXEL_16_OBJWIN(localX) \
106 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
107 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
108 if (UNLIKELY(!vramBase)) { \
109 return 0; \
110 } \
111 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
112 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
113 if (tileData) { \
114 renderer->row[outX] |= FLAG_OBJWIN; \
115 }
116
117#define SPRITE_XBASE_256(localX) unsigned xBase = (localX & ~0x7) * 8 + (localX & 6);
118#define SPRITE_YBASE_256(localY) unsigned yBase = (localY & ~0x7) * stride + (localY & 0x7) * 8;
119
120#define SPRITE_DRAW_PIXEL_256_NORMAL(localX) \
121 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
122 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
123 if (UNLIKELY(!vramBase)) { \
124 return 0; \
125 } \
126 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
127 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
128 current = renderer->spriteLayer[outX]; \
129 if ((current & FLAG_ORDER_MASK) > flags) { \
130 if (tileData) { \
131 renderer->spriteLayer[outX] = palette[tileData] | flags; \
132 } else if (current != FLAG_UNWRITTEN) { \
133 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
134 } \
135 }
136
137#define SPRITE_DRAW_PIXEL_256_NORMAL_OBJWIN(localX) \
138 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
139 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
140 if (UNLIKELY(!vramBase)) { \
141 return 0; \
142 } \
143 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
144 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
145 current = renderer->spriteLayer[outX]; \
146 if ((current & FLAG_ORDER_MASK) > flags) { \
147 if (tileData) { \
148 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
149 renderer->spriteLayer[outX] = color | flags; \
150 } else if (current != FLAG_UNWRITTEN) { \
151 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
152 } \
153 }
154
155#define SPRITE_DRAW_PIXEL_256_OBJWIN(localX) \
156 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
157 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
158 if (UNLIKELY(!vramBase)) { \
159 return 0; \
160 } \
161 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
162 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
163 if (tileData) { \
164 renderer->row[outX] |= FLAG_OBJWIN; \
165 }
166
167#ifndef COLOR_16_BIT
168#define TILE_TO_COLOR(tileData) \
169 unsigned color32; \
170 color32 = 0; \
171 color32 |= (tileData << 3) & 0xF8; \
172 color32 |= (tileData << 6) & 0xF800; \
173 color32 |= (tileData << 9) & 0xF80000; \
174 color32 |= (color32 >> 5) & 0x070707; \
175 color = color32;
176#elif COLOR_5_6_5
177#define TILE_TO_COLOR(tileData) \
178 uint16_t color16 = 0; \
179 color16 |= (tileData & 0x001F) << 11; \
180 color16 |= (tileData & 0x03E0) << 1; \
181 color16 |= (tileData & 0x7C00) >> 10; \
182 color = color16;
183#else
184#define TILE_TO_COLOR(tileData) \
185 color = tileData;
186#endif
187
188#define SPRITE_XBASE_BITMAP(localX) unsigned xBase = (localX & (stride - 1)) << 1;
189#define SPRITE_YBASE_BITMAP(localY) unsigned yBase = localY * (stride << 1);
190
191#define SPRITE_DRAW_PIXEL_BITMAP_NORMAL(localX) \
192 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
193 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
194 if (UNLIKELY(!vramBase)) { \
195 return 0; \
196 } \
197 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
198 current = renderer->spriteLayer[outX]; \
199 if ((current & FLAG_ORDER_MASK) > flags) { \
200 if (tileData & 0x8000) { \
201 uint32_t color; \
202 TILE_TO_COLOR(tileData); \
203 renderer->spriteLayer[outX] = color | flags; \
204 } else if (current != FLAG_UNWRITTEN) { \
205 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
206 } \
207 }
208
209#define SPRITE_DRAW_PIXEL_BITMAP_NORMAL_OBJWIN(localX) SPRITE_DRAW_PIXEL_BITMAP_NORMAL(localX)
210
211#define SPRITE_DRAW_PIXEL_BITMAP_OBJWIN(localX) \
212 uint32_t spriteBase = ((yBase + charBase + xBase) & 0x3FFFE); \
213 uint16_t* vramBase = renderer->d.vramOBJ[spriteBase >> VRAM_BLOCK_OFFSET]; \
214 if (UNLIKELY(!vramBase)) { \
215 return 0; \
216 } \
217 LOAD_16(tileData, spriteBase & VRAM_BLOCK_MASK, vramBase); \
218 if (tileData & 0x8000) { \
219 renderer->row[outX] |= FLAG_OBJWIN; \
220 }
221
222int GBAVideoSoftwareRendererPreprocessSprite(struct GBAVideoSoftwareRenderer* renderer, struct GBAObj* sprite, int y) {
223 int width = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][0];
224 int height = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][1];
225 int start = renderer->start;
226 int end = renderer->end;
227 uint32_t flags = GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY;
228 flags |= FLAG_TARGET_1 * ((GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) && renderer->target1Obj && renderer->blendEffect == BLEND_ALPHA) || GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT);
229 flags |= FLAG_OBJWIN * (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_OBJWIN);
230 if ((flags & FLAG_OBJWIN) && renderer->currentWindow.priority < renderer->objwin.priority) {
231 return 0;
232 }
233 int32_t x = (uint32_t) GBAObjAttributesBGetX(sprite->b) << 23;
234 x >>= 23;
235 x += renderer->objOffsetX;
236 unsigned charBase = GBAObjAttributesCGetTile(sprite->c);
237 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_BITMAP && renderer->bitmapStride) {
238 charBase = (charBase & (renderer->bitmapStride - 1)) * 0x10 + (charBase & ~(renderer->bitmapStride - 1)) * 0x80;
239 } else {
240 charBase *= renderer->tileStride;
241 }
242 if (!renderer->d.vramOBJ[charBase >> VRAM_BLOCK_OFFSET]) {
243 return 0;
244 }
245 if (renderer->spriteCyclesRemaining <= 0) {
246 return 0;
247 }
248
249 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt) && GBAWindowControlGetBlendEnable(renderer->objwin.packed) != GBAWindowControlIsBlendEnable(renderer->currentWindow.packed);
250 int variant = renderer->target1Obj &&
251 GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) &&
252 (renderer->blendEffect == BLEND_BRIGHTEN || renderer->blendEffect == BLEND_DARKEN);
253 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT || objwinSlowPath) {
254 int target2 = renderer->target2Bd;
255 target2 |= renderer->bg[0].target2;
256 target2 |= renderer->bg[1].target2;
257 target2 |= renderer->bg[2].target2;
258 target2 |= renderer->bg[3].target2;
259 if (target2) {
260 flags |= FLAG_REBLEND;
261 variant = 0;
262 } else {
263 flags &= ~FLAG_TARGET_1;
264 }
265 }
266
267 color_t* palette = &renderer->normalPalette[0x100];
268 color_t* objwinPalette = palette;
269
270 if (GBAObjAttributesAIs256Color(sprite->a) && renderer->objExtPalette) {
271 if (!variant) {
272 palette = renderer->objExtPalette;
273 objwinPalette = palette;
274 } else {
275 palette = renderer->objExtVariantPalette;
276 if (GBAWindowControlIsBlendEnable(renderer->objwin.packed)) {
277 objwinPalette = palette;
278 }
279 }
280 } else if (variant) {
281 palette = &renderer->variantPalette[0x100];
282 if (GBAWindowControlIsBlendEnable(renderer->objwin.packed)) {
283 objwinPalette = palette;
284 }
285 }
286
287 int inY = y - ((int) GBAObjAttributesAGetY(sprite->a) + renderer->objOffsetY);
288 int stride = GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt) ? (width >> !GBAObjAttributesAIs256Color(sprite->a)) : 0x80;
289 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_BITMAP && renderer->bitmapStride) {
290 stride = renderer->bitmapStride << 3;
291 }
292
293 uint32_t current;
294 if (GBAObjAttributesAIsTransformed(sprite->a)) {
295 int totalWidth = width << GBAObjAttributesAGetDoubleSize(sprite->a);
296 int totalHeight = height << GBAObjAttributesAGetDoubleSize(sprite->a);
297 renderer->spriteCyclesRemaining -= 10;
298 struct GBAOAMMatrix mat;
299 LOAD_16(mat.a, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].a);
300 LOAD_16(mat.b, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].b);
301 LOAD_16(mat.c, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].c);
302 LOAD_16(mat.d, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].d);
303
304 if (inY < 0) {
305 inY += 256;
306 }
307 int outX = x >= start ? x : start;
308 int condition = x + totalWidth;
309 int inX = outX - x;
310 if (end < condition) {
311 condition = end;
312 }
313
314 int xAccum = mat.a * (inX - 1 - (totalWidth >> 1)) + mat.b * (inY - (totalHeight >> 1)) + (width << 7);
315 int yAccum = mat.c * (inX - 1 - (totalWidth >> 1)) + mat.d * (inY - (totalHeight >> 1)) + (height << 7);
316
317 // Clip off early pixels
318 // TODO: Transform end coordinates too
319 if (mat.a) {
320 if ((xAccum >> 8) < 0) {
321 int32_t diffX = -xAccum - 1;
322 int32_t x = mat.a ? diffX / mat.a : 0;
323 xAccum += mat.a * x;
324 yAccum += mat.c * x;
325 outX += x;
326 inX += x;
327 } else if ((xAccum >> 8) >= width) {
328 int32_t diffX = (width << 8) - xAccum;
329 int32_t x = mat.a ? diffX / mat.a : 0;
330 xAccum += mat.a * x;
331 yAccum += mat.c * x;
332 outX += x;
333 inX += x;
334 }
335 }
336 if (mat.c) {
337 if ((yAccum >> 8) < 0) {
338 int32_t diffY = - yAccum - 1;
339 int32_t y = mat.c ? diffY / mat.c : 0;
340 xAccum += mat.a * y;
341 yAccum += mat.c * y;
342 outX += y;
343 inX += y;
344 } else if ((yAccum >> 8) >= height) {
345 int32_t diffY = (height << 8) - yAccum;
346 int32_t y = mat.c ? diffY / mat.c : 0;
347 xAccum += mat.a * y;
348 yAccum += mat.c * y;
349 outX += y;
350 inX += y;
351 }
352 }
353
354 if (outX < start || outX >= condition) {
355 return 0;
356 }
357
358 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_BITMAP && renderer->bitmapStride) {
359 int alpha = GBAObjAttributesCGetPalette(sprite->c);
360 if (flags & FLAG_OBJWIN) {
361 SPRITE_TRANSFORMED_LOOP(BITMAP, OBJWIN);
362 } else if (objwinSlowPath) {
363 SPRITE_TRANSFORMED_LOOP(BITMAP, NORMAL_OBJWIN);
364 } else {
365 SPRITE_TRANSFORMED_LOOP(BITMAP, NORMAL);
366 }
367 } else if (!GBAObjAttributesAIs256Color(sprite->a)) {
368 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
369 if (flags & FLAG_OBJWIN) {
370 SPRITE_TRANSFORMED_LOOP(16, OBJWIN);
371 } else if (objwinSlowPath) {
372 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
373 SPRITE_TRANSFORMED_LOOP(16, NORMAL_OBJWIN);
374 } else {
375 SPRITE_TRANSFORMED_LOOP(16, NORMAL);
376 }
377 } else if (!renderer->objExtPalette) {
378 if (flags & FLAG_OBJWIN) {
379 SPRITE_TRANSFORMED_LOOP(256, OBJWIN);
380 } else if (objwinSlowPath) {
381 SPRITE_TRANSFORMED_LOOP(256, NORMAL_OBJWIN);
382 } else {
383 SPRITE_TRANSFORMED_LOOP(256, NORMAL);
384 }
385 } else {
386 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 8];
387 if (flags & FLAG_OBJWIN) {
388 SPRITE_TRANSFORMED_LOOP(256, OBJWIN);
389 } else if (objwinSlowPath) {
390 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 8];
391 SPRITE_TRANSFORMED_LOOP(256, NORMAL_OBJWIN);
392 } else {
393 SPRITE_TRANSFORMED_LOOP(256, NORMAL);
394 }
395 }
396 if (x + totalWidth > renderer->masterEnd) {
397 renderer->spriteCyclesRemaining -= (x + totalWidth - renderer->masterEnd) * 2;
398 }
399 } else {
400 int outX = x >= start ? x : start;
401 int condition = x + width;
402 int mosaicH = 1;
403 if (GBAObjAttributesAIsMosaic(sprite->a)) {
404 mosaicH = GBAMosaicControlGetObjH(renderer->mosaic) + 1;
405 if (condition % mosaicH) {
406 condition += mosaicH - (condition % mosaicH);
407 }
408 }
409 if ((int) GBAObjAttributesAGetY(sprite->a) + height - 256 >= 0) {
410 inY += 256;
411 }
412 if (GBAObjAttributesBIsVFlip(sprite->b)) {
413 inY = height - inY - 1;
414 }
415 if (end < condition) {
416 condition = end;
417 }
418 int inX = outX - x;
419 int xOffset = 1;
420 if (GBAObjAttributesBIsHFlip(sprite->b)) {
421 inX = width - inX - 1;
422 xOffset = -1;
423 }
424 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_BITMAP && renderer->bitmapStride) {
425 int alpha = GBAObjAttributesCGetPalette(sprite->c);
426 if (flags & FLAG_OBJWIN) {
427 SPRITE_NORMAL_LOOP(BITMAP, OBJWIN);
428 } else if (mosaicH > 1) {
429 if (objwinSlowPath) {
430 SPRITE_MOSAIC_LOOP(BITMAP, NORMAL_OBJWIN);
431 } else {
432 SPRITE_MOSAIC_LOOP(BITMAP, NORMAL);
433 }
434 } else if (objwinSlowPath) {
435 SPRITE_NORMAL_LOOP(BITMAP, NORMAL_OBJWIN);
436 } else {
437 SPRITE_NORMAL_LOOP(BITMAP, NORMAL);
438 }
439 } else if (!GBAObjAttributesAIs256Color(sprite->a)) {
440 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
441 if (flags & FLAG_OBJWIN) {
442 SPRITE_NORMAL_LOOP(16, OBJWIN);
443 } else if (mosaicH > 1) {
444 if (objwinSlowPath) {
445 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
446 SPRITE_MOSAIC_LOOP(16, NORMAL_OBJWIN);
447 } else {
448 SPRITE_MOSAIC_LOOP(16, NORMAL);
449 }
450 } else if (objwinSlowPath) {
451 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
452 SPRITE_NORMAL_LOOP(16, NORMAL_OBJWIN);
453 } else {
454 SPRITE_NORMAL_LOOP(16, NORMAL);
455 }
456 } else if (!renderer->objExtPalette) {
457 if (flags & FLAG_OBJWIN) {
458 SPRITE_NORMAL_LOOP(256, OBJWIN);
459 } else if (mosaicH > 1) {
460 if (objwinSlowPath) {
461 SPRITE_MOSAIC_LOOP(256, NORMAL_OBJWIN);
462 } else {
463 SPRITE_MOSAIC_LOOP(256, NORMAL);
464 }
465 } else if (objwinSlowPath) {
466 SPRITE_NORMAL_LOOP(256, NORMAL_OBJWIN);
467 } else {
468 SPRITE_NORMAL_LOOP(256, NORMAL);
469 }
470 } else {
471 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 8];
472 if (flags & FLAG_OBJWIN) {
473 SPRITE_NORMAL_LOOP(256, OBJWIN);
474 } else if (mosaicH > 1) {
475 if (objwinSlowPath) {
476 SPRITE_MOSAIC_LOOP(256, NORMAL_OBJWIN);
477 } else {
478 SPRITE_MOSAIC_LOOP(256, NORMAL);
479 }
480 } else if (objwinSlowPath) {
481 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 8];
482 SPRITE_NORMAL_LOOP(256, NORMAL_OBJWIN);
483 } else {
484 SPRITE_NORMAL_LOOP(256, NORMAL);
485 }
486
487 }
488 if (x + width > renderer->masterEnd) {
489 renderer->spriteCyclesRemaining -= x + width - renderer->masterEnd;
490 }
491 }
492 return 1;
493}
494
495void GBAVideoSoftwareRendererPostprocessSprite(struct GBAVideoSoftwareRenderer* renderer, unsigned priority) {
496 int x;
497 uint32_t flags = FLAG_TARGET_2 * renderer->target2Obj;
498
499 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt);
500 bool objwinDisable = false;
501 bool objwinOnly = false;
502 if (objwinSlowPath) {
503 objwinDisable = !GBAWindowControlIsObjEnable(renderer->objwin.packed);
504 objwinOnly = !objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed);
505 if (objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
506 return;
507 }
508
509 if (objwinDisable) {
510 for (x = renderer->start; x < renderer->end; ++x) {
511 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
512 uint32_t current = renderer->row[x];
513 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && !(current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
514 _compositeBlendObjwin(renderer, x, color | flags, current);
515 }
516 }
517 return;
518 } else if (objwinOnly) {
519 for (x = renderer->start; x < renderer->end; ++x) {
520 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
521 uint32_t current = renderer->row[x];
522 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
523 _compositeBlendObjwin(renderer, x, color | flags, current);
524 }
525 }
526 return;
527 } else {
528 for (x = renderer->start; x < renderer->end; ++x) {
529 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
530 uint32_t current = renderer->row[x];
531 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
532 _compositeBlendObjwin(renderer, x, color | flags, current);
533 }
534 }
535 return;
536 }
537 } else if (!GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
538 return;
539 }
540 for (x = renderer->start; x < renderer->end; ++x) {
541 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
542 uint32_t current = renderer->row[x];
543 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
544 _compositeBlendNoObjwin(renderer, x, color | flags, current);
545 }
546 }
547}