rasterizer.cs.svn-base

这是一个windows mobile程序能够实现窗体运货效果非常不错

using System;

namespace Aspecto.PocketFrog
{
	/// <summary>
	/// Summary description for Rasterizer.
	/// </summary>
	public class Rasterizer
	{
		protected IntPtr uobj;

		public IntPtr uObject() 
		{ 
			return uobj; 
		}
		
		public Rasterizer(IntPtr iuobj)
		{
			uobj = iuobj;
		}

		public Rasterizer(Surface renderTarget)
		{
			IntPtr r = PF.rasterizer_create(renderTarget.uObject());
			if (r.ToInt32() != 0)
				uobj = r;
		}
		
		public void Blit(int destX, int destY, Surface source, Rect srcRect)
		{
			PF.rasterizer_blitusingcoords(uobj,destX,destY,source.uObject(),srcRect.uObject());
		}

		public void Blit(Point dest, Surface source, Rect srcRect)
		{
			PF.rasterizer_blitusingpoint(uobj,dest.uObject(), source.uObject(),srcRect.uObject());
		}

        public void Blit(int destX, int destY, Surface source)
        {
            Rect r = new Rect(0, 0, source.Width, source.Height);
            Blit(destX, destY, source, r);
        }

		public void BlitRotated(int destX, int destY, float angle, Surface source)
		{
			PF.rasterizer_blitrotated(uobj,destX,destY,ref angle,source.uObject());
		}

		public void BlitStretch(Rect dest, Surface source, Rect srcRect)
		{
			PF.rasterizer_blitstretch(uobj,dest.uObject(),source.uObject(),srcRect.uObject());
		}

		public void BlitRotatedStretch(int destX, int destY, float angle, Surface source, Surface stretch_surface,Rect srcRect)
		{
			PF.rasterizer_blitrotatedstretchusingcoords(uobj,destX,destY,ref angle,source.uObject(),stretch_surface.uObject(),srcRect.uObject());
		}

		public void BlitRotatedStretch(Point point, float angle, Surface source, Surface stretch_surface,Rect srcRect)
		{
			PF.rasterizer_blitrotatedstretchusingpoint(uobj,point.uObject(),ref angle,source.uObject(),stretch_surface.uObject(),srcRect.uObject());
		}

		public void Clear(ushort color)
		{
			PF.rasterizer_clear(uobj,color);
		}

		public void SetPixel(int x, int y, ushort color)
		{
			PF.rasterizer_setpixelusingcoords(uobj,x,y,color);
		}

		public void SetPixel(Point point, ushort color)
		{
			PF.rasterizer_setpixelusingpoint(uobj,point.uObject(),color);
		}

		public void DrawCircle(int x, int y, int radius, ushort color)
		{
			PF.rasterizer_drawcircleusingcoords(uobj,x,y,radius,color);
		}
		
		public void DrawCircle(Point point, int radius, ushort color) // missing
		{
			PF.rasterizer_drawcircleusingpoints(uobj,point.uObject(),radius,color);
		}
		
		public void DrawCircle(System.Drawing.Point point, int radius, ushort color) // missing
		{
			PF.rasterizer_drawcircleusingcoords( uobj, point.X, point.Y, radius,color );
		}

		public void DrawLine(int x1,int y1,int x2,int y2,ushort color)
		{
			PF.rasterizer_drawlineusingcoords(uobj,x1,x2,y1,y2,color);
		}

		public void DrawLine(Point point1, Point point2, ushort color)
		{
			PF.rasterizer_drawlineusingpoints(uobj,point1.uObject(),point2.uObject(),color);
		}

		public void DrawHLine(int x, int y, int length, ushort color)
		{
			PF.rasterizer_drawhlineusingcoords(uobj,x,y,length,color);
		}

		public void DrawHLine(Point point,int length, ushort color)
		{
			PF.rasterizer_drawhlineusingpoint(uobj,point.uObject(),length,color);
		}

		public void DrawVLine(int x, int y, int length, ushort color)
		{
			PF.rasterizer_drawvlineusingcoords(uobj,x,y,length,color);
		}

		public void DrawVLine(Point point, int length, ushort color)
		{
			PF.rasterizer_drawvlineusingpoint(uobj,point.uObject(),length,color);
		}

		public void DrawRect(int x1,int y1,int x2,int y2, ushort color)
		{
			PF.rasterizer_drawrectusingcoords(uobj,x1,y1,x2,y2,color);
		}

		public void DrawRect(Rect rect,ushort color)
		{
			PF.rasterizer_drawrectusingrect(uobj,rect.uObject(),color);
		}

		public void FillRect(int x1, int y1, int x2, int y2, ushort color)
		{
			PF.rasterizer_fillrectusingcoords(uobj,x1,y1,x2,y2,color);
		}

		public void FillRect(Rect rect,ushort color)
		{
			PF.rasterizer_fillrectusingrect(uobj,rect.uObject(),color);
			// doesn't work
		}

		/*public void DrawVGAText(char[] pFont,string text,int align,int locX, int locY,ushort color)
		{
			//TODO: look into how to get a ref char from a byte array
			//PF.rasterizer_drawvgatext(uobj,ref pFont,text,align,locX,locY,color);
		}*/

		public ushort GetPixel(int x, int y)
		{
			return PF.rasterizer_getpixel(uobj,x,y);
		}

		public Rect GetClipping()
		{
			IntPtr r = PF.rasterizer_getclipping(uobj);
			if (r.ToInt32() == 0)
				return null;
			else
				return new Rect(r);
		}

		public void SetBlending(byte alpha)
		{
			PF.rasterizer_setblending(uobj,alpha);
		}

		public void SetClipping(Rect rect)
		{
			PF.rasterizer_setclipping(uobj,rect.uObject());
		}

		public void SetDefaultShader()
		{
			PF.rasterizer_setdefaultshader(uobj);
		}

		/*
		public void SetPixelShader(PixelShader shader)
		{
			PF.rasterizer_setpixelshader(uobj,shader);
		}
		*/

		public Surface SetRenderTarget(Surface target)
		{
			IntPtr s = PF.rasterizer_setrendertarget(uobj,target.uObject());
			if (s.ToInt32() == 0)
				return null;
			else
				return new Surface(s);
		}
	}
}
/*
POCKETFROGCWRAPPER_API Rasterizer* __stdcall rasterizer_create(Surface* renderTarget);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitusingcoords(Rasterizer* pRasterizer, int destX, int destY, const Surface* source, const Rect* srcRect = 0);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitusingpoint(Rasterizer* pRasterizer, Point dest, const Surface* source, const Rect* srcRect = 0);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitrotated(Rasterizer* pRasterizer, int destX, int destY, float * angle, const Surface* source);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitstretch(Rasterizer* pRasterizer, const Rect* dest, const Surface* source, const Rect* srcRect = 0);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitrotatedstretchusingcoords(Rasterizer* pRasterizer, int destx, int desty, float * angle, const Surface* source, Surface* stretch_surface, const Rect* src_rect);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_blitrotatedstretchusingpoint(Rasterizer* pRasterizer, Point* point, float * angle, const Surface* source, Surface* stretch_surface, const Rect* src_rect);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_clear(Rasterizer* pRasterizer, Pixel color );
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setpixelusingcoords(Rasterizer* pRasterizer, int x, int y, Pixel color );
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setpixelusingpoint(Rasterizer* pRasterizer, Point point, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawcircleusingcoords(Rasterizer* pRasterizer, int x, int y , int radius, Pixel color );
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawcircleusingpoints(Rasterizer* pRasterizer, Point* point, int radius, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawlineusingcoords(Rasterizer* pRasterizer, int x1, int y1, int x2, int y2, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawlineusingpoints(Rasterizer* pRasterizer, Point point1, Point point2, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawhlineusingcoords(Rasterizer* pRasterizer, int x, int y , int length, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawhlineusingpoint(Rasterizer* pRasterizer, Point point, int length, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawvlineusingcoords(Rasterizer* pRasterizer, int x, int y , int length, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawvlineusingpoint(Rasterizer* pRasterizer, Point point, int length, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawrectusingcoords(Rasterizer* pRasterizer, int x1, int y1, int x2, int y2, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawrectusingrect(Rasterizer* pRasterizer, const Rect* rect, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_fillrectusingcoords(Rasterizer* pRasterizer, int x1, int y1, int x2, int y2, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_fillrectusingrect(Rasterizer* pRasterizer, const Rect* rect, Pixel color);
//TODO: next two on hold for Point[] marshelling knowledge
//POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawpoly(Rasterizer* pRasterizer, const Point points[], int pointCount, Pixel color);
//POCKETFROGCWRAPPER_API void __stdcall rasterizer_fillpoly(Rasterizer* pRasterizer, const Point points[], int pointCount, Pixel color);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_drawvgatext(Rasterizer* pRasterizer, unsigned char* pFont, TCHAR* string, int align, int locX, int locY, Pixel color);
POCKETFROGCWRAPPER_API Pixel __stdcall rasterizer_getpixel(Rasterizer* pRasterizer, int x, int y);
POCKETFROGCWRAPPER_API const Rect* __stdcall rasterizer_getclipping(Rasterizer* pRasterizer);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setblending(Rasterizer* pRasterizer, uint8_t alpha);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setclipping(Rasterizer* pRasterizer, const Rect* rect);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setdefaultshader(Rasterizer* pRasterizer);
POCKETFROGCWRAPPER_API void __stdcall rasterizer_setpixelshader(Rasterizer* pRasterizer, PixelShader* shader);
POCKETFROGCWRAPPER_API Surface* __stdcall rasterizer_setrendertarget(Rasterizer* pRasterizer, Surface* target);
*/