// *******************************
// FILE: 		gpu2d.cpp
// AUTHOR:		SharpCoder
// DATE:		2013-03-28
// ABOUT:		This is the 2D graphics engine (re written) for my
//				raspberry pi kernel. I'm trying to implement some
//				nicer functions and a backbuffer to make everything
//				smoother.
//
// LICENSE:		Provided "AS IS". USE AT YOUR OWN RISK.
// *******************************
#include "gpu2d.h"
#include "lamefont.c"

gpu2dCanvas::gpu2dCanvas( ) {
	gpu2dCanvas( true );
}

// BASIC CONSTRUCTOR
gpu2dCanvas::gpu2dCanvas( bool useDoubleBuffer ) {
	
	// Determine whether to use the double buffer system.
	this->enableDoubleBuffer = useDoubleBuffer;
	
	// Setup invalid state first.
	this->valid = false;
	
	// Create a framebuffer request object.
	this->fbInfo = (FB_Info*)KERNEL_FB_LOC; 
	
	// Setup some information about the canvas.
	this->fbInfo->screen_width = 800;
	this->fbInfo->screen_height = 600;
	this->fbInfo->virtual_width = this->fbInfo->screen_width;
	
	// If we're using double buffer...
	if ( this->enableDoubleBuffer )
		this->fbInfo->virtual_height = this->fbInfo->screen_height * 2;
	else
		this->fbInfo->virtual_height = this->fbInfo->screen_height;
		
	this->fbInfo->depth = 24;
	this->fbInfo->xoffset = 0;
	this->fbInfo->yoffset = 0;
	this->fbInfo->pitch = 0;
	this->fbInfo->framePtr = 0;
	this->fbInfo->bufferSize = 0;
	
	// Initialize the framebuffer stuff.
	if ( !initFrameBuffer() ) {
		return;
	}
	
	// set the "switched" to false.
	// This determines which part of the virtual buffer to read/write to.
	this->switched = false;
	
}

bool gpu2dCanvas::initFrameBuffer( void ) {
	// Crete the request data.
	uint32 requestData = RaspberryLib::Memory::PHYSICAL_TO_BUS( (uint32)fbInfo );
	// Send the request.
	RaspberryLib::MailboxWrite( 1, requestData );
	
	// Hold until we get a result.
	uint32 result = 0xFF;
	do {
		result = RaspberryLib::MailboxCheck( 1 );
	} while ( result != 0 );
	
	// If we've got a result, validate the data.
	if ( this->fbInfo->framePtr == 0 ) return false;
	if ( this->fbInfo->pitch == 0 ) return false;
	
	// Fix the pointer data.
	this->fbInfo->framePtr = RaspberryLib::Memory::BUS_TO_PHYSICAL( this->fbInfo->framePtr );
	
	// Set our valid flag and return
	this->valid = true;
	return true;
}

void gpu2dCanvas::Draw( void ) {
	if ( !this->valid ) return;
	if (  !this->enableDoubleBuffer ) return;
	
	uint32 y = 0;
	if ( !this->switched ) 
		y = this->fbInfo->screen_height;
	
	this->fbInfo->yoffset = y;
	initFrameBuffer();
	
	// Toggle switched.
	this->switched = !this->switched;
}

void gpu2dCanvas::Clear( uint32 color ) {
	if ( !this->valid ) return;
	// Setup the variables.
	uint32 x = 0, y = 0, y_offset = 0, bufferOffset;
	if ( !this->switched && this->enableDoubleBuffer )
		y_offset = this->fbInfo->screen_height;
	
	// Calculate the colors.
	char r = ( color & 0xFF0000 ) >> 16;
	char g = ( color & 0x00FF00 ) >> 8;
	char b = ( color & 0x0000FF );
	
	// Iterate
	for ( y = 0; y < this->fbInfo->screen_height; y++ ) {
		for ( x = 0; x < this->fbInfo->screen_width; x++ ) {
			
			// Calculate the location in memory.
			bufferOffset = ( ( y + y_offset ) * this->fbInfo->pitch ) + ( x * 3 );
			
			// Update the data.
			*( (char*)( this->fbInfo->framePtr + bufferOffset ) ) = r;
			*( (char*)( this->fbInfo->framePtr + bufferOffset + 1 ) ) = g;
			*( (char*)( this->fbInfo->framePtr + bufferOffset + 2 ) ) = b;
			
		}
	}
	
}

void gpu2dCanvas::sync( void ) {
	// If we're not in double buffer mode, don't even bother.
	if ( !this->enableDoubleBuffer ) return;

	// Copy all the things from one buffer to the other.
	uint32 x = 0, y = 0, y_offset = 0, bufferOffset;
	bool isSwitched = (this->switched);
	
	char* a;
	char* b;
	
	// Iterate
	for ( y = 0; y < this->fbInfo->screen_height; y++ ) {
		for ( x = 0; x < this->fbInfo->screen_width; x++ ) {
			
			// Do a double array copy.
			a = (char*)( this->fbInfo->framePtr + ( y * this->fbInfo->pitch ) + (x * 3) );
			b = (char*)( this->fbInfo->framePtr + ( ( y + this->fbInfo->screen_height ) * this->fbInfo->pitch ) + (x * 3) );
			
			// Figure out which one to copy from based on the buffer thing.
			if ( isSwitched ) {
				*b = *a;
			} else {
				*a = *b;
			}
		}	
	}
}

void gpu2dCanvas::setPixel( uint32 x, uint32 y, uint32 color ) {
	// Calculate which buffer to use.
	uint32 y_offset = 0, bufferOffset = 0;
	if ( !this->switched  && this->enableDoubleBuffer ) {
		y_offset = this->fbInfo->screen_height;
	}
	// Calculate the buffer offset.
	bufferOffset = ( ( y + y_offset ) * this->fbInfo->pitch ) + ( x * 3 );
	
	// Calculate the colors.
	char r = ( color & 0xFF0000 ) >> 16;
	char g = ( color & 0x00FF00 ) >> 8;
	char b = ( color & 0x0000FF );
	
	// Set the pixel.
	*(char*)( this->fbInfo->framePtr + bufferOffset + 0 ) = r;
	*(char*)( this->fbInfo->framePtr + bufferOffset + 1 ) = g;
	*(char*)( this->fbInfo->framePtr + bufferOffset + 2 ) = b;
}

void gpu2dCanvas::DrawLine( int x1, int y1, int x2, int y2, uint32 color ) {
	
	int dx = x2 - x1;
	int dy = y2 - y1;
	int delta = (2 * dy) - dx;
	int y = y1, x = 0;
	
	// Iterate
	for ( x = x1; x < x2; x++ ) {
		if ( delta > 0 ) {
			y = y + 1;
			setPixel( x, y, color );
			delta = delta + ( 2 * dy - 2 * dx );
		} else {
			setPixel( x, y, color );
			delta = delta + ( 2 * dy );
		}
	}
}

void gpu2dCanvas::DrawCharacter( int x, int y, char c, uint32 color ) {
	// uint32 i = 0, r = 0;
	// First, figure out our index.
	//uint32 start = (uint32)c * 16;
	//uint32 end = start + 16;
	// Create a structure to hold the result in.
	
	// Get the bytes.
	char bytes[16];
	uint32 start = (uint32)c * 16, end = start + 16, i = 0;
	for ( i = 0; i < 16; i++ ) {
		bytes[i] = kernel_default_font[start + i];
	}
	
	// Create a loop.
	short num1 = 0, num2 = 0;
	for ( num1 = 0; num1 < 16; num1++ ) {
		
		char databit = bytes[num1];
		
		bool show = false;
		
		// Do some bit math.
		for ( num2 = 0; num2 < 8; num2++ ) {
			
			// Figure out whether to show a given bit.
			show = ( databit & (0x01 << num2) ) != 0;
			
			// If show, then show.
			if ( show ) {
				setPixel ( x + num2, y + num1, color );
			}
			
		}
	}	
}

void gpu2dCanvas::ClearCharacter( int x, int y ) {
	short num1 = 0, num2 = 0;
	for( num1; num1 < 16; num1++ ) {
		for( num2; num2 < 8; num2++ ) {
			setPixel( x + num2, y + num1, 0x000000 );
		}
	}
}