Mercurial > vba-clojure

view src/gba/Mode2.cpp @ 575:15876b1a0906

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
glyph display works partially, but does not write all glyphs.
author Robert McIntyre <rlm@mit.edu>
date Sat, 01 Sep 2012 04:15:32 -0500
parents f9f4f1b99eed
children
line wrap: on
line source
     1 #include "GBAGfx.h"



     2 #include "GBAGlobals.h"



     3 



     4 void mode2RenderLine()



     5 {



     6 	u16 *palette = (u16 *)paletteRAM;



     7 



     8 	if (DISPCNT & 0x80)



     9 	{



    10 		for (int x = 0; x < 240; x++)



    11 		{



    12 			lineMix[x] = 0x7fff;



    13 		}



    14 		gfxLastVCOUNT = VCOUNT;



    15 		return;



    16 	}



    17 



    18 	if (layerEnable & 0x0400)



    19 	{



    20 		int changed = gfxBG2Changed;



    21 		if (gfxLastVCOUNT > VCOUNT)



    22 			changed = 3;



    23 



    24 		gfxDrawRotScreen(BG2CNT, BG2X_L, BG2X_H, BG2Y_L, BG2Y_H,



    25 		                 BG2PA, BG2PB, BG2PC, BG2PD, gfxBG2X, gfxBG2Y,



    26 		                 changed, line2);



    27 	}



    28 



    29 	if (layerEnable & 0x0800)



    30 	{



    31 		int changed = gfxBG3Changed;



    32 		if (gfxLastVCOUNT > VCOUNT)



    33 			changed = 3;



    34 



    35 		gfxDrawRotScreen(BG3CNT, BG3X_L, BG3X_H, BG3Y_L, BG3Y_H,



    36 		                 BG3PA, BG3PB, BG3PC, BG3PD, gfxBG3X, gfxBG3Y,



    37 		                 changed, line3);



    38 	}



    39 



    40 	gfxDrawSprites(lineOBJ);



    41 



    42 	u32 backdrop = (READ16LE(&palette[0]) | 0x30000000);



    43 



    44 	for (int x = 0; x < 240; x++)



    45 	{



    46 		u32 color = backdrop;



    47 		u8  top   = 0x20;



    48 



    49 		if ((u8)(line2[x]>>24) < (u8)(color >> 24))



    50 		{



    51 			color = line2[x];



    52 			top   = 0x04;



    53 		}



    54 



    55 		if ((u8)(line3[x]>>24) < (u8)(color >> 24))



    56 		{



    57 			color = line3[x];



    58 			top   = 0x08;



    59 		}



    60 



    61 		if ((u8)(lineOBJ[x]>>24) < (u8)(color >> 24))



    62 		{



    63 			color = lineOBJ[x];



    64 			top   = 0x10;



    65 		}



    66 



    67 		if ((top & 0x10) && (color & 0x00010000))



    68 		{



    69 			// semi-transparent OBJ



    70 			u32 back = backdrop;



    71 			u8  top2 = 0x20;



    72 



    73 			if ((u8)(line2[x]>>24) < (u8)(back >> 24))



    74 			{



    75 				back = line2[x];



    76 				top2 = 0x04;



    77 			}



    78 



    79 			if ((u8)(line3[x]>>24) < (u8)(back >> 24))



    80 			{



    81 				back = line3[x];



    82 				top2 = 0x08;



    83 			}



    84 



    85 			if (top2 & (BLDMOD>>8))



    86 				color = gfxAlphaBlend(color, back,



    87 				                      coeff[COLEV & 0x1F],



    88 				                      coeff[(COLEV >> 8) & 0x1F]);



    89 			else



    90 			{



    91 				switch ((BLDMOD >> 6) & 3)



    92 				{



    93 				case 2:



    94 					if (BLDMOD & top)



    95 						color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



    96 					break;



    97 				case 3:



    98 					if (BLDMOD & top)



    99 						color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   100 					break;



   101 				}



   102 			}



   103 		}



   104 



   105 		lineMix[x] = color;



   106 	}



   107 	gfxBG2Changed = 0;



   108 	gfxBG3Changed = 0;



   109 	gfxLastVCOUNT = VCOUNT;



   110 }



   111 



   112 void mode2RenderLineNoWindow()



   113 {



   114 	u16 *palette = (u16 *)paletteRAM;



   115 



   116 	if (DISPCNT & 0x80)



   117 	{



   118 		for (int x = 0; x < 240; x++)



   119 		{



   120 			lineMix[x] = 0x7fff;



   121 		}



   122 		gfxLastVCOUNT = VCOUNT;



   123 		return;



   124 	}



   125 



   126 	if (layerEnable & 0x0400)



   127 	{



   128 		int changed = gfxBG2Changed;



   129 		if (gfxLastVCOUNT > VCOUNT)



   130 			changed = 3;



   131 



   132 		gfxDrawRotScreen(BG2CNT, BG2X_L, BG2X_H, BG2Y_L, BG2Y_H,



   133 		                 BG2PA, BG2PB, BG2PC, BG2PD, gfxBG2X, gfxBG2Y,



   134 		                 changed, line2);



   135 	}



   136 



   137 	if (layerEnable & 0x0800)



   138 	{



   139 		int changed = gfxBG3Changed;



   140 		if (gfxLastVCOUNT > VCOUNT)



   141 			changed = 3;



   142 



   143 		gfxDrawRotScreen(BG3CNT, BG3X_L, BG3X_H, BG3Y_L, BG3Y_H,



   144 		                 BG3PA, BG3PB, BG3PC, BG3PD, gfxBG3X, gfxBG3Y,



   145 		                 changed, line3);



   146 	}



   147 



   148 	gfxDrawSprites(lineOBJ);



   149 



   150 	u32 backdrop = (READ16LE(&palette[0]) | 0x30000000);



   151 



   152 	for (int x = 0; x < 240; x++)



   153 	{



   154 		u32 color = backdrop;



   155 		u8  top   = 0x20;



   156 



   157 		if ((u8)(line2[x]>>24) < (u8)(color >> 24))



   158 		{



   159 			color = line2[x];



   160 			top   = 0x04;



   161 		}



   162 



   163 		if ((u8)(line3[x]>>24) < (u8)(color >> 24))



   164 		{



   165 			color = line3[x];



   166 			top   = 0x08;



   167 		}



   168 



   169 		if ((u8)(lineOBJ[x]>>24) < (u8)(color >> 24))



   170 		{



   171 			color = lineOBJ[x];



   172 			top   = 0x10;



   173 		}



   174 



   175 		if (!(color & 0x00010000))



   176 		{



   177 			switch ((BLDMOD >> 6) & 3)



   178 			{



   179 			case 0:



   180 				break;



   181 			case 1:



   182 			{



   183 				if (top & BLDMOD)



   184 				{



   185 					u32 back = backdrop;



   186 					u8  top2 = 0x20;



   187 



   188 					if ((u8)(line2[x]>>24) < (u8)(back >> 24))



   189 					{



   190 						if (top != 0x04)



   191 						{



   192 							back = line2[x];



   193 							top2 = 0x04;



   194 						}



   195 					}



   196 



   197 					if ((u8)(line3[x]>>24) < (u8)(back >> 24))



   198 					{



   199 						if (top != 0x08)



   200 						{



   201 							back = line3[x];



   202 							top2 = 0x08;



   203 						}



   204 					}



   205 



   206 					if ((u8)(lineOBJ[x]>>24) < (u8)(back >> 24))



   207 					{



   208 						if (top != 0x10)



   209 						{



   210 							back = lineOBJ[x];



   211 							top2 = 0x10;



   212 						}



   213 					}



   214 



   215 					if (top2 & (BLDMOD>>8))



   216 						color = gfxAlphaBlend(color, back,



   217 						                      coeff[COLEV & 0x1F],



   218 						                      coeff[(COLEV >> 8) & 0x1F]);



   219 				}



   220 				break;



   221 			}



   222 			case 2:



   223 				if (BLDMOD & top)



   224 					color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



   225 				break;



   226 			case 3:



   227 				if (BLDMOD & top)



   228 					color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   229 				break;



   230 			}



   231 		}



   232 		else



   233 		{



   234 			// semi-transparent OBJ



   235 			u32 back = backdrop;



   236 			u8  top2 = 0x20;



   237 



   238 			if ((u8)(line2[x]>>24) < (u8)(back >> 24))



   239 			{



   240 				back = line2[x];



   241 				top2 = 0x04;



   242 			}



   243 



   244 			if ((u8)(line3[x]>>24) < (u8)(back >> 24))



   245 			{



   246 				back = line3[x];



   247 				top2 = 0x08;



   248 			}



   249 



   250 			if (top2 & (BLDMOD>>8))



   251 				color = gfxAlphaBlend(color, back,



   252 				                      coeff[COLEV & 0x1F],



   253 				                      coeff[(COLEV >> 8) & 0x1F]);



   254 			else



   255 			{



   256 				switch ((BLDMOD >> 6) & 3)



   257 				{



   258 				case 2:



   259 					if (BLDMOD & top)



   260 						color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



   261 					break;



   262 				case 3:



   263 					if (BLDMOD & top)



   264 						color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   265 					break;



   266 				}



   267 			}



   268 		}



   269 



   270 		lineMix[x] = color;



   271 	}



   272 	gfxBG2Changed = 0;



   273 	gfxBG3Changed = 0;



   274 	gfxLastVCOUNT = VCOUNT;



   275 }



   276 



   277 void mode2RenderLineAll()



   278 {



   279 	u16 *palette = (u16 *)paletteRAM;



   280 



   281 	if (DISPCNT & 0x80)



   282 	{



   283 		for (int x = 0; x < 240; x++)



   284 		{



   285 			lineMix[x] = 0x7fff;



   286 		}



   287 		gfxLastVCOUNT = VCOUNT;



   288 		return;



   289 	}



   290 



   291 	bool inWindow0 = false;



   292 	bool inWindow1 = false;



   293 



   294 	if (layerEnable & 0x2000)



   295 	{



   296 		u8 v0 = WIN0V >> 8;



   297 		u8 v1 = WIN0V & 255;



   298 		inWindow0 = ((v0 == v1) && (v0 >= 0xe8));



   299 		if (v1 >= v0)



   300 			inWindow0 |= (VCOUNT >= v0 && VCOUNT < v1);



   301 		else



   302 			inWindow0 |= (VCOUNT >= v0 || VCOUNT < v1);



   303 	}



   304 	if (layerEnable & 0x4000)



   305 	{



   306 		u8 v0 = WIN1V >> 8;



   307 		u8 v1 = WIN1V & 255;



   308 		inWindow1 = ((v0 == v1) && (v0 >= 0xe8));



   309 		if (v1 >= v0)



   310 			inWindow1 |= (VCOUNT >= v0 && VCOUNT < v1);



   311 		else



   312 			inWindow1 |= (VCOUNT >= v0 || VCOUNT < v1);



   313 	}



   314 



   315 	if (layerEnable & 0x0400)



   316 	{



   317 		int changed = gfxBG2Changed;



   318 		if (gfxLastVCOUNT > VCOUNT)



   319 			changed = 3;



   320 



   321 		gfxDrawRotScreen(BG2CNT, BG2X_L, BG2X_H, BG2Y_L, BG2Y_H,



   322 		                 BG2PA, BG2PB, BG2PC, BG2PD, gfxBG2X, gfxBG2Y,



   323 		                 changed, line2);



   324 	}



   325 



   326 	if (layerEnable & 0x0800)



   327 	{



   328 		int changed = gfxBG3Changed;



   329 		if (gfxLastVCOUNT > VCOUNT)



   330 			changed = 3;



   331 



   332 		gfxDrawRotScreen(BG3CNT, BG3X_L, BG3X_H, BG3Y_L, BG3Y_H,



   333 		                 BG3PA, BG3PB, BG3PC, BG3PD, gfxBG3X, gfxBG3Y,



   334 		                 changed, line3);



   335 	}



   336 



   337 	gfxDrawSprites(lineOBJ);



   338 	gfxDrawOBJWin(lineOBJWin);



   339 



   340 	u32 backdrop = (READ16LE(&palette[0]) | 0x30000000);



   341 



   342 	u8 inWin0Mask = WININ & 0xFF;



   343 	u8 inWin1Mask = WININ >> 8;



   344 	u8 outMask    = WINOUT & 0xFF;



   345 



   346 	for (int x = 0; x < 240; x++)



   347 	{



   348 		u32 color = backdrop;



   349 		u8  top   = 0x20;



   350 		u8  mask  = outMask;



   351 



   352 		if (!(lineOBJWin[x] & 0x80000000))



   353 		{



   354 			mask = WINOUT >> 8;



   355 		}



   356 



   357 		if (inWindow1)



   358 		{



   359 			if (gfxInWin1[x])



   360 				mask = inWin1Mask;



   361 		}



   362 



   363 		if (inWindow0)



   364 		{



   365 			if (gfxInWin0[x])



   366 			{



   367 				mask = inWin0Mask;



   368 			}



   369 		}



   370 



   371 		if (line2[x] < color && (mask & 4))



   372 		{



   373 			color = line2[x];



   374 			top   = 0x04;



   375 		}



   376 



   377 		if ((u8)(line3[x]>>24) < (u8)(color >> 24) && (mask & 8))



   378 		{



   379 			color = line3[x];



   380 			top   = 0x08;



   381 		}



   382 



   383 		if ((u8)(lineOBJ[x]>>24) < (u8)(color >> 24) && (mask & 16))



   384 		{



   385 			color = lineOBJ[x];



   386 			top   = 0x10;



   387 		}



   388 



   389 		if (mask & 32)



   390 		{



   391 			if (!(color & 0x00010000))



   392 			{



   393 				switch ((BLDMOD >> 6) & 3)



   394 				{



   395 				case 0:



   396 					break;



   397 				case 1:



   398 				{



   399 					if (top & BLDMOD)



   400 					{



   401 						u32 back = backdrop;



   402 						u8  top2 = 0x20;



   403 



   404 						if ((mask & 4) && line2[x] < back)



   405 						{



   406 							if (top != 0x04)



   407 							{



   408 								back = line2[x];



   409 								top2 = 0x04;



   410 							}



   411 						}



   412 



   413 						if ((mask & 8) && (u8)(line3[x]>>24) < (u8)(back >> 24))



   414 						{



   415 							if (top != 0x08)



   416 							{



   417 								back = line3[x];



   418 								top2 = 0x08;



   419 							}



   420 						}



   421 



   422 						if ((mask & 16) && (u8)(lineOBJ[x]>>24) < (u8)(back >> 24))



   423 						{



   424 							if (top != 0x10)



   425 							{



   426 								back = lineOBJ[x];



   427 								top2 = 0x10;



   428 							}



   429 						}



   430 



   431 						if (top2 & (BLDMOD>>8))



   432 							color = gfxAlphaBlend(color, back,



   433 							                      coeff[COLEV & 0x1F],



   434 							                      coeff[(COLEV >> 8) & 0x1F]);



   435 					}



   436 					break;



   437 				}



   438 				case 2:



   439 					if (BLDMOD & top)



   440 						color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



   441 					break;



   442 				case 3:



   443 					if (BLDMOD & top)



   444 						color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   445 					break;



   446 				}



   447 			}



   448 			else



   449 			{



   450 				// semi-transparent OBJ



   451 				u32 back = backdrop;



   452 				u8  top2 = 0x20;



   453 



   454 				if ((mask & 4) && line2[x] < back)



   455 				{



   456 					back = line2[x];



   457 					top2 = 0x04;



   458 				}



   459 



   460 				if ((mask & 8) && (u8)(line3[x]>>24) < (u8)(back >> 24))



   461 				{



   462 					back = line3[x];



   463 					top2 = 0x08;



   464 				}



   465 



   466 				if (top2 & (BLDMOD>>8))



   467 					color = gfxAlphaBlend(color, back,



   468 					                      coeff[COLEV & 0x1F],



   469 					                      coeff[(COLEV >> 8) & 0x1F]);



   470 				else



   471 				{



   472 					switch ((BLDMOD >> 6) & 3)



   473 					{



   474 					case 2:



   475 						if (BLDMOD & top)



   476 							color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



   477 						break;



   478 					case 3:



   479 						if (BLDMOD & top)



   480 							color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   481 						break;



   482 					}



   483 				}



   484 			}



   485 		}



   486 		else if (color & 0x00010000)



   487 		{



   488 			// semi-transparent OBJ



   489 			u32 back = backdrop;



   490 			u8  top2 = 0x20;



   491 



   492 			if ((mask & 4) && line2[x] < back)



   493 			{



   494 				back = line2[x];



   495 				top2 = 0x04;



   496 			}



   497 



   498 			if ((mask & 8) && (u8)(line3[x]>>24) < (u8)(back >> 24))



   499 			{



   500 				back = line3[x];



   501 				top2 = 0x08;



   502 			}



   503 



   504 			if (top2 & (BLDMOD>>8))



   505 				color = gfxAlphaBlend(color, back,



   506 				                      coeff[COLEV & 0x1F],



   507 				                      coeff[(COLEV >> 8) & 0x1F]);



   508 			else



   509 			{



   510 				switch ((BLDMOD >> 6) & 3)



   511 				{



   512 				case 2:



   513 					if (BLDMOD & top)



   514 						color = gfxIncreaseBrightness(color, coeff[COLY & 0x1F]);



   515 					break;



   516 				case 3:



   517 					if (BLDMOD & top)



   518 						color = gfxDecreaseBrightness(color, coeff[COLY & 0x1F]);



   519 					break;



   520 				}



   521 			}



   522 		}



   523 



   524 		lineMix[x] = color;



   525 	}



   526 	gfxBG2Changed = 0;



   527 	gfxBG3Changed = 0;



   528 	gfxLastVCOUNT = VCOUNT;



   529 }



   530