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