[Cine-cvs] cruisE/src mainDraw.c,1.35,1.36

[Richard <tri...@us...>]

Update of /cvsroot/cine/cruisE/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv9657/src

Modified Files:
	mainDraw.c 
Log Message:
more cleanup (work in progress)

Index: mainDraw.c
===================================================================
RCS file: /cvsroot/cine/cruisE/src/mainDraw.c,v
retrieving revision 1.35
retrieving revision 1.36
diff -C2 -d -r1.35 -r1.36
*** mainDraw.c	31 Oct 2005 12:47:05 -0000	1.35
--- mainDraw.c	31 Oct 2005 17:39:03 -0000	1.36
***************
*** 120,133 ****
  }
  
! int flipLeftRight;
  int modelVar2;
! int modelVar3;
! int modelVar4;
! int modelVar5;
! int modelVar6;
! int modelVar7;
! int modelVar8;
! int modelVar9;
! int modelVar10;
  int modelVar11;
  
--- 120,133 ----
  }
  
! int m_flipLeftRight;
  int modelVar2;
! int m_lowerX;
! int m_lowerY;
! int m_coordCount;
! int m_first_X;
! int m_first_Y;
! int m_scaleValue;
! int m_current_X;
! int m_current_Y;
  int modelVar11;
  
***************
*** 138,150 ****
  
  // this function fills the sizeTable for the poly (OLD: mainDrawSub1Sub2)
! void getPolySize(int X, int Y, int scale, int sizeTable[4], unsigned char* dataPtr)
  {
  	int upperBorder;
  	int lowerBorder;
! 	flipLeftRight = 0;
  
  	if(scale < 0) // flip left right
  	{
! 		flipLeftRight = 1;
  		scale         = -scale;
  	}
--- 138,150 ----
  
  // this function fills the sizeTable for the poly (OLD: mainDrawSub1Sub2)
! void getPolySize(int spacingX, int spacingY, int scale, int sizeTable[4], unsigned char* dataPtr)
  {
  	int upperBorder;
  	int lowerBorder;
! 	m_flipLeftRight = 0;
  
  	if(scale < 0) // flip left right
  	{
! 		m_flipLeftRight = 1;
  		scale         = -scale;
  	}
***************
*** 154,158 ****
  	upperBorder = *(dataPtr + 3);
  
! 	if(flipLeftRight)
  	{
  		upperBorder = -upperBorder;
--- 154,158 ----
  	upperBorder = *(dataPtr + 3);
  
! 	if(m_flipLeftRight)
  	{
  		upperBorder = -upperBorder;
***************
*** 160,164 ****
  	
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder -= X;
  	upperBorder  = -upperBorder;
  	lowerBorder  =  upperBorder;
--- 160,164 ----
  	
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder -= spacingX;
  	upperBorder  = -upperBorder;
  	lowerBorder  =  upperBorder;
***************
*** 167,173 ****
  
  	upperBorder  = *(dataPtr + 1);
! 	upperBorder -= *(dataPtr + 3) ;
  
! 	if(flipLeftRight)
  	{
  		upperBorder = -upperBorder;
--- 167,173 ----
  
  	upperBorder  = *(dataPtr + 1);
! 	upperBorder -= *(dataPtr + 3);
  
! 	if(m_flipLeftRight)
  	{
  		upperBorder = -upperBorder;
***************
*** 175,179 ****
  
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder += X;
  
  	if(upperBorder < lowerBorder)	// exchange borders if lower > upper
--- 175,179 ----
  
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder += spacingX;
  
  	if(upperBorder < lowerBorder)	// exchange borders if lower > upper
***************
*** 191,195 ****
  	upperBorder  = *(dataPtr + 4);
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder -= Y;
  	upperBorder  = -upperBorder;
  	lowerBorder  = upperBorder;
--- 191,195 ----
  	upperBorder  = *(dataPtr + 4);
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder -= spacingY;
  	upperBorder  = -upperBorder;
  	lowerBorder  = upperBorder;
***************
*** 200,204 ****
  	upperBorder -= *(dataPtr + 4);
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder += Y;
  
  	if(upperBorder < lowerBorder)	// exchange borders if lower > upper
--- 200,204 ----
  	upperBorder -= *(dataPtr + 4);
  	upperBorder  = (upscaleValue(upperBorder, scale) + 0x8000) >> 16;
! 	upperBorder += spacingY;
  
  	if(upperBorder < lowerBorder)	// exchange borders if lower > upper
***************
*** 401,419 ****
  }
  
! char* drawPolyMode1(char* si, int cx)
  {
  	int index;
  	s16* pBufferDest;
  
! 	polyVar1 = cx;
  
  	pBufferDest = &polyBuffer4[polyVar1 * 2];
  
! 	index = *(si++);
  
! 	polySize1 = polySize2 = pBufferDest[-2] = pBufferDest[-2 + cx * 2] = polyBuffer2[index * 2];
! 	polySize1 = polySize2 = pBufferDest[-1] = pBufferDest[-1 + cx * 2] = polyBuffer2[(index * 2) + 1];
  
! 	cx--;
  
  	pBufferDest -= 2;
--- 401,419 ----
  }
  
! char* drawPolyMode1(char* dataPointer, int curValue)
  {
  	int index;
  	s16* pBufferDest;
  
! 	polyVar1 = curValue;
  
  	pBufferDest = &polyBuffer4[polyVar1 * 2];
  
! 	index = *(dataPointer++);
  
! 	polySize1 = polySize2 = pBufferDest[-2] = pBufferDest[-2 + curValue * 2] = polyBuffer2[index * 2];
! 	polySize1 = polySize2 = pBufferDest[-1] = pBufferDest[-1 + curValue * 2] = polyBuffer2[(index * 2) + 1];
  
! 	curValue--;
  
  	pBufferDest -= 2;
***************
*** 425,436 ****
  		int value;
  
! 		index = *(si++);
  		value = pBufferDest[-2] = pBufferDest[-2 + polyVar1 * 2] = polyBuffer2[index * 2];
  		
! 		if( value < polySize1 )
  		{
  			polySize1 = value;
  		}
! 		if( value > polySize2 )
  		{
  			polySize2 = value;
--- 425,436 ----
  		int value;
  
! 		index = *(dataPointer++);
  		value = pBufferDest[-2] = pBufferDest[-2 + polyVar1 * 2] = polyBuffer2[index * 2];
  		
! 		if(value < polySize1)
  		{
  			polySize1 = value;
  		}
! 		if(value > polySize2)
  		{
  			polySize2 = value;
***************
*** 450,461 ****
  		pBufferDest -= 2;
  
! 	} while(--cx);
  
  	drawPolySub();
  
! 	return si;
  }
  
! char* drawPolyMode2(char* si, int cx)
  {
  	int index;
--- 450,461 ----
  		pBufferDest -= 2;
  
! 	} while(--curValue);
  
  	drawPolySub();
  
! 	return dataPointer;
  }
  
! char* drawPolyMode2(char* dataPointer, int curValue)
  {
  	int index;
***************
*** 463,475 ****
  
  	pBufferDest = polyBuffer4;
! 	polyVar1    = cx;
  	polyVar2    = polyBuffer4;
  
! 	index = *(si++);
  
! 	polySize1 = polySize2 = pBufferDest[0] = pBufferDest[cx * 2]     = polyBuffer2[index * 2];
! 	polySize1 = polySize2 = pBufferDest[1] = pBufferDest[cx * 2 + 1] = polyBuffer2[(index * 2) + 1];
  
! 	cx--;
  
  	pBufferDest += 2;
--- 463,475 ----
  
  	pBufferDest = polyBuffer4;
! 	polyVar1    = curValue;
  	polyVar2    = polyBuffer4;
  
! 	index = *(dataPointer++);
  
! 	polySize1 = polySize2 = pBufferDest[0] = pBufferDest[curValue * 2]     = polyBuffer2[index * 2];
! 	polySize1 = polySize2 = pBufferDest[1] = pBufferDest[curValue * 2 + 1] = polyBuffer2[(index * 2) + 1];
  
! 	curValue--;
  
  	pBufferDest += 2;
***************
*** 479,483 ****
  		int value;
  
! 		index = *(si++);
  		value = pBufferDest[0] = pBufferDest[polyVar1 * 2] = polyBuffer2[index * 2];
  		
--- 479,483 ----
  		int value;
  
! 		index = *(dataPointer++);
  		value = pBufferDest[0] = pBufferDest[polyVar1 * 2] = polyBuffer2[index * 2];
  		
***************
*** 505,690 ****
  		pBufferDest += 2;
  
! 	} while(--cx);
  
  	drawPolySub();
  
! 	return si;
  }
  
  // parse all
! void mainDrawSub1Sub5(int X, int Y, int scale, char* ptr2, char* destBuffer, char* dataPtr)
  {
! 	int cx;
! 	int ax;
! 	int temp;
! 	int bx;
! 	int dx;
  	unsigned char* dataPointer = dataPtr;
! 	s16* si2;
! 	s16* di = polyBuffer;
! 
! 	polyOutputBuffer = destBuffer;
  
! 	flipLeftRight = 0;
! 	modelVar2     = 0;
! 	modelVar3     = *(dataPointer + 3);
! 	modelVar4     = *(dataPointer + 4);
  
  	if(scale < 0)
  	{
! 		scale         = -scale;
! 		flipLeftRight = 1;
  	}
  
! 	if(scale < 0x180)	// 384
  	{
! 		modelVar2 = 1;
  	}
! 
! 	dataPointer += 5;
! 
! 	modelVar5 = (*(dataPointer++)) + 1;
! 	modelVar6 =  *(dataPointer++);
! 	modelVar7 =  *(dataPointer++);
! 
! 	di[0] = 0;
! 	di[1] = 0;
! 	di   += 2;
! 	cx    = modelVar5 - 2;
! 	bx    = 0;
! 	dx    = 0;
! 
! 	do
! 	{
! 		ax  = *(dataPointer++);
! 		ax -= modelVar6;
! 		
! 		if(modelVar2)
! 		{
! 			ax >>= 1;
! 		}
! 
! 		bx  -= ax;
! 		temp = ax;
! 		ax   = bx;
! 		bx   = temp;
! 
! 		di[0] = ax;
! 		di++;
! 		ax  = *(dataPointer++);
! 		ax -= modelVar7;
! 		
! 		if(modelVar2)
! 		{
! 			ax >>= 1;
! 		}
! 		dx -= ax;
! 		dx  = -dx;
! 
! 		temp = ax;
! 		ax   = dx;
! 		dx   = temp;
! 
! 		di[0] = ax;
! 		di++;
! 
! 	} while(--cx);
! 
! 	ax = scale;
! 	
! 	if(modelVar2)
  	{
! 		ax <<= 1;
  	}
  
! 	modelVar8 = ax;
  
! 	ax = modelVar3 - modelVar6;
  
  	if(modelVar2)
  	{
! 		ax >>= 1;
  	}
! 	if(flipLeftRight)
  	{
! 		ax = -ax;
  	}
  
! 	X -= (upscaleValue(ax, modelVar8) + 0x8000) >> 16;
  
! 	ax = modelVar4 - modelVar7;
  
! 	if(modelVar2)
  	{
! 		ax >>= 1;
! 	}
  
! 	Y -= (upscaleValue(ax, modelVar8)+ 0x8000) >> 16;
  
! 	si2 = polyBuffer;
! 	di  = polyBuffer2;
  
! 	di[0] = si2[0] + X;
! 	di[1] = si2[1] + Y;
  
! 	di  += 2;
! 	si2 += 2;
  
! 	cx         = modelVar5 - 2;
! 	modelVar9  = 0;
! 	modelVar10 = 0;
  
  	do
  	{
! 		ax = si2[0];
  		
! 		if(flipLeftRight == 0)
  		{
! 			ax = -ax;
  		}
  
  		//////////////////
- /*		{
- 			int x1;
- 			int y1;
  
! 			x1 = upscaleValue(ax, modelVar8);
! 			
! 			modelVar9 += x1;
! 			di[0] = ((modelVar9 + 0x8000) >> 16) + X;
  
! 			ax = si2[1];
! 			y1  = upscaleValue(ax, modelVar8);
! 			modelVar10 += y1;
! 			di[1] = ((modelVar10 + 0x8000) >> 16) + Y;
! 		}
! */
! 		{
! 			modelVar9 += upscaleValue(ax, modelVar8);
! 			di[0] = ((modelVar9 + 0x8000) >> 16) + X;
  
- 			modelVar10 += upscaleValue(si2[1], modelVar8);
- 			di[1] = ((modelVar10 + 0x8000) >> 16) + Y;
- 		}
  		/////////////////
  
! 		di  += 2;
! 		si2 += 2;
  
! 	} while(--cx);
  
  	do
  	{
! 		ax = *(dataPointer++);
! 		cx = ax;
  
! 		if(cx > 1)
  		{
  			u16 tempU16;
  
! 			modelVar11 = *dataPointer;
  			dataPointer += 2;
  
! 			tempU16 = *(u16*)(dataPointer);
  			dataPointer += 2;
  
--- 505,664 ----
  		pBufferDest += 2;
  
! 	} while(--curValue);
  
  	drawPolySub();
  
! 	return dataPointer;
  }
  
  // parse all
! void mainDrawSub1Sub5(int spacingX, int spacingY, int scale, char* ptr2, char* destBuffer, char* dataPtr)
  {
! 	int counter				   = 0;						// numbers of coordinates to process
! 	int startX				   = 0;						// first X in model
! 	int startY				   = 0;						// first Y in model
! 	int x					   = 0;						// current X
! 	int y					   = 0;						// current Y
! 	int offsetXinModel         = 0;						// offset of the X value in the model
! 	int offsetYinModel         = 0;						// offset of the Y value in the model
  	unsigned char* dataPointer = dataPtr;
! 	s16* ptrPoly_1_Buf         = polyBuffer;
! 	s16* ptrPoly_2_Buf;
! 	polyOutputBuffer		   = destBuffer;			// global
  
! 	m_flipLeftRight = 0;
! 	modelVar2       = 0;
! 	m_lowerX        = *(dataPointer + 3);
! 	m_lowerY        = *(dataPointer + 4);
  
  	if(scale < 0)
  	{
! 		scale           = -scale;		// flip left right
! 		m_flipLeftRight = 1;
  	}
  
! 	if(scale < 0x180)					// If scale is smaller than 384
  	{
! 		modelVar2    = 1;
! 		m_scaleValue = scale << 1;		// double scale
  	}
! 	else
  	{
! 		m_scaleValue = scale;
  	}
  
! 	dataPointer += 5;
  
! 	m_coordCount = (*(dataPointer++)) + 1;
! 	m_first_X    =  *(dataPointer++);
! 	m_first_Y    =  *(dataPointer++);
! 	startX		 = m_lowerX - m_first_X;
! 	startY		 = m_lowerY - m_first_Y;
  
  	if(modelVar2)
  	{
! 		startX >>= 1;
! 		startY >>= 1;
  	}
! 	
! 	if(m_flipLeftRight)
  	{
! 		startX = -startX;
  	}
  
! 	/*
! 		NOTE:
  
! 		The original code continues here with using X, Y instead of startX and StartY.
! 		Since X, Y are actually spacing values it makes more sense to use startX and startY.
! 		
! 		Original code:
! 		X -= (upscaleValue(startX, m_scaleValue) + 0x8000) >> 16;
! 		Y -= (upscaleValue(startX, m_scaleValue) + 0x8000) >> 16;
! 	*/
! 	
! 	// get coordinates from data
  
! 	startX = spacingX - ((upscaleValue(startX, m_scaleValue) + 0x8000) >> 16);
! 	startY = spacingY - ((upscaleValue(startY, m_scaleValue) + 0x8000) >> 16);
! 	
! 	ptrPoly_1_Buf[0] = 0;
! 	ptrPoly_1_Buf[1] = 0;
! 	ptrPoly_1_Buf   += 2;
! 	counter          = m_coordCount - 2;	// skip the first two, we already have the values
! 
! 	do
  	{
! 		// X
  
! 		x = *(dataPointer++) - m_first_X;
! 		y = *(dataPointer++) - m_first_Y;
! 		
! 		if(modelVar2)
! 		{
! 			x >>= 1;		// scale down?
! 			y >>= 1;		// scale down?
! 		}
  
! 		ptrPoly_1_Buf[0] = offsetXinModel - x;
! 		ptrPoly_1_Buf++;
! 		offsetXinModel = x;
! 		
! 		ptrPoly_1_Buf[0] = (offsetYinModel - y) * -1;
! 		ptrPoly_1_Buf++;
! 		offsetYinModel = y;
  
! 	} while(--counter);
  
! 	// scale and adjust coordinates with offset (using two polybuffers by doing that)
  
! 	/*
! 		NOTE: Is there a need for having two, a scaled and unscaled polybuffer?
! 	*/
! 	
! 	ptrPoly_2_Buf = polyBuffer;
! 	ptrPoly_1_Buf = polyBuffer2;
! 	counter       = m_coordCount;		// reset counter
! 	m_current_X   = 0;
! 	m_current_Y   = 0;
  
  	do
  	{
! 		x = ptrPoly_2_Buf[0];
  		
! 		if(m_flipLeftRight == 0)
  		{
! 			 x = -x;
  		}
  
  		//////////////////
  
! 		m_current_X     += upscaleValue(x, m_scaleValue);
! 		ptrPoly_1_Buf[0] = ((m_current_X + 0x8000) >> 16) + startX;			// adjust X value with start offset
  
! 		m_current_Y     += upscaleValue(ptrPoly_2_Buf[1], m_scaleValue);
! 		ptrPoly_1_Buf[1] = ((m_current_Y + 0x8000) >> 16) + startY;			// adjust Y value with start offset
  
  		/////////////////
  
! 		ptrPoly_1_Buf += 2;
! 		ptrPoly_2_Buf += 2;
  
! 	} while(--counter);
! 	
! 	// position of the dataPointer is m_coordCount * 2
  
  	do
  	{
! 		int curValue = *dataPointer++;				// some sort of index I guess?
  
! 		if(curValue > 1)							// if value not zero
  		{
  			u16 tempU16;
  
! 			modelVar11   = *dataPointer;			// put current value into modelVar11
  			dataPointer += 2;
  
! 			tempU16      = *(u16*) (dataPointer);
  			dataPointer += 2;
  
***************
*** 693,697 ****
  			if(tempU16 > scale)
  			{
! 				dataPointer += cx;
  				
  				if(*dataPointer == 0xFF)
--- 667,671 ----
  			if(tempU16 > scale)
  			{
! 				dataPointer += curValue;
  				
  				if(*dataPointer == 0xFF)
***************
*** 702,712 ****
  			else
  			{
! 				if(flipLeftRight)
  				{
! 					dataPointer = drawPolyMode1(dataPointer, cx);
  				}
  				else
  				{
! 					dataPointer = drawPolyMode2(dataPointer, cx);
  				}
  
--- 676,686 ----
  			else
  			{
! 				if(m_flipLeftRight)
  				{
! 					dataPointer = drawPolyMode1(dataPointer, curValue);
  				}
  				else
  				{
! 					dataPointer = drawPolyMode2(dataPointer, curValue);
  				}
  
***************
*** 715,723 ****
  					if(ptr2)
  					{
! 						blitPolyMode1(destBuffer, ptr2, polyBuffer3, modelVar11&0xF);
  					}
  					else
  					{
! 						blitPolyMode2(destBuffer, polyBuffer3, modelVar11&0xF);
  					}
  				}
--- 689,697 ----
  					if(ptr2)
  					{
! 						blitPolyMode1(destBuffer, ptr2, polyBuffer3, modelVar11 & 0xF);
  					}
  					else
  					{
! 						blitPolyMode2(destBuffer, polyBuffer3, modelVar11 & 0xF);
  					}
  				}
***************
*** 731,736 ****
  		else
  		{
! 			cx          += 4;
! 			dataPointer += cx;
  			
  			if(*dataPointer == 0xFF)
--- 705,709 ----
  		else
  		{
! 			dataPointer += 4;
  			
  			if(*dataPointer == 0xFF)