Mercurial > vba-linux

view src/gba/Mode1.cpp @ 37:9eae224b8056 recording-sans-reset

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
reseting the movie does not appear to work
author Robert McIntyre <rlm@mit.edu>
date Mon, 05 Mar 2012 14:51:43 -0600
parents f9f4f1b99eed
children
line wrap: on
line source
     1 #include "GBAGfx.h"



     2 #include "GBAGlobals.h"



     3 



     4 void mode1RenderLine()



     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 & 0x0100)



    19 	{



    20 		gfxDrawTextScreen(BG0CNT, BG0HOFS, BG0VOFS, line0);



    21 	}



    22 



    23 	if (layerEnable & 0x0200)



    24 	{



    25 		gfxDrawTextScreen(BG1CNT, BG1HOFS, BG1VOFS, line1);



    26 	}



    27 



    28 	if (layerEnable & 0x0400)



    29 	{



    30 		int changed = gfxBG2Changed;



    31 		if (gfxLastVCOUNT > VCOUNT)



    32 			changed = 3;



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



    34 		                 BG2PA, BG2PB, BG2PC, BG2PD,



    35 		                 gfxBG2X, gfxBG2Y, changed, line2);



    36 	}



    37 



    38 	gfxDrawSprites(lineOBJ);



    39 



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



    41 



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



    43 	{



    44 		u32 color = backdrop;



    45 		u8  top   = 0x20;



    46 



    47 		if (line0[x] < color)



    48 		{



    49 			color = line0[x];



    50 			top   = 0x01;



    51 		}



    52 



    53 		if ((u8)(line1[x]>>24) < (u8)(color >> 24))



    54 		{



    55 			color = line1[x];



    56 			top   = 0x02;



    57 		}



    58 



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



    60 		{



    61 			color = line2[x];



    62 			top   = 0x04;



    63 		}



    64 



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



    66 		{



    67 			color = lineOBJ[x];



    68 			top   = 0x10;



    69 		}



    70 



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



    72 		{



    73 			// semi-transparent OBJ



    74 			u32 back = backdrop;



    75 			u8  top2 = 0x20;



    76 



    77 			if ((u8)(line0[x]>>24) < (u8)(back >> 24))



    78 			{



    79 				back = line0[x];



    80 				top2 = 0x01;



    81 			}



    82 



    83 			if ((u8)(line1[x]>>24) < (u8)(back >> 24))



    84 			{



    85 				back = line1[x];



    86 				top2 = 0x02;



    87 			}



    88 



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



    90 			{



    91 				back = line2[x];



    92 				top2 = 0x04;



    93 			}



    94 



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



    96 				color = gfxAlphaBlend(color, back,



    97 				                      coeff[COLEV & 0x1F],



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



    99 			else



   100 			{



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



   102 				{



   103 				case 2:



   104 					if (BLDMOD & top)



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



   106 					break;



   107 				case 3:



   108 					if (BLDMOD & top)



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



   110 					break;



   111 				}



   112 			}



   113 		}



   114 



   115 		lineMix[x] = color;



   116 	}



   117 	gfxBG2Changed = 0;



   118 	gfxLastVCOUNT = VCOUNT;



   119 }



   120 



   121 void mode1RenderLineNoWindow()



   122 {



   123 	u16 *palette = (u16 *)paletteRAM;



   124 



   125 	if (DISPCNT & 0x80)



   126 	{



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



   128 		{



   129 			lineMix[x] = 0x7fff;



   130 		}



   131 		gfxLastVCOUNT = VCOUNT;



   132 		return;



   133 	}



   134 



   135 	if (layerEnable & 0x0100)



   136 	{



   137 		gfxDrawTextScreen(BG0CNT, BG0HOFS, BG0VOFS, line0);



   138 	}



   139 



   140 	if (layerEnable & 0x0200)



   141 	{



   142 		gfxDrawTextScreen(BG1CNT, BG1HOFS, BG1VOFS, line1);



   143 	}



   144 



   145 	if (layerEnable & 0x0400)



   146 	{



   147 		int changed = gfxBG2Changed;



   148 		if (gfxLastVCOUNT > VCOUNT)



   149 			changed = 3;



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



   151 		                 BG2PA, BG2PB, BG2PC, BG2PD,



   152 		                 gfxBG2X, gfxBG2Y, changed, line2);



   153 	}



   154 



   155 	gfxDrawSprites(lineOBJ);



   156 



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



   158 



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



   160 	{



   161 		u32 color = backdrop;



   162 		u8  top   = 0x20;



   163 



   164 		if (line0[x] < color)



   165 		{



   166 			color = line0[x];



   167 			top   = 0x01;



   168 		}



   169 



   170 		if ((u8)(line1[x]>>24) < (u8)(color >> 24))



   171 		{



   172 			color = line1[x];



   173 			top   = 0x02;



   174 		}



   175 



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



   177 		{



   178 			color = line2[x];



   179 			top   = 0x04;



   180 		}



   181 



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



   183 		{



   184 			color = lineOBJ[x];



   185 			top   = 0x10;



   186 		}



   187 



   188 		if (!(color & 0x00010000))



   189 		{



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



   191 			{



   192 			case 0:



   193 				break;



   194 			case 1:



   195 			{



   196 				if (top & BLDMOD)



   197 				{



   198 					u32 back = backdrop;



   199 					u8  top2 = 0x20;



   200 					if ((u8)(line0[x]>>24) < (u8)(back >> 24))



   201 					{



   202 						if (top != 0x01)



   203 						{



   204 							back = line0[x];



   205 							top2 = 0x01;



   206 						}



   207 					}



   208 



   209 					if ((u8)(line1[x]>>24) < (u8)(back >> 24))



   210 					{



   211 						if (top != 0x02)



   212 						{



   213 							back = line1[x];



   214 							top2 = 0x02;



   215 						}



   216 					}



   217 



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



   219 					{



   220 						if (top != 0x04)



   221 						{



   222 							back = line2[x];



   223 							top2 = 0x04;



   224 						}



   225 					}



   226 



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



   228 					{



   229 						if (top != 0x10)



   230 						{



   231 							back = lineOBJ[x];



   232 							top2 = 0x10;



   233 						}



   234 					}



   235 



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



   237 						color = gfxAlphaBlend(color, back,



   238 						                      coeff[COLEV & 0x1F],



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



   240 				}



   241 				break;



   242 			}



   243 			case 2:



   244 				if (BLDMOD & top)



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



   246 				break;



   247 			case 3:



   248 				if (BLDMOD & top)



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



   250 				break;



   251 			}



   252 		}



   253 		else



   254 		{



   255 			// semi-transparent OBJ



   256 			u32 back = backdrop;



   257 			u8  top2 = 0x20;



   258 



   259 			if ((u8)(line0[x]>>24) < (u8)(back >> 24))



   260 			{



   261 				back = line0[x];



   262 				top2 = 0x01;



   263 			}



   264 



   265 			if ((u8)(line1[x]>>24) < (u8)(back >> 24))



   266 			{



   267 				back = line1[x];



   268 				top2 = 0x02;



   269 			}



   270 



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



   272 			{



   273 				back = line2[x];



   274 				top2 = 0x04;



   275 			}



   276 



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



   278 				color = gfxAlphaBlend(color, back,



   279 				                      coeff[COLEV & 0x1F],



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



   281 			else



   282 			{



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



   284 				{



   285 				case 2:



   286 					if (BLDMOD & top)



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



   288 					break;



   289 				case 3:



   290 					if (BLDMOD & top)



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



   292 					break;



   293 				}



   294 			}



   295 		}



   296 



   297 		lineMix[x] = color;



   298 	}



   299 	gfxBG2Changed = 0;



   300 	gfxLastVCOUNT = VCOUNT;



   301 }



   302 



   303 void mode1RenderLineAll()



   304 {



   305 	u16 *palette = (u16 *)paletteRAM;



   306 



   307 	if (DISPCNT & 0x80)



   308 	{



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



   310 		{



   311 			lineMix[x] = 0x7fff;



   312 		}



   313 		gfxLastVCOUNT = VCOUNT;



   314 		return;



   315 	}



   316 



   317 	bool inWindow0 = false;



   318 	bool inWindow1 = false;



   319 



   320 	if (layerEnable & 0x2000)



   321 	{



   322 		u8 v0 = WIN0V >> 8;



   323 		u8 v1 = WIN0V & 255;



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



   325 		if (v1 >= v0)



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



   327 		else



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



   329 	}



   330 	if (layerEnable & 0x4000)



   331 	{



   332 		u8 v0 = WIN1V >> 8;



   333 		u8 v1 = WIN1V & 255;



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



   335 		if (v1 >= v0)



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



   337 		else



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



   339 	}



   340 



   341 	if (layerEnable & 0x0100)



   342 	{



   343 		gfxDrawTextScreen(BG0CNT, BG0HOFS, BG0VOFS, line0);



   344 	}



   345 



   346 	if (layerEnable & 0x0200)



   347 	{



   348 		gfxDrawTextScreen(BG1CNT, BG1HOFS, BG1VOFS, line1);



   349 	}



   350 



   351 	if (layerEnable & 0x0400)



   352 	{



   353 		int changed = gfxBG2Changed;



   354 		if (gfxLastVCOUNT > VCOUNT)



   355 			changed = 3;



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



   357 		                 BG2PA, BG2PB, BG2PC, BG2PD,



   358 		                 gfxBG2X, gfxBG2Y, changed, line2);



   359 	}



   360 



   361 	gfxDrawSprites(lineOBJ);



   362 	gfxDrawOBJWin(lineOBJWin);



   363 



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



   365 



   366 	u8 inWin0Mask = WININ & 0xFF;



   367 	u8 inWin1Mask = WININ >> 8;



   368 	u8 outMask    = WINOUT & 0xFF;



   369 



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



   371 	{



   372 		u32 color = backdrop;



   373 		u8  top   = 0x20;



   374 		u8  mask  = outMask;



   375 



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



   377 		{



   378 			mask = WINOUT >> 8;



   379 		}



   380 



   381 		if (inWindow1)



   382 		{



   383 			if (gfxInWin1[x])



   384 				mask = inWin1Mask;



   385 		}



   386 



   387 		if (inWindow0)



   388 		{



   389 			if (gfxInWin0[x])



   390 			{



   391 				mask = inWin0Mask;



   392 			}



   393 		}



   394 



   395 		if (line0[x] < color && (mask & 1))



   396 		{



   397 			color = line0[x];



   398 			top   = 0x01;



   399 		}



   400 



   401 		if ((u8)(line1[x]>>24) < (u8)(color >> 24) && (mask & 2))



   402 		{



   403 			color = line1[x];



   404 			top   = 0x02;



   405 		}



   406 



   407 		if ((u8)(line2[x]>>24) < (u8)(color >> 24) && (mask & 4))



   408 		{



   409 			color = line2[x];



   410 			top   = 0x04;



   411 		}



   412 



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



   414 		{



   415 			color = lineOBJ[x];



   416 			top   = 0x10;



   417 		}



   418 



   419 		// special FX on the window



   420 		if (mask & 32)



   421 		{



   422 			if (!(color & 0x00010000))



   423 			{



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



   425 				{



   426 				case 0:



   427 					break;



   428 				case 1:



   429 				{



   430 					if (top & BLDMOD)



   431 					{



   432 						u32 back = backdrop;



   433 						u8  top2 = 0x20;



   434 						if ((mask & 1) && (u8)(line0[x]>>24) < (u8)(back >> 24))



   435 						{



   436 							if (top != 0x01)



   437 							{



   438 								back = line0[x];



   439 								top2 = 0x01;



   440 							}



   441 						}



   442 



   443 						if ((mask & 2) && (u8)(line1[x]>>24) < (u8)(back >> 24))



   444 						{



   445 							if (top != 0x02)



   446 							{



   447 								back = line1[x];



   448 								top2 = 0x02;



   449 							}



   450 						}



   451 



   452 						if ((mask & 4) && (u8)(line2[x]>>24) < (u8)(back >> 24))



   453 						{



   454 							if (top != 0x04)



   455 							{



   456 								back = line2[x];



   457 								top2 = 0x04;



   458 							}



   459 						}



   460 



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



   462 						{



   463 							if (top != 0x10)



   464 							{



   465 								back = lineOBJ[x];



   466 								top2 = 0x10;



   467 							}



   468 						}



   469 



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



   471 							color = gfxAlphaBlend(color, back,



   472 							                      coeff[COLEV & 0x1F],



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



   474 					}



   475 					break;



   476 				}



   477 				case 2:



   478 					if (BLDMOD & top)



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



   480 					break;



   481 				case 3:



   482 					if (BLDMOD & top)



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



   484 					break;



   485 				}



   486 			}



   487 			else



   488 			{



   489 				// semi-transparent OBJ



   490 				u32 back = backdrop;



   491 				u8  top2 = 0x20;



   492 



   493 				if ((mask & 1) && (u8)(line0[x]>>24) < (u8)(back >> 24))



   494 				{



   495 					back = line0[x];



   496 					top2 = 0x01;



   497 				}



   498 



   499 				if ((mask & 2) && (u8)(line1[x]>>24) < (u8)(back >> 24))



   500 				{



   501 					back = line1[x];



   502 					top2 = 0x02;



   503 				}



   504 



   505 				if ((mask & 4) && (u8)(line2[x]>>24) < (u8)(back >> 24))



   506 				{



   507 					back = line2[x];



   508 					top2 = 0x04;



   509 				}



   510 



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



   512 					color = gfxAlphaBlend(color, back,



   513 					                      coeff[COLEV & 0x1F],



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



   515 				else



   516 				{



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



   518 					{



   519 					case 2:



   520 						if (BLDMOD & top)



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



   522 						break;



   523 					case 3:



   524 						if (BLDMOD & top)



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



   526 						break;



   527 					}



   528 				}



   529 			}



   530 		}



   531 		else if (color & 0x00010000)



   532 		{



   533 			// semi-transparent OBJ



   534 			u32 back = backdrop;



   535 			u8  top2 = 0x20;



   536 



   537 			if ((mask & 1) && (u8)(line0[x]>>24) < (u8)(back >> 24))



   538 			{



   539 				back = line0[x];



   540 				top2 = 0x01;



   541 			}



   542 



   543 			if ((mask & 2) && (u8)(line1[x]>>24) < (u8)(back >> 24))



   544 			{



   545 				back = line1[x];



   546 				top2 = 0x02;



   547 			}



   548 



   549 			if ((mask & 4) && (u8)(line2[x]>>24) < (u8)(back >> 24))



   550 			{



   551 				back = line2[x];



   552 				top2 = 0x04;



   553 			}



   554 



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



   556 				color = gfxAlphaBlend(color, back,



   557 				                      coeff[COLEV & 0x1F],



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



   559 			else



   560 			{



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



   562 				{



   563 				case 2:



   564 					if (BLDMOD & top)



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



   566 					break;



   567 				case 3:



   568 					if (BLDMOD & top)



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



   570 					break;



   571 				}



   572 			}



   573 		}



   574 



   575 		lineMix[x] = color;



   576 	}



   577 	gfxBG2Changed = 0;



   578 	gfxLastVCOUNT = VCOUNT;



   579 }



   580