class SGL_Interface
{
private:

	int screenW, screenH;
	double * zBuffer;
	SGL_Color * backBuffer;
	SGL_Color tempColor;
	int j,bufLen,bufMem;

public:
	void SGL_Init(int x, int y)
	{
		screenW = x;
		screenH = y;
		zBuffer = new double[x*y];
		backBuffer = new SGL_Color[x*y];
		bufLen = x*y;
		bufMem = x*y*sizeof(SGL_Color);
	}

	void SGL_Quit()
	{
		delete zBuffer;
		delete [] backBuffer;
	}

	void SGL_ClearScreen()
	{
		memset(backBuffer,0,bufMem);
	}

	int SGL_GetPixel(int x, int y)
	{
		int j = y*screenW+x;
		if(j<bufLen)
			return backBuffer[j].GetColor();
		return 0;
	}

	//graphics methods
	void SGL_PlotPixel(int x, int y, SGL_Color &v)
	{
		int j = y*screenW+x;
		if(x>=0 && x<screenW)
		if(y>=0 && y<screenH)
			backBuffer[j].SetColor(v);
	}

	void SGL_EFLA_DrawLine(float x,float y,float x2,float y2,SGL_Color c)
	{
		// see http://www.edepot.com/lineb.html - not for commercial use
		// on Duron 1200, same speed as SGL_DrawLine below
		bool yLonger=false;
		int incrementVal;
		int shortLen=(int)(y2-y);
		int longLen=(int)(x2-x);
		int i;
		if (abs(shortLen)>abs(longLen)) 
		{
			int swap=shortLen;
			shortLen=longLen;
			longLen=swap;
			yLonger=true;
		}

		if (longLen<0) 
			incrementVal=-1;
		else 
			incrementVal=1;

		float multDiff;
		if (longLen==0.0) 
			multDiff= (float)shortLen;
		else 
			multDiff= (float)shortLen/(float)longLen;
		if (yLonger) 
		{
			for (i=0;i!=longLen;i+=incrementVal) 
				SGL_PlotPixel((int)(x+(int)((float)i*multDiff)),(int)(y+i),c);
		} 
		else 
		{
			for (i=0;i!=longLen;i+=incrementVal) 
				SGL_PlotPixel((int)(x+i),(int)(y+(int)((float)i*multDiff)),c);
		}
	}

	void SGL_DrawLine(float x,float y,float x2,float y2,SGL_Color c)
	{
		float dist = sqrtf((x2-x)*(x2-x)+(y2-y)*(y2-y));
		float dx = (x2-x)/dist;
		float dy = (y2-y)/dist;
		for(int j=0;j<dist;j++)
		{
			SGL_PlotPixel((int)x,(int)y,c);
			x+=dx;
			y+=dy;
		}
	}

	void SGL_DrawTriangleSolidFill(SGL_TRIANGLE tri,SGL_Color c)
	{
		float dist = sqrtf((tri.p3.x-tri.p1.x)*(tri.p3.x-tri.p1.x)+(tri.p3.y-tri.p1.y)*(tri.p3.y-tri.p1.y));

		if(dist == 0.0f)
			return;

		float area = tri.Area();
		float h =  (float)fabs(2.0f * area / dist);

		float dx1 = (tri.p2.x-tri.p1.x)/h;
		float dx2 = (tri.p2.x-tri.p3.x)/h;
		float dy1 = (tri.p2.y-tri.p1.y)/h;
		float dy2 = (tri.p2.y-tri.p3.y)/h;

		for(j=0;j<h;j++)
		{
			SGL_DrawLine(tri.p1.x,tri.p1.y,tri.p3.x,tri.p3.y,c);
			tri.p1.x+=dx1;
			tri.p3.x+=dx2;
			tri.p1.y+=dy1;
			tri.p3.y+=dy2;
		}
	}

	void SGL_DrawTriangleGradFill(	SGL_TRIANGLE tri, 
									SGL_Color c1,
									SGL_Color c2,
									SGL_Color c3)
	{
		float dist3 = sqrtf((tri.p3.x-tri.p1.x)*(tri.p3.x-tri.p1.x)+(tri.p3.y-tri.p1.y)*(tri.p3.y-tri.p1.y));

		if(dist3 == 0.0f)
			return;

		float area = tri.Area();
		float h = (float)fabs(2.0f * area / dist3);

		float px1=tri.p1.x;
		float px2=tri.p3.x;
		float py1=tri.p1.y;
		float py2=tri.p3.y;

		SGL_Color pc,pc1,pc2,pc3;
		pc1 = c1;
		pc2 = c2;
		pc3 = c3;

		float dx1 = (tri.p2.x-tri.p1.x)/h;
		float dx2 = (tri.p2.x-tri.p3.x)/h;
		float dy1 = (tri.p2.y-tri.p1.y)/h;
		float dy2 = (tri.p2.y-tri.p3.y)/h;

		float px,py,dx,dy,dist,colp1,colp2,colp3;
		float j,k;

		SGL_Color c;

		for(j=0;j<h;j++)
		{
			dist = sqrtf((px2-px1)*(px2-px1)+(py2-py1)*(py2-py1));

			if(dist>0)
			{
				px = px1;
				py = py1;
				dx = (px2-px1)/dist;
				dy = (py2-py1)/dist;

				for(k=0;k<dist;k++)
				{
					//barycentric coordinates, sum always equal to 1
					colp1  = ((tri.p1.x - px) * (tri.p2.y - py) - (tri.p2.x - px) * (tri.p1.y - py)) / area;
					colp3  = ((tri.p2.x - px) * (tri.p3.y - py) - (tri.p3.x - px) * (tri.p2.y - py)) / area;
					colp2  = 1.0f - colp1 - colp3; //((x3 - px) * (y1 - py) - (x1 - px) * (y3 - py)) / area;

					c.SetColor(	(uint8)(colp1 * (float)pc1.r + colp2 * (float)pc2.r + colp3 * (float)pc3.r),
								(uint8)(colp1 * (float)pc1.g + colp2 * (float)pc2.g + colp3 * (float)pc3.g),
								(uint8)(colp1 * (float)pc1.b + colp2 * (float)pc2.b + colp3 * (float)pc3.b));

					SGL_PlotPixel((int)px,(int)py,c);
					px+=dx;
					py+=dy;
				}

				px1+=dx1;
				px2+=dx2;
				py1+=dy1;
				py2+=dy2;
			}
		}

	}

	void SGL_MandelbrotFractal(double rMin, double rMax, double iMin, double iMax, int N)
	{
		//based on http://www.devx.com/amd/Article/21827/2046
		int i,j,q;
		double zReal,zImag,xReal,xImag,a,b,c;
		xReal = 0.0f;
		xImag = 0.0f;
		double delta = (rMax - rMin)/double(screenW);
		for(i=0,zReal = rMin;i<screenW;i++,zReal+=delta)
			for(j=0,zImag = iMin;j<screenH;j++,zImag+=delta)
			{
				xReal = zReal;
				xImag = zImag;
				for (q = 0; q < N; q++) 
				{
					a = xReal * xReal;
					b = xImag * xImag;
					c = 2.0 * xReal * xImag;
					xReal = a - b + zReal;
					xImag = c + zImag;
					if((a + b) > 4.0) 
					{ 
						SGL_PlotPixel(i,j,SGL_Color(0,(uint8)xImag,(uint8)xReal));
						q=N; 
					}
				}
			}
	}

	void SGL_PerlinNoise(float persistence, int octaves)
	{
		SGL_Perlin Perlin;
		Perlin.Number_Of_Octaves = octaves;
		Perlin.persistence = persistence;

		int i,j;
		float c;
		for(i=0;i<screenW;i++)
			for(j=0;j<screenH;j++)
			{
				c = Perlin.PerlinNoise_2D((float)i/(float)screenW,(float)j/(float)screenH) + 1.0f;
				SGL_PlotPixel(i,j,SGL_Color((uint8)(c*256.0f),0,0));
			}
	}

	void SGL_Blit(SGL_RECT dest, SGL_RECT src, SGL_Texture * texture,  SGL_Texture * mask = 0)
	{
		int x,y;
		int xs = (int)fabs(src.p2.x-src.p1.x);
		int ys = (int)fabs(src.p2.y-src.p1.y);
		int xsd = (src.p2.x-src.p1.x) > 0 ? 1:-1;
		int ysd = (src.p2.y-src.p1.y) > 0 ? 1:-1;

		int dx, dy;
		for(x=0;x<xs;x++)
			for(y=0;y<ys;y++)
			{
				dx = (int)(src.p1.x)+x*xsd;
				dy = (int)(src.p1.y)+y*ysd;
				if( mask==0 || mask->GetColorAt(dx,dy).black() )
					SGL_PlotPixel((int)dest.p1.x+x,(int)dest.p1.y+y,texture->GetColorAt(dx,dy));
			}
	}

	void SGL_BlitStretch(SGL_RECT dest, SGL_RECT src, SGL_Texture * texture, SGL_Texture * mask = 0)
	{
		int x,y;
		int xss = (int)fabs(src.p2.x-src.p1.x);
		int yss = (int)fabs(src.p2.y-src.p1.y);
		int xds = (int)fabs(dest.p2.x-dest.p1.x);
		int yds = (int)fabs(dest.p2.y-dest.p1.y);

		float yratio = (yds>0) ? (float)yss/(float)yds : 0;
		float xratio = (xds>0) ? (float)xss/(float)xds : 0;

		int xsd = (src.p2.x-src.p1.x) > 0 ? 1:-1;
		int ysd = (src.p2.y-src.p1.y) > 0 ? 1:-1;
		int xdd = (dest.p2.x-dest.p1.x) > 0 ? 1:-1;
		int ydd = (dest.p2.y-dest.p1.y) > 0 ? 1:-1;
		int dx,dy;

		for(x=0;x<xds;x++)
			for(y=0;y<yds;y++)
			{
				dx = (int)(src.p1.x+(float)(x*xsd)*xratio);
				dy = (int)(src.p1.y+(float)(y*ysd)*yratio);
				if(mask == 0 || mask->GetColorAt(dx,dy).black())
					SGL_PlotPixel((int)dest.p1.x+x*xdd,(int)dest.p1.y+y*ydd,texture->GetColorAt(dx,dy));
			}
	}

	void SGL_DrawTriangleTexture(	SGL_TRIANGLE tri, 
									SGL_TRIANGLE tex, 
									SGL_Texture * texture,
									SGL_2X2Matrix &trans,
									SGL_Texture * mask = 0,  
									SGL_Texture * bump = 0,
									SGL_Light2D_Handler * lights = 0
									)
	{
		int lightCount = 0;
		if(lights!=0)
			lightCount = lights->SGL_LightCount();

		float dist3 = sqrtf((tri.p3.x-tri.p1.x)*(tri.p3.x-tri.p1.x)+
							(tri.p3.y-tri.p1.y)*(tri.p3.y-tri.p1.y));
			
		float area = (tri.p2.x - tri.p1.x) * (tri.p3.y - tri.p1.y) - 
					 (tri.p3.x - tri.p1.x) * (tri.p2.y - tri.p1.y);
		float h = dist3 > 0.0f ? (float)fabs(2.0f * area / dist3) : 0.0f;

		if(h==0.0f)
			return;

		float px1=tri.p1.x;
		float px2=tri.p3.x;
		float py1=tri.p1.y;
		float py2=tri.p3.y;

		float ptx1=tex.p1.x;
		float ptx2=tex.p3.x;
		float pty1=tex.p1.y;
		float pty2=tex.p3.y;

		float dx1 = (tri.p2.x-tri.p1.x)/h;
		float dx2 = (tri.p2.x-tri.p3.x)/h;
		float dy1 = (tri.p2.y-tri.p1.y)/h;
		float dy2 = (tri.p2.y-tri.p3.y)/h;

		float dtx1 = (tex.p2.x-tex.p1.x)/h;
		float dtx2 = (tex.p2.x-tex.p3.x)/h;
		float dty1 = (tex.p2.y-tex.p1.y)/h;
		float dty2 = (tex.p2.y-tex.p3.y)/h;

		float px,py,dx,dy,dist,ptx,pty,dtx,dty;
		float j,k,z,q;
		int l;

		SGL_Color c,b,b2;
		SGL_POINT3 norm;
		SGL_POINT tNorm;

		for(j=0;j<h;j++)
		{
			dist = sqrtf((px2-px1)*(px2-px1)+(py2-py1)*(py2-py1));

			if(dist>0)
			{
				px = px1;
				py = py1;
				ptx=ptx1;
				pty=pty1;
				dx = (px2-px1)/dist;
				dy = (py2-py1)/dist;
				dtx = (ptx2-ptx1)/dist;
				dty = (pty2-pty1)/dist;

				for(k=0;k<dist;k++)
				{
					if(mask==0 || mask->GetColorAt((int)ptx,(int)pty).black())
					{
						c = texture->GetColorAt((int)ptx,(int)pty);
						z=0.0f;
						if(bump!=0)
						{
							b = bump->GetColorAt((int)ptx,(int)pty);
							z = (float)b.GetColor()/(256.0f*256.0f*256.0f);
							c.scale(z);
							z*=5.0f;
							norm = bump->GetNormalAt((int)ptx,(int)pty);
							tNorm.x = norm.x;
							tNorm.y = norm.y;
							tNorm = trans * tNorm;
							norm.x = tNorm.x;
							norm.y = tNorm.y; 
						}
						if(lights != 0)
						{
							q = 0.0f;
							b.r = 0;
							b.g = 0;
							b.b = 0;

							for(l=0;l<lightCount;l++)
							{
								q = lights->SGL_GetLight(l)->getIntensityAtAngle(px,py,z,norm);
								b2 = lights->SGL_GetLight(l)->color;
								b2.scale(q);
								b += b2;
							}
							c.scale(b);
						}

						SGL_PlotPixel((int)px,(int)py,c);
					}
					px+=dx;
					py+=dy;
					ptx+=dtx;
					pty+=dty;
				}

				px1+=dx1;
				px2+=dx2;
				py1+=dy1;
				py2+=dy2;

				ptx1+=dtx1;
				ptx2+=dtx2;
				pty1+=dty1;
				pty2+=dty2;
			}
		}
	}

	void SGL_Print(SGL_Font * font, char * text, float size, SGL_RECT box)
	{
		uint32 j = strlen(text);
		float h = size / (float)font->Height();

		SGL_RECT src, dest;
		
		dest.p1.x = box.p1.x;
		dest.p1.y = box.p1.y;

		for(uint32 k = 0; k<j;k++)
		{
			src.p1.x = (float)font->Start(text[k]);
			src.p2.x = src.p1.x+(float)font->Width(text[k]);
			src.p1.y = 0.0f;
			src.p2.y = (float)font->Height();

			dest.p2.x=dest.p1.x + (float)font->Width(text[k]) * h;
			dest.p2.y=dest.p1.y + size;
			
			SGL_BlitStretch(dest,src,font->font,font->mask);
			dest.p1.x+=(float)font->Width(text[k]) * h;
		}
	}
};