/*


It can be useful for making easier status changes (that why i designed it)


Remember the limit of bits is 32 per int.





The functions RETURN the new value instead of changing the original.


To do that you have to use something like:





	originalFlag = WhateverFlagBitOperation ( originalFlag, flagMaskOrOffset );





For more information on bit flags, visit: http://www.vipan.com/htdocs/bitwisehelp.html





*/





//The first two are simplified functions for reading or setting one bit at time


//Keep in mind that flagOffset can be 0-31.


//


int GetFlagBit ( int flagSource, int flagOffset )


{





	int flagMask = ( pow(2, flagOffset));


	return CheckFlagBits( flagSource, flagMask);





}





//Here flagNewValue can be 0, 1, or 2 (for switching to the opossite (1-bit not)


//any other value will return the flag without any change


int PutFlagBit ( int flagSource, int flagOffset , int flagNewValue )


{


	int flagBuffer = flagSource;


	int flagMask = ( pow(2, flagOffset));


	switch (flagNewValue)


	{


		case 0 : flagBuffer = UnSetFlagBits( flagSource, flagMask );


		case 1 : flagBuffer = SetFlagBits( flagSource, flagMask );


		case 2 : flagBuffer = SwitchFlagBits( flagSource, flagMask );


	}





	return flagBuffer;


}











//The next four functions are the direct flag managing


//the bits that are 'on' (value==1) on flagMask indicate


//which bits is the operation made on flagSource


//


int CheckFlagBits ( int flagSource, int flagMask )


{





//Checks if ALL the set (value=1) bits on the mask are set on the flag


//and returns 1 if true or 0 if false





	if ((flagSource & flagMask ) == FlagMask) {


		return 1;


	}


	else {


		return 0;


	}


}








//Sets ALL the the bits on the flag that are set on the mask. All the other bits are left.


int SetFlagBits ( int flagSource, int flagMask )


{


	return flagSource | flagMask;


}





//The same but it unsets (value=0) instead of setting


int UnSetFlagBits ( int flagSource, int flagMask )


{


	return flagSource & BitwiseNot(flagMask);


}





//It sets the unset and unsets the set


//


int SwitchFlagBits ( int flagSource, int flagMask )


{


	return flagSource ^ flagMask;


}








//A workaround for making a bitwise NOT in vergeC


//


int BitwiseNot(int sourceNumber)


{


	return (pow(2, 32)-1)-sourceNumber;


}

//Interpolate


//By Omni.


//


//Simply lets you generate horizontal interpolation on the screen.


//IE, a 320x240 screen becomes a 640x240 screen with interpolated values,


//smoothing out (some) sharp pixel edges.


//


//SETUP:


//1.  Run your game in twice the desired resolution.


//	(IE, if you run in 320x240, run in 640x480)


//2.  Call O_Interpolate() right before ShowPage().











int oint_2xscale=0;


	//If this is set to 1, O_interpolate will draw the screen without


	//interpolation.  Allows you to compare and see the difference.


int screen_shell = NewImage(ImageWidth(screen), ImageHeight(screen));





int oint_2xinterpolate=0;


	//If set to 1, O_Interpolate interpolates the screen


	//horizontally and vertically.  This causes some slowdown.


	//If zero, O_Interpolate only interpolates the screen horizontally.











void O_Interpolate()	{


//Interpolate the screen horizontally.


//Essentially, the screen is now twice the horizontal width.


//Every new pixel column is a mix of the pixels from the left and right


//of it from the original source image.


//


//To accomplish in a hacky but hopefully fast way:


//1.  Make an imageshell of the desired screen section.


//	(will be half of the V3 resolution.


//	(IE, if res = 640x480, we are then interpolating a 320x240 source image).


//2.  Scale blit the shell to a temporary buffer.


//3.  Additive blit the buffer at 50% lucency to the screen, twice, with a one


//	pixel offset so that every other pixel column will be new and a composite


//	blending of two pixel columns from the source image.


//


//AFTER CALLING THIS FUNCTION, LUCENCY IS RESET TO ZERO


	


	int get_screen = ImageShell(0, 0, ImageWidth(screen)/2, ImageHeight(screen)/2, screen);


	ScaleBlit(0, 0, ImageWidth(screen), ImageHeight(screen), get_screen, screen_shell);


	FreeImage(get_screen);





	if (!oint_2xscale)


		{


		RectFill(0, 0, ImageWidth(screen), ImageHeight(screen), RGB(0, 0, 0), screen);





		//I need to set lucency to 1/4th (to compose new data from four blits)


		//if interpolation is horizontal & vertical.  Otherwise,


		//lucency = 1/2th for just horizontal.


		//


		//Keep in mind when I say lucency I mean the intensity of the image, not it's see-through-ability.


		//Thus for me I need 25% opacity and use 75% with SetLucent.  Yeah.  I screw terms up.


		


		if (oint_2xinterpolate) SetLucent(75); else SetLucent(50);





		AdditiveBlit(0, 0, screen_shell, screen);


		AdditiveBlit(1, 0, screen_shell, screen);


		


		if (oint_2xinterpolate)	{


			AdditiveBlit(1, 1, screen_shell, screen);


			AdditiveBlit(0, 1, screen_shell, screen);


			}


			


		SetLucent(0);


		}


	


	if (oint_2xscale) Blit(0, 0, screen_shell, screen);


	}