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 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
72 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
73 current = renderer->spriteLayer[outX]; \
74 if ((current & FLAG_ORDER_MASK) > flags) { \
75 if (tileData) { \
76 renderer->spriteLayer[outX] = palette[tileData] | flags; \
77 } else if (current != FLAG_UNWRITTEN) { \
78 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
79 } \
80 }
81
82#define SPRITE_DRAW_PIXEL_16_NORMAL_OBJWIN(localX) \
83 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
84 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
85 current = renderer->spriteLayer[outX]; \
86 if ((current & FLAG_ORDER_MASK) > flags) { \
87 if (tileData) { \
88 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
89 renderer->spriteLayer[outX] = color | flags; \
90 } else if (current != FLAG_UNWRITTEN) { \
91 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
92 } \
93 }
94
95#define SPRITE_DRAW_PIXEL_16_OBJWIN(localX) \
96 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
97 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
98 if (tileData) { \
99 renderer->row[outX] |= FLAG_OBJWIN; \
100 }
101
102#define SPRITE_XBASE_256(localX) unsigned xBase = (localX & ~0x7) * 8 + (localX & 6);
103#define SPRITE_YBASE_256(localY) unsigned yBase = (localY & ~0x7) * stride + (localY & 0x7) * 8;
104
105#define SPRITE_DRAW_PIXEL_256_NORMAL(localX) \
106 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
107 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
108 current = renderer->spriteLayer[outX]; \
109 if ((current & FLAG_ORDER_MASK) > flags) { \
110 if (tileData) { \
111 renderer->spriteLayer[outX] = palette[tileData] | flags; \
112 } else if (current != FLAG_UNWRITTEN) { \
113 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
114 } \
115 }
116
117#define SPRITE_DRAW_PIXEL_256_NORMAL_OBJWIN(localX) \
118 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
119 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
120 current = renderer->spriteLayer[outX]; \
121 if ((current & FLAG_ORDER_MASK) > flags) { \
122 if (tileData) { \
123 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
124 renderer->spriteLayer[outX] = color | flags; \
125 } else if (current != FLAG_UNWRITTEN) { \
126 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
127 } \
128 }
129
130#define SPRITE_DRAW_PIXEL_256_OBJWIN(localX) \
131 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
132 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
133 if (tileData) { \
134 renderer->row[outX] |= FLAG_OBJWIN; \
135 }
136
137int GBAVideoSoftwareRendererPreprocessSprite(struct GBAVideoSoftwareRenderer* renderer, struct GBAObj* sprite, int y) {
138 int width = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][0];
139 int height = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][1];
140 int start = renderer->start;
141 int end = renderer->end;
142 uint32_t flags = GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY;
143 flags |= FLAG_TARGET_1 * ((GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) && renderer->target1Obj && renderer->blendEffect == BLEND_ALPHA) || GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT);
144 flags |= FLAG_OBJWIN * (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_OBJWIN);
145 if ((flags & FLAG_OBJWIN) && renderer->currentWindow.priority < renderer->objwin.priority) {
146 return 0;
147 }
148 int32_t x = (uint32_t) GBAObjAttributesBGetX(sprite->b) << 23;
149 x >>= 23;
150 x += renderer->objOffsetX;
151 uint16_t* vramBase = &renderer->d.vram[BASE_TILE >> 1];
152 bool align = GBAObjAttributesAIs256Color(sprite->a) && !GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt);
153 unsigned charBase = (GBAObjAttributesCGetTile(sprite->c) & ~align) * 0x20;
154 if (GBARegisterDISPCNTGetMode(renderer->dispcnt) >= 3 && GBAObjAttributesCGetTile(sprite->c) < 512) {
155 return 0;
156 }
157 if (renderer->spriteCyclesRemaining <= 0) {
158 return 0;
159 }
160
161 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt) && GBAWindowControlGetBlendEnable(renderer->objwin.packed) != GBAWindowControlIsBlendEnable(renderer->currentWindow.packed);
162 int variant = renderer->target1Obj &&
163 GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) &&
164 (renderer->blendEffect == BLEND_BRIGHTEN || renderer->blendEffect == BLEND_DARKEN);
165 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT || objwinSlowPath) {
166 int target2 = renderer->target2Bd;
167 target2 |= renderer->bg[0].target2;
168 target2 |= renderer->bg[1].target2;
169 target2 |= renderer->bg[2].target2;
170 target2 |= renderer->bg[3].target2;
171 if (target2) {
172 flags |= FLAG_REBLEND;
173 variant = 0;
174 } else {
175 flags &= ~FLAG_TARGET_1;
176 }
177 }
178
179 color_t* palette = &renderer->normalPalette[0x100];
180 color_t* objwinPalette = palette;
181
182 if (variant) {
183 palette = &renderer->variantPalette[0x100];
184 if (GBAWindowControlIsBlendEnable(renderer->objwin.packed)) {
185 objwinPalette = palette;
186 }
187 }
188
189 int inY = y - ((int) GBAObjAttributesAGetY(sprite->a) + renderer->objOffsetY);
190 int stride = GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt) ? (width >> !GBAObjAttributesAIs256Color(sprite->a)) : 0x80;
191
192 uint32_t current;
193 if (GBAObjAttributesAIsTransformed(sprite->a)) {
194 int totalWidth = width << GBAObjAttributesAGetDoubleSize(sprite->a);
195 int totalHeight = height << GBAObjAttributesAGetDoubleSize(sprite->a);
196 renderer->spriteCyclesRemaining -= 10;
197 struct GBAOAMMatrix mat;
198 LOAD_16(mat.a, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].a);
199 LOAD_16(mat.b, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].b);
200 LOAD_16(mat.c, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].c);
201 LOAD_16(mat.d, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].d);
202
203 if (inY < 0) {
204 inY += 256;
205 }
206 int outX = x >= start ? x : start;
207 int condition = x + totalWidth;
208 int inX = outX - x;
209 if (end < condition) {
210 condition = end;
211 }
212
213 int xAccum = mat.a * (inX - 1 - (totalWidth >> 1)) + mat.b * (inY - (totalHeight >> 1)) + (width << 7);
214 int yAccum = mat.c * (inX - 1 - (totalWidth >> 1)) + mat.d * (inY - (totalHeight >> 1)) + (height << 7);
215
216 // Clip off early pixels
217 // TODO: Transform end coordinates too
218 if (mat.a) {
219 if ((xAccum >> 8) < 0) {
220 int32_t diffX = -xAccum - 1;
221 int32_t x = mat.a ? diffX / mat.a : 0;
222 xAccum += mat.a * x;
223 yAccum += mat.c * x;
224 outX += x;
225 inX += x;
226 } else if ((xAccum >> 8) >= width) {
227 int32_t diffX = (width << 8) - xAccum;
228 int32_t x = mat.a ? diffX / mat.a : 0;
229 xAccum += mat.a * x;
230 yAccum += mat.c * x;
231 outX += x;
232 inX += x;
233 }
234 }
235 if (mat.c) {
236 if ((yAccum >> 8) < 0) {
237 int32_t diffY = - yAccum - 1;
238 int32_t y = mat.c ? diffY / mat.c : 0;
239 xAccum += mat.a * y;
240 yAccum += mat.c * y;
241 outX += y;
242 inX += y;
243 } else if ((yAccum >> 8) >= height) {
244 int32_t diffY = (height << 8) - yAccum;
245 int32_t y = mat.c ? diffY / mat.c : 0;
246 xAccum += mat.a * y;
247 yAccum += mat.c * y;
248 outX += y;
249 inX += y;
250 }
251 }
252
253 if (outX < start || outX >= condition) {
254 return 0;
255 }
256
257 if (!GBAObjAttributesAIs256Color(sprite->a)) {
258 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
259 if (flags & FLAG_OBJWIN) {
260 SPRITE_TRANSFORMED_LOOP(16, OBJWIN);
261 } else if (objwinSlowPath) {
262 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
263 SPRITE_TRANSFORMED_LOOP(16, NORMAL_OBJWIN);
264 } else {
265 SPRITE_TRANSFORMED_LOOP(16, NORMAL);
266 }
267 } else {
268 if (flags & FLAG_OBJWIN) {
269 SPRITE_TRANSFORMED_LOOP(256, OBJWIN);
270 } else if (objwinSlowPath) {
271 SPRITE_TRANSFORMED_LOOP(256, NORMAL_OBJWIN);
272 } else {
273 SPRITE_TRANSFORMED_LOOP(256, NORMAL);
274 }
275 }
276 if (x + totalWidth > VIDEO_HORIZONTAL_PIXELS) {
277 renderer->spriteCyclesRemaining -= (x + totalWidth - VIDEO_HORIZONTAL_PIXELS) * 2;
278 }
279 } else {
280 int outX = x >= start ? x : start;
281 int condition = x + width;
282 int mosaicH = 1;
283 if (GBAObjAttributesAIsMosaic(sprite->a)) {
284 mosaicH = GBAMosaicControlGetObjH(renderer->mosaic) + 1;
285 if (condition % mosaicH) {
286 condition += mosaicH - (condition % mosaicH);
287 }
288 }
289 if ((int) GBAObjAttributesAGetY(sprite->a) + height - 256 >= 0) {
290 inY += 256;
291 }
292 if (GBAObjAttributesBIsVFlip(sprite->b)) {
293 inY = height - inY - 1;
294 }
295 if (end < condition) {
296 condition = end;
297 }
298 int inX = outX - x;
299 int xOffset = 1;
300 if (GBAObjAttributesBIsHFlip(sprite->b)) {
301 inX = width - inX - 1;
302 xOffset = -1;
303 }
304 if (!GBAObjAttributesAIs256Color(sprite->a)) {
305 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
306 if (flags & FLAG_OBJWIN) {
307 SPRITE_NORMAL_LOOP(16, OBJWIN);
308 } else if (mosaicH > 1) {
309 if (objwinSlowPath) {
310 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
311 SPRITE_MOSAIC_LOOP(16, NORMAL_OBJWIN);
312 } else {
313 SPRITE_MOSAIC_LOOP(16, NORMAL);
314 }
315 } else if (objwinSlowPath) {
316 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
317 SPRITE_NORMAL_LOOP(16, NORMAL_OBJWIN);
318 } else {
319 SPRITE_NORMAL_LOOP(16, NORMAL);
320 }
321 } else {
322 if (flags & FLAG_OBJWIN) {
323 SPRITE_NORMAL_LOOP(256, OBJWIN);
324 } else if (mosaicH > 1) {
325 if (objwinSlowPath) {
326 SPRITE_MOSAIC_LOOP(256, NORMAL_OBJWIN);
327 } else {
328 SPRITE_MOSAIC_LOOP(256, NORMAL);
329 }
330 } else if (objwinSlowPath) {
331 SPRITE_NORMAL_LOOP(256, NORMAL_OBJWIN);
332 } else {
333 SPRITE_NORMAL_LOOP(256, NORMAL);
334 }
335 }
336 if (x + width > VIDEO_HORIZONTAL_PIXELS) {
337 renderer->spriteCyclesRemaining -= x + width - VIDEO_HORIZONTAL_PIXELS;
338 }
339 }
340 return 1;
341}
342
343void GBAVideoSoftwareRendererPostprocessSprite(struct GBAVideoSoftwareRenderer* renderer, unsigned priority) {
344 int x;
345 uint32_t* pixel = &renderer->row[renderer->start];
346 uint32_t flags = FLAG_TARGET_2 * renderer->target2Obj;
347
348 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt);
349 bool objwinDisable = false;
350 bool objwinOnly = false;
351 if (objwinSlowPath) {
352 objwinDisable = !GBAWindowControlIsObjEnable(renderer->objwin.packed);
353 objwinOnly = !objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed);
354 if (objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
355 return;
356 }
357
358 if (objwinDisable) {
359 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
360 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
361 uint32_t current = *pixel;
362 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && !(current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
363 _compositeBlendObjwin(renderer, pixel, color | flags, current);
364 }
365 }
366 return;
367 } else if (objwinOnly) {
368 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
369 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
370 uint32_t current = *pixel;
371 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
372 _compositeBlendObjwin(renderer, pixel, color | flags, current);
373 }
374 }
375 return;
376 } else {
377 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
378 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
379 uint32_t current = *pixel;
380 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
381 _compositeBlendObjwin(renderer, pixel, color | flags, current);
382 }
383 }
384 return;
385 }
386 } else if (!GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
387 return;
388 }
389 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
390 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
391 uint32_t current = *pixel;
392 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
393 _compositeBlendNoObjwin(renderer, pixel, color | flags, current);
394 }
395 }
396}