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