glib.c

color_lcd_test

/*********************************************************************************************
* File：	glib.c
* Author:	Embest	
* Desc：	general lib
* History:	
*			Y.J.Guo, Programming modify, April 12, 2005
*********************************************************************************************/

/*------------------------------------------------------------------------------------------*/
/*	 								include files						 				    */
/*------------------------------------------------------------------------------------------*/
#include "def.h"
#include "lcdlib.h"
#include "glib.h"
#include "lcd.h"
#include <math.h>
/*------------------------------------------------------------------------------------------*/
/*	 								functions declare                                       */
/*------------------------------------------------------------------------------------------*/
void (*PutPixel)(UINT32T,UINT32T,UINT32T);
void (*BitmapView)(UINT8T *pBuffer);
//int distance(int x1,int y1,int x2,int y2);
void Glib_Rectangle(int x1,int y1,int x2,int y2,int color,int width);
void Glib_H_line(int x1, int x2, int y, int color, int width);
void Glib_V_line(int x, int y1, int y2, int color, int width);

/*********************************************************************************************
* name:		Glib_Init()
* func:		Glib initialization
* para:		type    --  lcd display mode
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_Init(int type)
{
    switch(type)
    {

	    case MODE_CSTN_8BIT:
	    	PutPixel=_PutCstn8Bit;
	    	BitmapView=BitmapViewCstn8Bit;
	    	break;   
	    default: 
	    	break;
   }
}

/*********************************************************************************************
* name:		_PutCstn8Bit()
* func:		put pixel to 8bpp color stn
* para:		UINT32T x   --  x coordinate
*           UINT32T y   --  y coordinate
*           UINT32T c   --  color value          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void _PutCstn8Bit(UINT32T x,UINT32T y,UINT32T c)
{
    if(x<SCR_XSIZE_CSTN&& y<SCR_YSIZE_CSTN)
        frameBuffer8Bit[(y)][(x)/4]=( frameBuffer8Bit[(y)][x/4]
	    & ~(0xff000000>>((x)%4)*8) ) | ( (c&0x000000ff)<<((4-1-((x)%4))*8) );
}


/*********************************************************************************************
* name:		BitmapViewCstn8Bit
* func:		display a 8bpp bitmap  on 256 color LCD
* para:		UINT8T *pBuffer --  bitmap data pointer          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void BitmapViewCstn8Bit(UINT8T *pBuffer)
{
    UINT32T i, j;
	UINT32T *pView = (UINT32T*)frameBuffer8Bit;

	for (i = 0; i < SCR_YSIZE_STN; i++)
	{
	    for (j = 0; j < LCD_XSIZE_STN/4; j++)
	    {
		pView[j] = ((*pBuffer) << 24) + ((*(pBuffer+1)) << 16) + ((*(pBuffer+2)) << 8) + (*(pBuffer+3));
		pBuffer += 4;
	   }
	    pView+=SCR_XSIZE_STN/4;
	}

}
/*********************************************************************************************
* name:		Glib_Rectangle()
* func:		describe a Rectangle
* para:		int x1      --  x coordinate 1
*           int y1      --  y coordinate 1
*           int x2      --  x coordinate 2
*           int y2      --  y coordinate 2
*           int color   --  color value          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_Rectangle(int x1,int y1,int x2,int y2,int color,int width)
{
	while((width--)>=0)
	{
    Glib_Line(x1,y1,x2,y1,color);
    Glib_Line(x2,y1,x2,y2,color);
    Glib_Line(x1,y2,x2,y2,color);
    Glib_Line(x1,y1,x1,y2,color);
    x1++;
    y1++;
    x2--;
    y2--;
    }
}
/*********************************************************************************************
* name:		Glib_Triangle()
* func:		describe a Rectangle
* para:		point A      --  x coordinate 1
*           point B      --  y coordinate 1
*           point C      --  x coordinate 2
*           int color   --  color value          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_Triangle(struct point A,struct point B,struct point C)
{
	Glib_Line(A.x,A.y,B.x,B.y,RED);
	Glib_Line(A.x,A.y,C.x,C.y,BLUE);
	Glib_Line(B.x,B.y,C.x,C.y,GREEN);
}

/*********************************************************************************************
* name:		Glib_FilledRectangle()
* func:		describe a FilledRectangle
* para:		int x1      --  x coordinate 1
*           int y1      --  y coordinate 1
*           int x2      --  x coordinate 2
*           int y2      --  y coordinate 2
*           int color   --  color value          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_FilledRectangle(int x1,int y1,int x2,int y2,int color)
{
    int i;

    for(i=y1;i<=y2;i++)
	Glib_Line(x1,i,x2,i,color);
}



/*********************************************************************************************
* name:		Glib_Line()
* func:		describe a Line
* para:		int x1      --  x coordinate 1
*           int y1      --  y coordinate 1
*           int x2      --  x coordinate 2
*           int y2      --  y coordinate 2
*           int color   --  color value          
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_Line(int x1,int y1,int x2,int y2,int color)
{
	int dx,dy,e;
	dx=x2-x1; 
	dy=y2-y1;
    
	if(dx>=0)
	{
		if(dy >= 0)                                             // dy>=0
		{
			if(dx>=dy)                                          // 1/8 octant
			{
				e=dy-dx/2;
				while(x1<=x2)
				{
					PutPixel(x1,y1,color);
					if(e>0){y1+=1;e-=dx;}	
					x1+=1;
					e+=dy;
				}
			}
			else                                                // 2/8 octant
			{
				e=dx-dy/2;
				while(y1<=y2)
				{
					PutPixel(x1,y1,color);
					if(e>0){x1+=1;e-=dy;}	
					y1+=1;
					e+=dx;
				}
			}
		}
		else                                                    // dy<0
		{
			dy=-dy;                                             // dy=abs(dy)

			if(dx>=dy)                                          // 8/8 octant
			{
				e=dy-dx/2;
				while(x1<=x2)
				{
					PutPixel(x1,y1,color);
					if(e>0){y1-=1;e-=dx;}	
					x1+=1;
					e+=dy;
				}
			}
			else                                                // 7/8 octant
			{
				e=dx-dy/2;
				while(y1>=y2)
				{
					PutPixel(x1,y1,color);
					if(e>0){x1+=1;e-=dy;}	
					y1-=1;
					e+=dx;
				}
			}
		}	
	}
	else                                                        //dx<0
	{
		dx=-dx;                                                 //dx=abs(dx)
		if(dy >= 0)                                             // dy>=0
		{
			if(dx>=dy)                                          // 4/8 octant
			{
				e=dy-dx/2;
				while(x1>=x2)
				{
					PutPixel(x1,y1,color);
					if(e>0){y1+=1;e-=dx;}	
					x1-=1;
					e+=dy;
				}
			}
			else                                                // 3/8 octant
			{
				e=dx-dy/2;
				while(y1<=y2)
				{
					PutPixel(x1,y1,color);
					if(e>0){x1-=1;e-=dy;}	
					y1+=1;
					e+=dx;
				}
			}
		}
		else                                                    // dy<0
		{
			dy=-dy;                                             // dy=abs(dy)

			if(dx>=dy)                                          // 5/8 octant
			{
				e=dy-dx/2;
				while(x1>=x2)
				{
					PutPixel(x1,y1,color);
					if(e>0){y1-=1;e-=dx;}	
					x1-=1;
					e+=dy;
				}
			}
			else                                                // 6/8 octant
			{
				e=dx-dy/2;
				while(y1>=y2)
				{
					PutPixel(x1,y1,color);
					if(e>0){x1-=1;e-=dy;}	
					y1-=1;
					e+=dx;
				}
			}
		}	
	}
}


/*********************************************************************************************
* name:		Glib_ClearScr()
* func:		Clear screen with color value c
* para:		UINT32T c   --  color value 
*           int type    --  lcd display type         
* ret:		none
* modify:
* comment:		
*********************************************************************************************/
void Glib_ClearScr(UINT32T c, int type)
{	
    int i,j;

    if((type&0x4000)&&(type&0x400))                                 // type:MODE_TFT_1BIT_800600|MODE_TFT_8BIT_800600|MODE_TFT_16BIT_800600
        for(j=0;j<SCR_YSIZE_TFT_800600;j++)
            for(i=0;i<SCR_XSIZE_TFT_800600;i++)
		        PutPixel(i,j,c);
    else if((type&0x4000)&&(type&0x200))                            // type:MODE_TFT_1BIT_640480|MODE_TFT_8BIT_640480|MODE_TFT_16BIT_640480
        for(j=0;j<SCR_YSIZE_TFT_640480;j++)
            for(i=0;i<SCR_XSIZE_TFT_640480;i++)
		        PutPixel(i,j,c);
    else if((type&0x4000)&&(type&0x100))                            // type:MODE_TFT_1BIT_240320|MODE_TFT_8BIT_240320|MODE_TFT_16BIT_240320
        for(j=0;j<SCR_YSIZE_TFT_240320;j++)
            for(i=0;i<SCR_XSIZE_TFT_240320;i++)
		        PutPixel(i,j,c);
    else if(type&0x2000)                                            // type:MODE_CSTN_8BIT|MODE_CSTN_12BIT
        for(j=0;j<SCR_YSIZE_CSTN;j++)
    	    for(i=0;i<SCR_XSIZE_CSTN;i++)
		        PutPixel(i,j,c);
    else                                                            // type:MODE_CSTN_4BIT|MODE_STN_2BIT|MODE_STN_1BIT
        for(j=0;j<SCR_YSIZE_STN;j++)
    	    for(i=0;i<SCR_XSIZE_STN;i++)
		        PutPixel(i,j,c);
}