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