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 "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 SPRITE_XBASE_ ## DEPTH(inX); \
16 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(inX); \
17 }
18
19#define SPRITE_MOSAIC_LOOP(DEPTH, TYPE) \
20 SPRITE_YBASE_ ## DEPTH(inY); \
21 unsigned tileData; \
22 if (outX % mosaicH) { \
23 if (!inX && xOffset > 0) { \
24 inX = mosaicH - (outX % mosaicH); \
25 outX += mosaicH - (outX % mosaicH); \
26 } else if (inX == width - xOffset) { \
27 inX = mosaicH + (outX % mosaicH); \
28 outX += mosaicH - (outX % mosaicH); \
29 } \
30 } \
31 for (; outX < condition; ++outX, inX += xOffset) { \
32 if (!(renderer->row[outX] & FLAG_UNWRITTEN)) { \
33 continue; \
34 } \
35 int localX = inX - xOffset * (outX % mosaicH); \
36 if (localX < 0 || localX > width - 1) { \
37 continue; \
38 } \
39 SPRITE_XBASE_ ## DEPTH(localX); \
40 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(localX); \
41 }
42
43#define SPRITE_TRANSFORMED_LOOP(DEPTH, TYPE) \
44 unsigned tileData; \
45 for (; outX < x + totalWidth && outX < end; ++outX, ++inX) { \
46 if (!(renderer->row[outX] & FLAG_UNWRITTEN)) { \
47 continue; \
48 } \
49 xAccum += mat.a; \
50 yAccum += mat.c; \
51 int localX = (xAccum >> 8) + (width >> 1); \
52 int localY = (yAccum >> 8) + (height >> 1); \
53 \
54 if (localX < 0 || localX >= width || localY < 0 || localY >= height) { \
55 continue; \
56 } \
57 \
58 SPRITE_YBASE_ ## DEPTH(localY); \
59 SPRITE_XBASE_ ## DEPTH(localX); \
60 SPRITE_DRAW_PIXEL_ ## DEPTH ## _ ## TYPE(localX); \
61 }
62
63#define SPRITE_XBASE_16(localX) unsigned xBase = (localX & ~0x7) * 4 + ((localX >> 1) & 2);
64#define SPRITE_YBASE_16(localY) unsigned yBase = (localY & ~0x7) * (GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt) ? width >> 1 : 0x80) + (localY & 0x7) * 4;
65
66#define SPRITE_DRAW_PIXEL_16_NORMAL(localX) \
67 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), 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 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
80 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
81 current = renderer->spriteLayer[outX]; \
82 if ((current & FLAG_ORDER_MASK) > flags) { \
83 if (tileData) { \
84 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
85 renderer->spriteLayer[outX] = color | flags; \
86 } else if (current != FLAG_UNWRITTEN) { \
87 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
88 } \
89 }
90
91#define SPRITE_DRAW_PIXEL_16_OBJWIN(localX) \
92 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
93 tileData = (tileData >> ((localX & 3) << 2)) & 0xF; \
94 if (tileData) { \
95 renderer->row[outX] |= FLAG_OBJWIN; \
96 }
97
98#define SPRITE_XBASE_256(localX) unsigned xBase = (localX & ~0x7) * 8 + (localX & 6);
99#define SPRITE_YBASE_256(localY) unsigned yBase = (localY & ~0x7) * (GBARegisterDISPCNTIsObjCharacterMapping(renderer->dispcnt) ? width : 0x80) + (localY & 0x7) * 8;
100
101#define SPRITE_DRAW_PIXEL_256_NORMAL(localX) \
102 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
103 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
104 current = renderer->spriteLayer[outX]; \
105 if ((current & FLAG_ORDER_MASK) > flags) { \
106 if (tileData) { \
107 renderer->spriteLayer[outX] = palette[tileData] | flags; \
108 } else if (current != FLAG_UNWRITTEN) { \
109 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
110 } \
111 }
112
113#define SPRITE_DRAW_PIXEL_256_NORMAL_OBJWIN(localX) \
114 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
115 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
116 current = renderer->spriteLayer[outX]; \
117 if ((current & FLAG_ORDER_MASK) > flags) { \
118 if (tileData) { \
119 unsigned color = (renderer->row[outX] & FLAG_OBJWIN) ? objwinPalette[tileData] : palette[tileData]; \
120 renderer->spriteLayer[outX] = color | flags; \
121 } else if (current != FLAG_UNWRITTEN) { \
122 renderer->spriteLayer[outX] = (current & ~FLAG_ORDER_MASK) | GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY; \
123 } \
124 }
125
126#define SPRITE_DRAW_PIXEL_256_OBJWIN(localX) \
127 LOAD_16(tileData, ((yBase + charBase + xBase) & 0x7FFE), vramBase); \
128 tileData = (tileData >> ((localX & 1) << 3)) & 0xFF; \
129 if (tileData) { \
130 renderer->row[outX] |= FLAG_OBJWIN; \
131 }
132
133int GBAVideoSoftwareRendererPreprocessSprite(struct GBAVideoSoftwareRenderer* renderer, struct GBAObj* sprite, int y) {
134 int width = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][0];
135 int height = GBAVideoObjSizes[GBAObjAttributesAGetShape(sprite->a) * 4 + GBAObjAttributesBGetSize(sprite->b)][1];
136 int start = renderer->start;
137 int end = renderer->end;
138 uint32_t flags = GBAObjAttributesCGetPriority(sprite->c) << OFFSET_PRIORITY;
139 flags |= FLAG_TARGET_1 * ((GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) && renderer->target1Obj && renderer->blendEffect == BLEND_ALPHA) || GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT);
140 flags |= FLAG_OBJWIN * (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_OBJWIN);
141 int32_t x = GBAObjAttributesBGetX(sprite->b) << 23;
142 x >>= 23;
143 uint16_t* vramBase = &renderer->d.vram[BASE_TILE >> 1];
144 unsigned charBase = GBAObjAttributesCGetTile(sprite->c) * 0x20;
145 if (GBARegisterDISPCNTGetMode(renderer->dispcnt) >= 3 && GBAObjAttributesCGetTile(sprite->c) < 512) {
146 return 0;
147 }
148 int variant = renderer->target1Obj && GBAWindowControlIsBlendEnable(renderer->currentWindow.packed) && (renderer->blendEffect == BLEND_BRIGHTEN || renderer->blendEffect == BLEND_DARKEN);
149 if (GBAObjAttributesAGetMode(sprite->a) == OBJ_MODE_SEMITRANSPARENT) {
150 int target2 = renderer->target2Bd << 4;
151 target2 |= renderer->bg[0].target2 << (renderer->bg[0].priority);
152 target2 |= renderer->bg[1].target2 << (renderer->bg[1].priority);
153 target2 |= renderer->bg[2].target2 << (renderer->bg[2].priority);
154 target2 |= renderer->bg[3].target2 << (renderer->bg[3].priority);
155 if ((1 << GBAObjAttributesCGetPriority(sprite->c)) < target2) {
156 variant = 0;
157 }
158 }
159 color_t* palette = &renderer->normalPalette[0x100];
160 color_t* objwinPalette = palette;
161 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt) && GBAWindowControlGetBlendEnable(renderer->objwin.packed) != GBAWindowControlIsBlendEnable(renderer->currentWindow.packed);
162
163 if (variant) {
164 palette = &renderer->variantPalette[0x100];
165 if (GBAWindowControlIsBlendEnable(renderer->objwin.packed)) {
166 objwinPalette = palette;
167 }
168 }
169
170 int inY = y - (int) GBAObjAttributesAGetY(sprite->a);
171
172 uint32_t current;
173 if (GBAObjAttributesAIsTransformed(sprite->a)) {
174 int totalWidth = width << GBAObjAttributesAGetDoubleSize(sprite->a);
175 int totalHeight = height << GBAObjAttributesAGetDoubleSize(sprite->a);
176 struct GBAOAMMatrix mat;
177 LOAD_16(mat.a, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].a);
178 LOAD_16(mat.b, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].b);
179 LOAD_16(mat.c, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].c);
180 LOAD_16(mat.d, 0, &renderer->d.oam->mat[GBAObjAttributesBGetMatIndex(sprite->b)].d);
181
182 if (inY < 0) {
183 inY += 256;
184 }
185 int outX = x >= start ? x : start;
186 int inX = outX - x;
187 int xAccum = mat.a * (inX - 1 - (totalWidth >> 1)) + mat.b * (inY - (totalHeight >> 1));
188 int yAccum = mat.c * (inX - 1 - (totalWidth >> 1)) + mat.d * (inY - (totalHeight >> 1));
189
190 if (!GBAObjAttributesAIs256Color(sprite->a)) {
191 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
192 if (flags & FLAG_OBJWIN) {
193 SPRITE_TRANSFORMED_LOOP(16, OBJWIN);
194 } else if (objwinSlowPath) {
195 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
196 SPRITE_TRANSFORMED_LOOP(16, NORMAL_OBJWIN);
197 } else {
198 SPRITE_TRANSFORMED_LOOP(16, NORMAL);
199 }
200 } else {
201 if (flags & FLAG_OBJWIN) {
202 SPRITE_TRANSFORMED_LOOP(256, OBJWIN);
203 } else if (objwinSlowPath) {
204 SPRITE_TRANSFORMED_LOOP(256, NORMAL_OBJWIN);
205 } else {
206 SPRITE_TRANSFORMED_LOOP(256, NORMAL);
207 }
208 }
209 } else {
210 int outX = x >= start ? x : start;
211 int condition = x + width;
212 int mosaicH = 1;
213 if (GBAObjAttributesAIsMosaic(sprite->a)) {
214 mosaicH = GBAMosaicControlGetObjH(renderer->mosaic) + 1;
215 if (condition % mosaicH) {
216 condition += mosaicH - (condition % mosaicH);
217 }
218 }
219 if ((int) GBAObjAttributesAGetY(sprite->a) + height - 256 >= 0) {
220 inY += 256;
221 }
222 if (GBAObjAttributesBIsVFlip(sprite->b)) {
223 inY = height - inY - 1;
224 }
225 if (end < condition) {
226 condition = end;
227 }
228 int inX = outX - x;
229 int xOffset = 1;
230 if (GBAObjAttributesBIsHFlip(sprite->b)) {
231 inX = width - inX - 1;
232 xOffset = -1;
233 }
234 if (!GBAObjAttributesAIs256Color(sprite->a)) {
235 palette = &palette[GBAObjAttributesCGetPalette(sprite->c) << 4];
236 if (flags & FLAG_OBJWIN) {
237 SPRITE_NORMAL_LOOP(16, OBJWIN);
238 } else if (GBAObjAttributesAIsMosaic(sprite->a)) {
239 SPRITE_MOSAIC_LOOP(16, NORMAL);
240 } else if (objwinSlowPath) {
241 objwinPalette = &objwinPalette[GBAObjAttributesCGetPalette(sprite->c) << 4];
242 SPRITE_NORMAL_LOOP(16, NORMAL_OBJWIN);
243 } else {
244 SPRITE_NORMAL_LOOP(16, NORMAL);
245 }
246 } else {
247 if (flags & FLAG_OBJWIN) {
248 SPRITE_NORMAL_LOOP(256, OBJWIN);
249 } else if (GBAObjAttributesAIsMosaic(sprite->a)) {
250 SPRITE_MOSAIC_LOOP(256, NORMAL);
251 } else if (objwinSlowPath) {
252 SPRITE_NORMAL_LOOP(256, NORMAL_OBJWIN);
253 } else {
254 SPRITE_NORMAL_LOOP(256, NORMAL);
255 }
256 }
257 }
258 return 1;
259}
260
261void GBAVideoSoftwareRendererPostprocessSprite(struct GBAVideoSoftwareRenderer* renderer, unsigned priority) {
262 int x;
263 uint32_t* pixel = &renderer->row[renderer->start];
264 uint32_t flags = FLAG_TARGET_2 * renderer->target2Obj;
265
266 int objwinSlowPath = GBARegisterDISPCNTIsObjwinEnable(renderer->dispcnt);
267 bool objwinDisable = false;
268 bool objwinOnly = false;
269 if (objwinSlowPath) {
270 objwinDisable = !GBAWindowControlIsObjEnable(renderer->objwin.packed);
271 objwinOnly = !objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed);
272 if (objwinDisable && !GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
273 return;
274 }
275
276 if (objwinDisable) {
277 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
278 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
279 uint32_t current = *pixel;
280 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && !(current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
281 _compositeBlendObjwin(renderer, pixel, color | flags, current);
282 }
283 }
284 return;
285 } else if (objwinOnly) {
286 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
287 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
288 uint32_t current = *pixel;
289 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (current & FLAG_OBJWIN) && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
290 _compositeBlendObjwin(renderer, pixel, color | flags, current);
291 }
292 }
293 return;
294 } else {
295 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
296 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
297 uint32_t current = *pixel;
298 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
299 _compositeBlendObjwin(renderer, pixel, color | flags, current);
300 }
301 }
302 return;
303 }
304 } else if (!GBAWindowControlIsObjEnable(renderer->currentWindow.packed)) {
305 return;
306 }
307 for (x = renderer->start; x < renderer->end; ++x, ++pixel) {
308 uint32_t color = renderer->spriteLayer[x] & ~FLAG_OBJWIN;
309 uint32_t current = *pixel;
310 if ((color & FLAG_UNWRITTEN) != FLAG_UNWRITTEN && (color & FLAG_PRIORITY) >> OFFSET_PRIORITY == priority) {
311 _compositeBlendNoObjwin(renderer, pixel, color | flags, current);
312 }
313 }
314}