raster.as

flex3d 的源码

			if (steep){
				drawAlphaPixel(bmp,ypx2,xpx2,alpha,c);
			}else{
				drawAlphaPixel(bmp,xpx2, ypx2,alpha,c);
			}
			alpha=((yend)%1)*xgap;
			if (steep){
				drawAlphaPixel(bmp,ypx2 + 1,xpx2,alpha,c);
			}else{
				drawAlphaPixel(bmp,xpx2, ypx2 + 1,alpha,c);
			}
			 
			var x:int=xpx1;
			
			while (x++<xpx2){
				alpha=1-((intery)%1);
				if (steep){
					drawAlphaPixel(bmp,intery,x,alpha,c);
				}else{
					drawAlphaPixel(bmp,x,intery,alpha,c);
				}
				alpha=intery%1;
				if (steep){
					drawAlphaPixel(bmp,intery+1,x,alpha,c);
				}else{
					drawAlphaPixel(bmp,x,intery+1,alpha,c);
				}
				intery = intery + gradient
			}
    	}
    	
    	/**
    	 * Draws a Quadratic Bezier Curve (equivalent to a DisplayObject's graphics#curveTo)
    	 * 
    	 * TODO: Determine whether x/y params would be better named as anchor/control
    	 * 
    	 * @param bmp 			BimtapData to draw on (alpha set to true)
    	 * @param x0 			x position of first anchor
    	 * @param y0 			y position of first anchor
    	 * @param x1 			x position of control point
    	 * @param y1 			y position of control point
    	 * @param x2 			x position of second anchor
    	 * @param y2 			y position of second anchor
    	 * @param c 			color
		 * @param resolution 	[optional] determines the accuracy of the curve's length (higher number = greater accuracy = longer process)
    	 * */
    	public static function quadBezier( bmp:BitmapData, x0:int, y0:int, x1:int, y1:int, x2:int, y2:int, c:Number, resolution:int = 3) : void
    	{
    		
    		var ox:Number = x0;
	    	var oy:Number = y0;
	    	var px:int;
    		var py:int;
	    	var dist:Number = 0;
	    	
	    	var inverse:Number = 1 / resolution;
	    	var interval:Number;
    		var intervalSq:Number;
    		var diff:Number;
    		var diffSq:Number;
	    	
	    	var i:int = 0;
	    	while( ++i <= resolution )
	    	{
	    		
	    		interval = inverse * i;
    			intervalSq = interval * interval;
    			diff = 1 - interval;
    			diffSq = diff * diff;
    			
	    		px = diffSq * x0 + 2 * interval * diff * x1 + intervalSq * x2;
	    		py = diffSq * y0 + 2 * interval * diff * y1 + intervalSq * y2;
	    		
	    		dist += Math.sqrt( ( px - ox ) * ( px - ox ) + ( py - oy ) * ( py - oy ) );
	    		
	    		ox = px;
	    		oy = py;
	    		
	    	}
    		
    		//approximates the length of the curve
    		var curveLength:int = Math.floor( dist );
    		inverse = 1 / curveLength;
			
			var lastx:int=x0;
			var lasty:int=y0;
		    		
    		i = -1;
    		while( ++i <= curveLength )
    		{
    			
    			interval = inverse * i;
    			intervalSq = interval * interval;
    			diff = 1 - interval;
    			diffSq = diff * diff;
    			
    			px = diffSq * x0 + 2 * interval * diff * x1 + intervalSq * x2;
    			py = diffSq * y0 + 2 * interval * diff * y1 + intervalSq * y2;
    			
				line(bmp,lastx,lasty,px,py,c);
				lastx=px;
				lasty=py;
    			
    		}
    		
    	}
    	
    	/**
    	 * Draws a Cubic Bezier Curve
    	 * 
    	 * TODO: Determine whether x/y params would be better named as anchor/control
    	 * 
    	 * @param bmp 			BimtapData to draw on (alpha set to true)
    	 * @param x0 			x position of first anchor
    	 * @param y0 			y position of first anchor
    	 * @param x1 			x position of control point
    	 * @param y1 			y position of control point
    	 * @param x2 			x position of second control point
    	 * @param y2 			y position of second control point
    	 * @param x3 			x position of second anchor
    	 * @param y3 			y position of second anchor
    	 * @param c 			color
		 * @param resolution 	[optional] determines the accuracy of the curve's length (higher number = greater accuracy = longer process)
    	 * */
    	public static function cubicBezier( bmp:BitmapData, x0:int, y0:int, x1:int, y1:int, x2:int, y2:int, x3:int, y3:int, c:Number, resolution:int = 5 ) : void
    	{
    		
    		var ox:Number = x0;
	    	var oy:Number = y0;
	    	var px:int;
    		var py:int;
	    	var dist:Number = 0;
	    	
	    	var inverse:Number = 1 / resolution;
	    	var interval:Number;
    		var intervalSq:Number;
    		var intervalCu:Number;
    		var diff:Number;
    		var diffSq:Number;
    		var diffCu:Number;
	    	
	    	var i:int = 0;
	    	while( ++i <= resolution )
	    	{
	    		
	    		interval = inverse * i;
    			intervalSq = interval * interval;
    			intervalCu = intervalSq * interval;
    			diff = 1 - interval;
    			diffSq = diff * diff;
    			diffCu = diffSq * diff;
    			
    			px = diffCu * x0 + 3 * interval * diffSq * x1 + 3 * x2 * intervalSq * diff + x3 * intervalCu;
	    		py = diffCu * y0 + 3 * interval * diffSq * y1 + 3 * y2 * intervalSq * diff + y3 * intervalCu;
	    		
	    		dist += Math.sqrt( ( px - ox ) * ( px - ox ) + ( py - oy ) * ( py - oy ) );
	    		
	    		ox = px;
	    		oy = py;
	    		
	    	}
    		
    		//approximates the length of the curve
    		var curveLength:int = Math.floor( dist );
    		inverse = 1 / curveLength;
			
			var lastx:int=x0;
			var lasty:int=y0;
    		
    		i = -1;
    		while( ++i <= curveLength )
    		{
    			
    			interval = inverse * i;
    			intervalSq = interval * interval;
    			intervalCu = intervalSq * interval;
    			diff = 1 - interval;
    			diffSq = diff * diff;
    			diffCu = diffSq * diff;
    			
    			px = diffCu * x0 + 3 * interval * diffSq * x1 + 3 * x2 * intervalSq * diff + x3 * intervalCu;
	    		py = diffCu * y0 + 3 * interval * diffSq * y1 + 3 * y2 * intervalSq * diff + y3 * intervalCu;
    			
    			line(bmp,lastx,lasty,px,py,c);
				lastx=px;
				lasty=py;
    			
    		}
    		
    	}
		
		// ------------------------------------------------
		//
		// ---o private static methods
		//
		// ------------------------------------------------
			
		/**
		* Draw an alpha32 pixel
		*/
		private static function drawAlphaPixel(bmp:BitmapData,x:int,y:int,a:Number,c:Number):void{
			
			var g:uint=bmp.getPixel32(x,y);
			
			var r0:uint= ((g & 0x00FF0000) >> 16);
			var g0:uint= ((g & 0x0000FF00) >> 8);
			var b0:uint= ((g & 0x000000FF));
			
			var r1:uint= ((c & 0x00FF0000) >> 16);
			var g1:uint= ((c & 0x0000FF00) >> 8);
			var b1:uint= ((c & 0x000000FF));
			
			
			var ac:Number=0xFF;
			var rc:Number=r1*a+r0*(1-a);
			var gc:Number=g1*a+g0*(1-a);
			var bc:Number=b1*a+b0*(1-a);
			
			
			var n:uint=(ac<<24)+(rc<<16)+(gc<<8)+bc;
			
			bmp.setPixel32(x,y,n);
		}
		
		/**
		* Check a triangle line
		*/
		private static function checkLine(o:Object,x:int,y:int,bmp:BitmapData,c:int,r:Rectangle):void{
			if (o[y]){
				if (o[y]>x){
					r.width=o[y]-x;
					r.x=x;
					r.y=y;
					bmp.fillRect(r,c);
				}else{
					r.width=x-o[y];
					r.x=o[y];
					r.y=y;
					bmp.fillRect(r,c);
				}
			}else{
				o[y]=x;
			}
		}
		
		/**
		* Special line for filled triangle
		*/
		private static function lineTri(o:Object,bmp:BitmapData,x0:int,y0:int,x1:int,y1:int,c:Number):void{
			var steep:Boolean= (y1-y0)*(y1-y0) > (x1-x0)*(x1-x0);
			var swap:int;
			
			if (steep){
				swap=x0; x0=y0; y0=swap;
				swap=x1; x1=y1; y1=swap;
			}
			if (x0>x1){
				x0^=x1; x1^=x0; x0^=x1;
				y0^=y1; y1^=y0; y0^=y1;
			}
			
			var deltax:int = x1 - x0
			var deltay:int = Math.abs(y1 - y0);
			var error:int = 0;
			var y:int = y0;			
			var ystep:int = y0<y1 ? 1 : -1;
			var x:int=x0;
			var xend:int=x1-(deltax>>1);
			var fx:int=x1;
			var fy:int=y1;
			var r:Rectangle=new Rectangle();
			var px:int=0;
			r.x=0;
			r.y=0;
			r.width=0;
			r.height=1;
										
			while (x++<=xend){
				if (steep){
					checkLine(o,y,x,bmp,c,r);
					if (fx!=x1 && fx!=xend)checkLine(o,fy,fx+1,bmp,c,r);
				}
					
				error += deltay;
				if ((error<<1) >= deltax){
					if (!steep){
						checkLine(o,x-px+1,y,bmp,c,r);
						if (fx!=xend)checkLine(o,fx+1,fy,bmp,c,r);
				
					}
					px=0;
					y+=ystep;
					fy-=ystep;
					error -= deltax; 
				}
				px++;
				fx--;
			}
			
			if (!steep){
				checkLine(o,x-px+1,y,bmp,c,r);
			}
			
		}
	}		
}