clip.cpp

SFC游戏模拟器 snes9x 1.43 的原代码

												OR_BANDS(Bands[B], Win2[0], Win1[1]);
												B++;
											}
											else
											{
												Bands[0] = Win1[0];
												Bands[1] = Win2[0];
												Bands[2] = Win1[1];
												B = 3;
											}
									}
								}
								else
								{
									// Both windows have two bands
									OR_BANDS(Bands[0], Win1[0], Win2[0]);
									OR_BANDS(Bands[1], Win1[1], Win2[1]);
									B = 1;
									if (BANDS_INTERSECT(Bands[0], Bands[1]))
										OR_BANDS(Bands[0], Bands[0], Bands[1])
									else
										B = 2;
								}
							break;

						  case CLIP_AND:
							if (Window1Enabled == 1)
							{
								// Window 1 has one band
								if (BAND_EMPTY(Win1[0]))
									Bands [B++] = Win1[0];
								else
									if (Window2Enabled == 1)
									{
										if (BAND_EMPTY (Win2[0]))
											Bands [B++] = Win2[0];
										else
										{
											AND_BANDS(Bands[0], Win1[0], Win2[0]);
											B = 1;
										}
									}
									else
									{
										AND_BANDS(Bands[0], Win1[0], Win2[0]);
										AND_BANDS(Bands[1], Win1[0], Win2[1]);
										B = 2;
									}
							}
							else
								if (Window2Enabled == 1)
								{
									if (BAND_EMPTY(Win2[0]))
										Bands[B++] = Win2[0];
									else
									{
										// Window 1 has two bands.
										AND_BANDS(Bands[0], Win1[0], Win2[0]);
										AND_BANDS(Bands[1], Win1[1], Win2[0]);
										B = 2;
									}
								}
								else
								{
									// Both windows have two bands.
									AND_BANDS(Bands[0], Win1[0], Win2[0]);
									AND_BANDS(Bands[1], Win1[1], Win2[1]);
									B = 2;
									if (BANDS_INTERSECT(Win1[0], Win2[1]))
									{
										AND_BANDS(Bands[2], Win1[0], Win2[1]);
										B = 3;
									}
									else
										if (BANDS_INTERSECT(Win1[1], Win2[0]))
										{
											AND_BANDS(Bands[2], Win1[1], Win2[0]);
											B = 3;
										}
								}
							break;
						  case CLIP_XNOR:
							invert = !invert;
							// Fall...

						  case CLIP_XOR:
							if (Window1Enabled == 1 && BAND_EMPTY(Win1[0]))
							{
								B = Window2Enabled;
								memmove (Bands, Win2,
										 sizeof(Win2[0]) * Window2Enabled);
							}
							else
								if (Window2Enabled == 1 && BAND_EMPTY(Win2[0]))
								{
									B = Window1Enabled;
									memmove (Bands, Win1,
											 sizeof(Win1[0]) * Window1Enabled);
								}
								else
								{
									uint32 p = 0;
									uint32 points [10];
									uint32 i;

									invert = !invert;
									// Build an array of points (window edges)
									points [p++] = 0;
									for (i = 0; i < Window1Enabled; i++)
									{
										points [p++] = Win1[i].Left;
										points [p++] = Win1[i].Right;
									}
									for (i = 0; i < Window2Enabled; i++)
									{
										points [p++] = Win2[i].Left;
										points [p++] = Win2[i].Right;
									}
									points [p++] = 256;
									// Sort them
									qsort ((void *) points, p, sizeof (points [0]),
										   IntCompare);
									for (i = 0; i < p; i += 2)
									{
										if (points [i] == points [i + 1])
											continue;
										Bands [B].Left = points [i];
										while (i + 2 < p && 
											   points [i + 1] == points [i + 2])
										{
											i += 2;
										}
										Bands [B++].Right = points [i + 1];
									}
								}
							break;
						}
						if (invert)
						{
							int b;
							int j = 0;
							int empty_band_count = 0;

							// First remove all empty bands from the list.
							for (b = 0; b < B; b++)
							{
								if (!BAND_EMPTY(Bands[b]))
								{
									if (b != j)
										Bands[j] = Bands[b];
									j++;
								}
								else
									empty_band_count++;
							}

							if (j > 0)
							{
								if (j == 1)
								{
									j = 0;
									// Easy case to deal with, so special case it.

									if (Bands[0].Left > 0)
									{
										pClip->Left[j][w] = 0;
										pClip->Right[j++][w] = Bands[0].Left + 1;
									}
									if (Bands[0].Right < 256)
									{
										pClip->Left[j][w] = Bands[0].Right;
										pClip->Right[j++][w] = 256;
									}
									if (j == 0)
									{
										pClip->Left[j][w] = 1;
										pClip->Right[j++][w] = 0;
									}
								}
								else
								{
									// Now sort the bands into order
									B = j;
									qsort ((void *) Bands, B,
										   sizeof (Bands [0]), BandCompare);

									// Now invert the area the bands cover
									j = 0;
									for (b = 0; b < B; b++)
									{
										if (b == 0 && Bands[b].Left > 0)
										{
											pClip->Left[j][w] = 0;
											pClip->Right[j++][w] = Bands[b].Left + 1;
										}
										else
											if (b == B - 1 && Bands[b].Right < 256)
											{
												pClip->Left[j][w] = Bands[b].Right;
												pClip->Right[j++][w] = 256;
											}
										if (b < B - 1)
										{
											pClip->Left[j][w] = Bands[b].Right;
											pClip->Right[j++][w] = Bands[b + 1].Left + 1;
										}
									}
								}
							}
							else
							{
								// Inverting a window that consisted of only
								// empty bands is the whole width of the screen.
								// Needed for Mario Kart's rear-view mirror display.
								if (empty_band_count)
								{
									pClip->Left[j][w] = 0;
									pClip->Right[j][w] = 256;
									j++;
								}
							}
							pClip->Count[w] = j;
						}
						else
						{
							for (int j = 0; j < B; j++)
							{
								pClip->Left[j][w] = Bands[j].Left;
								pClip->Right[j][w] = Bands[j].Right;
							}
							pClip->Count [w] = B;
						}
					}
					else
					{
						// Only one window enabled so no need to perform
						// complex overlap logic...

						if (Window1Enabled)
						{
							if (invert)
							{
								int j = 0;

								if (Window1Enabled == 1)
								{
									if (Win1[0].Left <= Win1[0].Right)
									{
										if (Win1[0].Left > 0)
										{
											pClip->Left[j][w] = 0;
											pClip->Right[j++][w] = Win1[0].Left;
										}
										if (Win1[0].Right < 256)
										{
											pClip->Left[j][w] = Win1[0].Right;
											pClip->Right[j++][w] = 256;
										}
										if (j == 0)
										{
											pClip->Left[j][w] = 1;
											pClip->Right[j++][w] = 0;
										}
									}
									else
									{
										pClip->Left[j][w] = 0;
										pClip->Right[j++][w] = 256;
									}
								}
								else
								{
									pClip->Left [j][w] = Win1[0].Right;
									pClip->Right[j++][w] = Win1[1].Left;
								}
								pClip->Count [w] = j;
							}
							else
							{
								for (uint32 j = 0; j < Window1Enabled; j++)
								{
									pClip->Left [j][w] = Win1[j].Left;
									pClip->Right [j][w] = Win1[j].Right;
								}
								pClip->Count [w] = Window1Enabled;
							}
						}
						else
							if (Window2Enabled)
							{
								if (invert)
								{
									int j = 0;
									if (Window2Enabled == 1)
									{
										if (Win2[0].Left <= Win2[0].Right)
										{
											if (Win2[0].Left > 0)
											{
												pClip->Left[j][w] = 0;
												pClip->Right[j++][w] = Win2[0].Left;
											}
											if (Win2[0].Right < 256)
											{
												pClip->Left[j][w] = Win2[0].Right;
												pClip->Right[j++][w] = 256;
											}
											if (j == 0)
											{
												pClip->Left[j][w] = 1;
												pClip->Right[j++][w] = 0;
											}
										}
										else
										{
											pClip->Left[j][w] = 0;
											pClip->Right[j++][w] = 256;
										}
									}
									else
									{
										pClip->Left [j][w] = Win2[0].Right;
										pClip->Right[j++][w] = Win2[1].Left + 1;
									}
									pClip->Count [w] = j;
								}
								else
								{
									for (uint32 j = 0; j < Window2Enabled; j++)
									{
										pClip->Left [j][w] = Win2[j].Left;
										pClip->Right [j][w] = Win2[j].Right;
									}
									pClip->Count [w] = Window2Enabled;
								}
							}
					}

					if (w != 5 && pClip->Count [5])
					{
						// Colour window enabled. Set the
						// clip windows for all remaining backgrounds to be
						// the same as the colour window.
						if (pClip->Count [w] == 0)
						{
							pClip->Count [w] = pClip->Count [5];
							for (uint32 i = 0; i < pClip->Count [w]; i++)
							{
								pClip->Left [i][w] = pClip->Left [i][5];
								pClip->Right [i][w] = pClip->Right [i][5];
							}
						}
						else
						{
							// Intersect the colour window with the bg's
							// own clip window.
							for (uint32 i = 0; i < pClip->Count [w]; i++)
							{
								uint32 j;
								for (j = 0; j < pClip->Count [5]; j++)
								{
									if((pClip->Left[i][w] >= pClip->Left[j][5] && pClip->Left[i][w] < pClip->Right[j][5]) || (pClip->Left[j][5] >= pClip->Left[i][w] && pClip->Left[j][5] < pClip->Right[i][w])){
										// Found an intersection!
										pClip->Left[i][w]=MAX(pClip->Left[i][w], pClip->Left[j][5]);
										pClip->Right[i][w]=MIN(pClip->Right[i][w], pClip->Right[j][5]);
										goto Clip_ok;
									}
								}
								// no intersection, nullify it
								pClip->Left[i][w]=1;
								pClip->Right[i][w]=0;
Clip_ok:
								j=0; // dummy statement
							}
						}
					}
				} // if (w == 5 | ...
			} // if (!Settings.DisableGraphicWindows)
		} // for (int w...
	} // for (int c...
}