CnC_Remastered_Collection

ROTBMP.CPP (11107B)

---

 //
 // Copyright 2020 Electronic Arts Inc.
 //
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is free 
 // software: you can redistribute it and/or modify it under the terms of 
 // the GNU General Public License as published by the Free Software Foundation, 
 // either version 3 of the License, or (at your option) any later version.
 
 // TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed 
 // in the hope that it will be useful, but with permitted additional restrictions 
 // under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT 
 // distributed with this program. You should have received a copy of the 
 // GNU General Public License along with permitted additional restrictions 
 // with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
 
 /* $Header: /CounterStrike/ROTBMP.CPP 1     3/03/97 10:25a Joe_bostic $ */
 /***********************************************************************************************
  ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
  ***********************************************************************************************
  *                                                                                             *
  *                 Project Name : Command & Conquer                                            *
  *                                                                                             *
  *                    File Name : ROTBMP.CPP                                                   *
  *                                                                                             *
  *                   Programmer : Joe L. Bostic                                                *
  *                                                                                             *
  *                   Start Date : 07/05/96                                                     *
  *                                                                                             *
  *                  Last Update : July 5, 1996 [JLB]                                           *
  *                                                                                             *
  *---------------------------------------------------------------------------------------------*
  * Functions:                                                                                  *
  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 #if (0)//PG
 //#include	"function.h"
 #include	"watcom.h"
 #include "rotbmp.h"
 #define FILE_H
 #define WWMEM_H
 #include	<wwlib32.h>
 
 
 int Rotate_Bitmap(GraphicViewPortClass * srcvp, GraphicViewPortClass * destvp, int angle);
 
 struct WPPOINT {
 	int x;
 	int y;
 };
 
 /***************************************************************************
  * Rotate_bitmap -- rotate a bitmap from srcvp to destvp                   *
  *                                                                         *
  * INPUT: note that angles are 0 - 255 (best if used in increments of 4!)  *
  *                                                                         *
  * OUTPUT:                                                                 *
  *                                                                         *
  * WARNINGS:                                                               *
  *	   destvp should be a square. width and height should be equal to : 	 	*
  * 	MAX(srcvp->width,srcvp->height) * 1.7 (square root of 2!!)    		 	*
  *																								 	*
  *																								 	*
  * HISTORY:                                                                *
  *   01/02/1996  BP : Created.                                             *
  *=========================================================================*/
 Rotate_Bitmap(GraphicViewPortClass * srcvp, GraphicViewPortClass * destvp, int a)
 {
 	int shift = 7;
 	int fixpoint1 = 1 << shift; // this is a fixed point 1
 	int Deltax;
 	int Deltay;
 	int sx,sy,dx,dy;
 	int Error = 0;
 	int Decimal = 0;
 	// this is used if I walk in Y
 	int buffwidth = srcvp->Get_Width() + srcvp->Get_XAdd();
 	int buffwid2 = destvp->Get_Width() + destvp->Get_XAdd();
 	char * dest;
 	char * src;
 	int sa,ca;
 	int t;
 	int x,y;
 	int rx,ry;
 	int w,h;
 	int dw = destvp->Get_Width();
 	int dh = destvp->Get_Height();
 	WPPOINT sp[4];
 	WPPOINT dp[4];
 	sa = Sin256[a];
 	ca = Cos256[a];
 	// get rectangle size
 	x = 0;
 	y = 0;
 	w = srcvp->Get_Width();
 	h = srcvp->Get_Height();
 
 	int halfws = w >> 1;
 	int halfhs = h >> 1;
 	int halfwd = dw >> 1;
 	int halfhd = dh >> 1;
 
 
 	// make the src rectangle
 	sp[0].x = x;
 	sp[0].y = y;
 
 	sp[1].x = x + w;
 	sp[1].y = y;
 
 	// now calculate the rotated rectangle
 	dp[0].x = ( ((sp[0].x - halfws) * ca) - ((sp[0].y - halfhs) * sa) ) >> shift;
 	dp[0].x += halfwd;
 
 	dp[0].y = ( ((sp[0].x - halfws) * sa) + ((sp[0].y - halfhs) * ca) ) >> shift;
 	dp[0].y += halfhd;
 
 	dp[1].x = ( ((sp[1].x - halfws) * ca) - ((sp[1].y - halfhs) * sa) ) >> shift;
 	dp[1].x += halfwd;
 
 	dp[1].y = ( ((sp[1].x - halfws) * sa) + ((sp[1].y - halfhs) * ca) ) >> shift;
 	dp[1].y += halfhd;
 
 	rx = dp[0].x;
 	ry = dp[0].y;
 	// now calculate slope
 
 	// diff from new to old x
 
 	Deltax = (dp[1].x - dp[0].x);
 
 	// diff from new to old y
 
 	Deltay = (dp[1].y - dp[0].y);
 
 	// handle the easy cases
 
 	// no change in x
 	int r;
 	if (!Deltax) { // must be 90 or 270 degree transpose!
 		if (Deltay < 0) {
 			// walk across source in the x + dir
 			// walk across dest in the y - dir
 
 			x = 0;
 			dy = 0;
 			dx = 0;
 			for (t = 0; t< h; t++) {
 				x = 0;
 				src = MAKE_PTR(srcvp, x, y);
 				dest = MAKE_PTR(destvp, rx + dx, ry - dy);
 				for (r = 0; r< w; r++) {
 					// transparency
 					if (* src)
 						*dest = *src;
 					src++;
 					dest -= buffwid2;
 				}
 				y++;
 				dx++;
 			}
 		} else {
 			// walk across source in the x + dir
 			// walk across dest in the y + dir
 
 			x = 0;
 			dy = 0;
 			dx = 0;
 			for (t = 0; t< h; t++) {
 				x = 0;
 				src = MAKE_PTR(srcvp, x, y);
 				dest = MAKE_PTR(destvp, rx - dx, ry + dy);
 				for (r = 0; r< w; r++) {
 					// transparency
 					if (*src)
 						*dest = *src;
 					src++;
 					dest += buffwid2;
 				}
 				y++;
 				dx++;
 			}
 		}
 		return 0;
 	}
 	// no change in y
 
 	if (!Deltay) { // must be 0 or 180 degree transpose !
 		if (Deltax < 0) {
 			y = 0;
 			for (y = 0; y< h; y++) {
 				x = 0;
 				src = MAKE_PTR(srcvp, x, y);
 				dest = MAKE_PTR(destvp, rx - x , ry - y);
 				for (x = 0 ; x< w; x++) {
 					// transparency
 					if (*src)
 						*dest = *src;
 					dest--;
 					src++;
 				}
 			}
 		} else {
 			for (y = 0; y< h; y++) {
 				x = 0;
 				src = MAKE_PTR(srcvp, x, y);
 				dest = MAKE_PTR(destvp, rx + x, ry + y);
 				for (x = 0 ; x< w; x++) {
 					// transparency
 					if (*src)
 						*dest = *src;
 					dest++;
 					src++;
 				}
 			}
 		}
 		return 0;
 	}
 
 
 	// ok now the hard part
 
 	// make them 16.16
 	if ( ABS(Deltax) < ABS(Deltay)) { // ok this means we want to walk in y
 
 		// walk in  + x in the src and
 		// walk in  + y in the dest
 		Error = 0;
 		// start at left top corner in src and dest
 
 		sx = 0;
 		sy = 0;
 
 		dx = 0;
 		dy = 0;
 
 		dest = MAKE_PTR(destvp, rx + dx, ry + dy);
 
 		src = MAKE_PTR(srcvp, x + sx, y + sy);
 
 		// this gets added to error each inc of x
 		// when error is > 1 then inc y!
 		int xinc = 1;
 		if (Deltax < 0) {
 			Deltax = -Deltax;
 			xinc = -1;
 		}
 		int yinc = 1;
 		int yinc1 = 1;
 		if (Deltay < 0) {
 			Deltay = - Deltay;
 			buffwid2 = - buffwid2;
 		}
 		Decimal = ( Deltax << shift) / Deltay ;
 		// walk in X
 
 		int Deltax2 = Deltax << shift;
 		int Deltay2 = Deltay << shift;
 
 		// this is the ratio between the source height and the dest height
 		// as the rectangle rotates the height and width change
 		int DeltaH = (w << shift) / Deltay;
 		int Error2 = 0;
 		sy = 0;
 		for (int r = 0; r< h ;r++) {
 			// now we walk across the top calculating each rotated point
 			// along the side
 			// the use delta formula to walk in x and y in destination space
 			// always walking in the x in the source!
 			// figure out rotated location to start in dest
 			rx = ( ( (sx - halfws) * ca) - ( (sy - halfhs) * sa) ) >> shift;
 			rx += halfwd;
 			ry = ( ( (sx - halfws) * sa) + ( (sy - halfhs) * ca) ) >> shift;
 			ry += halfhd;
 
 			// this is the end point of the line
 
 			int y2 = ( ( ((w) - halfws) * sa) + ( (sy - halfhs) * ca) ) >> shift;
 			y2 += halfhd;
 
 			// length of line
 
 			int diff = ABS(y2 - ry);
 
 			// if walking backwards reveres diff to reflect sign
 
 			src = MAKE_PTR(srcvp, x, y + sy);
 
 			dest = MAKE_PTR(destvp, rx, ry);
 
 			Error = 0;
 			Error2 = 0;
 			char * baseptr = src;
 			// while walking line
 			while (diff--) {
 				char c = *src;
 				// transparency
 				if (c)
 					*dest = *src;
 				Error2 += DeltaH;
 				dest += buffwid2;
 				Error += Decimal;
 				src = baseptr + (Error2 >> shift) ;
 				// this is time to inc x in src y in dest
 				if (Error >= fixpoint1) {
 					Error -= fixpoint1;
 					if (*src)
 						*dest = *src;
 					dest += xinc;
 				}
 			}
 			sy += yinc;
 		}
 		return 0;
 	} else { // else we walk in X
 		int lasterror = 0;
 		Error = 0;
 		// start at left top corner in src and dest
 
 		sx = 0;
 		sy = 0;
 
 		dx = 0;
 		dy = 0;
 
 		dest = MAKE_PTR(destvp, rx + dx, ry + dy);
 
 		src = MAKE_PTR(srcvp, x + sx, y + sy);
 
 		// this gets added to error each inc of x
 		// when error is > 1 then inc y!
 		int xinc = 1;
 		if (Deltax < 0) {
 			Deltax = -Deltax;
 			xinc = -1;
 		}
 		int yinc = 1;
 		if (Deltay < 0) {
 			Deltay = - Deltay;
 			buffwid2 = - buffwid2;
 			sy = sy + h - 1;
 			yinc = -1;
 		}
 
 
 		Decimal = ( Deltay << shift) / Deltax ;
 		// walk in X
 
 		int Deltax2 = Deltax << shift;
 		int Deltay2 = Deltay << shift;
 
 		// this is the ratios between the source width and the dest width
 		// as the rectangle rotates the actual size changes!
 
 		int DeltaW = (w << shift) / Deltax;
 		int Error2 = 0;
 		for (int r = 0; r< h ;r++) {
 			sx = 0;
 
 			// now we walk across the side calculating each rotated point
 			// along the side
 			// the use delta formula to walk in x and y in destination space
 			// always walking in the x in the source!
 			// figure out rotated location to start
 
 			rx = ( ( (sx - halfws) * ca) - ( (sy - halfhs) * sa) ) >> shift;
 			rx += halfwd;
 			ry = ( ( (sx - halfws) * sa) + ( (sy - halfhs) * ca) ) >> shift;
 			ry += halfhd;
 			// this is the other side of the box
 
 			int x2 = ( ( ((sx + w) - halfws) * ca) - ( (sy - halfhs) * sa) ) >> shift;
 
 			x2 += halfwd;
 
 			int diff = x2 - rx;
 
 
 			dx = 0;
 			dy = 0;
 
 			if (xinc == -1) {
 				diff = -diff;
 			}
 
 			src = MAKE_PTR(srcvp, x + sx, y + sy);
 
 			dest = MAKE_PTR(destvp, rx + dx, ry + dy);
 			Error = 0;
 			Error2 = 0;
 			char * baseptr = src;
 
 			while (diff--) {
 				char c = *src;
 				// transparency
 				if (c)
 					*dest = *src;
 				Error2 += DeltaW;
  				rx++;
 				dest += xinc;
 				Error += Decimal;
 				src = baseptr + (Error2 >> shift);
 				if (Error >= fixpoint1) {
 					Error -= fixpoint1;
 					if (*src)
 						*dest = *src;
 					dest += buffwid2;
 				}
 			}
 			sy += yinc;
 		}
 	}
 	return 0;
 }
 #endif