import java.applet.*;
import java.awt.*;
import java.awt.image.*;

public class MainClass extends Applet
{
	final int 	W=320,
				H=240;
	Image img = null;
	MemoryImageSource mis = null;	
	
	public void init()
	{
		this.setSize(W,H);
		this.setBackground(Color.GRAY);
		
		int pixels[] = new int[W*H];		
		for (int i=0; i < W*H; i++)
			pixels[i] =  255 << 24 | 255 << 16 | 255 << 8 | 255;
		
		int color1[] = {80, 80, 80};		
		int color2[] = {120, 120, 120};
		int color3[] = {255, 255, 255};
		pixels = smoothPolygon(	new Point(50,50), 
								new Point(200,100),
								new Point(70,220),
								color1, color2, color3,
								pixels);
		mis = new MemoryImageSource(W, H, pixels, 0, W);		
	    img = createImage(mis);		    	    
	}
	
	public void paint (Graphics g)
	{		
		g.drawImage(img,0,0,this);		
	}
	
	//-----------------------------------------------------------------------
	// Draw smooth polygon
	//-----------------------------------------------------------------------
	public int[] smoothPolygon(	Point fpP1, Point fpP2, Point fpP3,
								int fpColor1[], int fpColor2[], int fpColor3[],
								int fpPixels[])
	{
		if (fpP1.y > fpP2.y)
		{			
			Point tempPoint = fpP1;
			fpP1 = fpP2;
			fpP2 = tempPoint;
			int tempColor[] = fpColor1;
			fpColor1 = fpColor2;
			fpColor2 = tempColor;
		}		
		if (fpP2.y > fpP3.y)
		{
			Point tempPoint = fpP2;
			fpP2 = fpP3;
			fpP3 = tempPoint;
			int tempColor[] = fpColor2;
			fpColor2 = fpColor3;
			fpColor3 = tempColor;			
		}		
		if (fpP1.y > fpP3.y)
		{
			Point tempPoint = fpP1;
			fpP1 = fpP3;
			fpP3 = tempPoint;
			int tempColor[] = fpColor3;
			fpColor1 = fpColor3;
			fpColor3 = tempColor;			
		}
		
		float CEdgeX = fpP1.x;
		float CEdgeDeltaY = fpP3.y - fpP1.y;
		float CEdgeDeltaX = fpP3.x - fpP1.x;
		float CEdgeStep = CEdgeDeltaX/CEdgeDeltaY;
		
		float CColorR = fpColor1[0];
		float CColorG = fpColor1[1];
		float CColorB = fpColor1[2];		
		float CColorDeltaR = fpColor3[0] - fpColor1[0];
		float CColorDeltaG = fpColor3[1] - fpColor1[1];
		float CColorDeltaB = fpColor3[2] - fpColor1[2];
		float CColorStepR =  CColorDeltaR/CEdgeDeltaY;
		float CColorStepG =  CColorDeltaG/CEdgeDeltaY;
		float CColorStepB =  CColorDeltaB/CEdgeDeltaY;		
		
		// Polygon top
		if (fpP1.y != fpP2.y)
		{
			float AEdgeX = fpP1.x;
			float AEdgeDeltaY = fpP2.y-fpP1.y;
			float AEdgeDeltaX = fpP2.x-fpP1.x;
			float AEdgeStep = AEdgeDeltaX/AEdgeDeltaY;
			
			float AColorR = fpColor1[0];
			float AColorG = fpColor1[1];
			float AColorB = fpColor1[2];		
			float AColorDeltaR = fpColor2[0] - fpColor1[0];
			float AColorDeltaG = fpColor2[1] - fpColor1[1];
			float AColorDeltaB = fpColor2[2] - fpColor1[2];
			float AColorStepR =  AColorDeltaR/AEdgeDeltaY;
			float AColorStepG =  AColorDeltaG/AEdgeDeltaY;
			float AColorStepB =  AColorDeltaB/AEdgeDeltaY;				
			
			for (int i=fpP1.y; i < fpP2.y; i++)
			{
				AEdgeX += AEdgeStep;
				CEdgeX += CEdgeStep;
				
				AColorR += AColorStepR;
				AColorG += AColorStepG;
				AColorB += AColorStepB;
				CColorR += CColorStepR;
				CColorG += CColorStepG;
				CColorB += CColorStepB;				
				
				int x1 = (int)AEdgeX;
				int x2 = (int)CEdgeX;
				int c1[] = {(int)AColorR, (int)AColorG, (int)AColorB};
				int c2[] = {(int)CColorR, (int)CColorG, (int)CColorB};
				fpPixels = scanLine (	new Point(x1,i),
										new Point(x2,i),
										c1, c2,										
										fpPixels);
			}
		}
		
		// Polygon bottom
		if (fpP2.y != fpP3.y)
		{
			float BEdgeX = fpP2.x;
			float BEdgeDeltaY = fpP3.y-fpP2.y;
			float BEdgeDeltaX = fpP3.x-fpP2.x;
			float BEdgeStep = BEdgeDeltaX/BEdgeDeltaY;
			
			float BColorR = fpColor2[0];
			float BColorG = fpColor2[1];
			float BColorB = fpColor2[2];		
			float BColorDeltaR = fpColor3[0] - fpColor2[0];
			float BColorDeltaG = fpColor3[1] - fpColor2[1];
			float BColorDeltaB = fpColor3[2] - fpColor2[2];
			float BColorStepR =  BColorDeltaR/BEdgeDeltaY;
			float BColorStepG =  BColorDeltaG/BEdgeDeltaY;
			float BColorStepB =  BColorDeltaB/BEdgeDeltaY;					
			
			for (int i=fpP2.y; i < fpP3.y; i++)
			{
				BEdgeX += BEdgeStep;
				CEdgeX += CEdgeStep;
				
				BColorR += BColorStepR;
				BColorG += BColorStepG;
				BColorB += BColorStepB;
				CColorR += CColorStepR;
				CColorG += CColorStepG;
				CColorB += CColorStepB;							
				
				int x1 = (int)BEdgeX;
				int x2 = (int)CEdgeX;
				int c1[] = {(int)BColorR, (int)BColorG, (int)BColorB};
				int c2[] = {(int)CColorR, (int)CColorG, (int)CColorB};
				fpPixels = scanLine (	new Point(x1,i),
										new Point(x2,i),
										c1, c2,										
										fpPixels);
			}
		}		
		
		return fpPixels;
	}
	//-----------------------------------------------------------------------	
	
	//-----------------------------------------------------------------------
	// Draw smooth scanline
	//-----------------------------------------------------------------------	
	public int[] scanLine(	Point fpP1,
							Point fpP2,
							int fpColor1[],
							int fpColor2[],
							int fpPixels[])
	{
		if (fpP1.x > fpP2.x)
		{
			Point tempPoint = fpP1;
			fpP1 = fpP2;
			fpP2 = tempPoint;
			int tempColor[] = fpColor1;
			fpColor1 = fpColor2;
			fpColor2 = tempColor;
		}
		
		int delta = fpP2.x - fpP1.x;
		float colorR = fpColor1[0];
		float colorG = fpColor1[1];
		float colorB = fpColor1[2];
		int colorDeltaR = fpColor2[0] - fpColor1[0];
		int colorDeltaG = fpColor2[1] - fpColor1[1];
		int colorDeltaB = fpColor2[2] - fpColor1[2];
		float colorStepR = colorDeltaR/delta;
		float colorStepG = colorDeltaG/delta;
		float colorStepB = colorDeltaB/delta;
		
		if (delta != 0)
		{							
			for (int i=fpP1.x; i < fpP2.x; i++)
			{		
				colorR += colorStepR;
				colorG += colorStepG;
				colorB += colorStepB;
				int color[] = {(int)colorR, (int)colorG, (int)colorB};
				fpPixels[fpP1.y * W + i] = 255<<24 | color[0]<<16 | color[1]<<8 | color[2];
			}
		}
		
		return fpPixels;
	}
	//-----------------------------------------------------------------------
}