colorshortcuts.as

flash,做點對點移動,殘影+可調整速度

			*/
			var cfm:ColorTransform = new ColorTransform(mc, mc, mc, 1, co, co, co, 0);
			p_obj.transform.colorTransform = cfm;
		}

		/**
		 * _saturation
		 * Saturation of an object: 0 -> [1] -> 2
		 */
		public static function _saturation_get (p_obj:Object, p_parameters:Array, p_extra:Object = null):Number {

			var mtx:Array = getObjectMatrix(p_obj);

			var isDumb:Boolean = p_parameters[0];
			var rl:Number = isDumb ? 1/3 : LUMINANCE_R;
			var gl:Number = isDumb ? 1/3 : LUMINANCE_G;
			var bl:Number = isDumb ? 1/3 : LUMINANCE_B;

			var mc:Number = ((mtx[0]-rl)/(1-rl) + (mtx[6]-gl)/(1-gl) + (mtx[12]-bl)/(1-bl)) / 3;					// Color saturation as determined by the main channels
			var cc:Number = 1 - ((mtx[1]/gl + mtx[2]/bl + mtx[5]/rl + mtx[7]/bl + mtx[10]/rl + mtx[11]/gl) / 6);	// Color saturation as determined by the other channels
			return (mc + cc) / 2;
		}
		public static function _saturation_set (p_obj:Object, p_value:Number, p_parameters:Array, p_extra:Object = null): void {
			
			var isDumb:Boolean = p_parameters[0];
			var rl:Number = isDumb ? 1/3 : LUMINANCE_R;
			var gl:Number = isDumb ? 1/3 : LUMINANCE_G;
			var bl:Number = isDumb ? 1/3 : LUMINANCE_B;

			var sf:Number = p_value;
			var nf:Number = 1-sf;
			var nr:Number = rl * nf;
			var ng:Number = gl * nf;
			var nb:Number = bl * nf;

			var mtx:Array = [
				nr+sf,	ng,		nb,		0,	0,
				nr,		ng+sf,	nb,		0,	0,
				nr,		ng,		nb+sf,	0,	0,
				0,  	0, 		0,  	1,  0
			];
			setObjectMatrix(p_obj, mtx);
		}

		/**
		 * _contrast
		 * Contrast of an object: -1 -> [0] -> +1
		 */
		public static function _contrast_get (p_obj:Object, p_parameters:Array, p_extra:Object = null):Number {

			/*
			// Using ColorMatrix:
			var mtx:Array = getObjectMatrix(p_obj);

			var mc:Number = ((mtx[0] + mtx[6] + mtx[12]) / 3) - 1;		// Contrast as determined by the main channels
			var co:Number = (mtx[4] + mtx[9] + mtx[14]) / 3 / -128;		// Contrast as determined by the offset channel
			*/
			var cfm:ColorTransform = p_obj.transform.colorTransform;
			var mc:Number;	// Contrast as determined by the main channels
			var co:Number;	// Contrast as determined by the offset channel
			mc = ((cfm.redMultiplier + cfm.greenMultiplier + cfm.blueMultiplier) / 3) - 1;
			co = (cfm.redOffset + cfm.greenOffset + cfm.blueOffset) / 3 / -128;
			/*
			if (cfm.ra < 100) {
				// Low contrast
				mc = ((cfm.ra + cfm.ga + cfm.ba) / 300) - 1;
				co = (cfm.rb + cfm.gb + cfm.bb) / 3 / -128;
			} else {
				// High contrast
				mc = (((cfm.ra + cfm.ga + cfm.ba) / 300) - 1) / 37;
				co = (cfm.rb + cfm.gb + cfm.bb) / 3 / -3840;
			}
			*/

			return (mc+co)/2;
		}
		public static function _contrast_set (p_obj:Object, p_value:Number, p_parameters:Array, p_extra:Object = null): void {
			
			var mc:Number;	// Main channel
			var co:Number;	// Channel offset
			mc = p_value + 1;
			co = Math.round(p_value*-128);

			/*
			if (p_value < 0) {
				// Low contrast
				mc = p_value + 1;
				co = Math.round(p_value*-128);
			} else {
				// High contrast
				mc = (p_value * 37) + 1;
				co = Math.round(p_value*-3840);
			}
			*/
			
			// Flash: * 8, * -512

			/*
			// Using ColorMatrix:
			var mtx:Array = [
				mc,	0,	0, 	0, co,
				0,	mc,	0, 	0, co,
				0,	0,	mc,	0, co,
				0,  0, 	0, 	1,  0
			];
			setObjectMatrix(p_obj, mtx);
			*/
			var cfm:ColorTransform = new ColorTransform(mc, mc, mc, 1, co, co, co, 0);
			p_obj.transform.colorTransform = cfm;
		}

		/**
		 * _hue
		 * Hue of an object: -180 -> [0] -> 180
		 */
		public static function _hue_get (p_obj:Object, p_parameters:Array, p_extra:Object = null):Number {

			var mtx:Array = getObjectMatrix(p_obj);

			// Find the current Hue based on a given matrix.
			// This is a kind of a brute force method by sucessive division until a close enough angle is found.
			// Reverse-engineering the hue equation would be is a better choice, but it's hard to find material
			// on the correct calculation employed by Flash.
			// This code has to run only once (before the tween starts), so it's good enough.

			var hues:Array = [];
			var i:Number;

			hues[0] = {angle:-179.9, matrix:getHueMatrix(-179.9)};
			hues[1] = {angle:180, matrix:getHueMatrix(180)};
		
			for (i = 0; i < hues.length; i++) {
				hues[i].distance = getHueDistance(mtx, hues[i].matrix);
			}

			var maxTries:Number = 15;	// Number o maximum divisions until the hue is found
			var angleToSplit:Number;

			for (i = 0; i < maxTries; i++) {
				// Find the nearest angle
				if (hues[0].distance < hues[1].distance) {
					// First is closer
					angleToSplit = 1;
				} else {
					// Second is closer
					angleToSplit = 0;
				}
				hues[angleToSplit].angle = (hues[0].angle + hues[1].angle)/2;
				hues[angleToSplit].matrix = getHueMatrix(hues[angleToSplit].angle)
				hues[angleToSplit].distance = getHueDistance(mtx, hues[angleToSplit].matrix);
			}

			return hues[angleToSplit].angle;
		}

		public static function _hue_set (p_obj:Object, p_value:Number, p_parameters:Array, p_extra:Object = null): void {
			setObjectMatrix(p_obj, getHueMatrix(p_value));
		}

		public static function getHueDistance (mtx1:Array, mtx2:Array): Number {
			return (Math.abs(mtx1[0] - mtx2[0]) + Math.abs(mtx1[1] - mtx2[1]) + Math.abs(mtx1[2] - mtx2[2]));
		}

		public static function getHueMatrix (hue:Number): Array {
			var ha:Number = hue * Math.PI/180;		// Hue angle, to radians

			var rl:Number = LUMINANCE_R;
			var gl:Number = LUMINANCE_G;
			var bl:Number = LUMINANCE_B;

			var c:Number = Math.cos(ha);
			var s:Number = Math.sin(ha);

			var mtx:Array = [
				(rl + (c * (1 - rl))) + (s * (-rl)),
				(gl + (c * (-gl))) + (s * (-gl)),
				(bl + (c * (-bl))) + (s * (1 - bl)),
				0, 0,

				(rl + (c * (-rl))) + (s * 0.143),
				(gl + (c * (1 - gl))) + (s * 0.14),
				(bl + (c * (-bl))) + (s * -0.283),
				0, 0,

				(rl + (c * (-rl))) + (s * (-(1 - rl))),
				(gl + (c * (-gl))) + (s * gl),
				(bl + (c * (1 - bl))) + (s * bl),
				0, 0,

				0, 0, 0, 1, 0
			];
			
			return mtx;
		}


		// ==================================================================================================================================
		// AUXILIARY functions --------------------------------------------------------------------------------------------------------------

		private static function getObjectMatrix(p_obj:Object): Array {
			// Get the current color matrix of an object
			for (var i:Number = 0; i < p_obj.filters.length; i++) {
				if (p_obj.filters[i] is ColorMatrixFilter) {
					return p_obj.filters[i].matrix.concat();
				}
			}
			return [
				1, 0, 0, 0, 0,
				0, 1, 0, 0, 0,
				0, 0, 1, 0, 0,
				0, 0, 0, 1, 0
			];
		}

		private static function setObjectMatrix(p_obj:Object, p_matrix:Array): void {
			// Set the current color matrix of an object
			var objFilters:Array = p_obj.filters.concat();
			var found:Boolean = false;
			for (var i:Number = 0; i < objFilters.length; i++) {
				if (objFilters[i] is ColorMatrixFilter) {
					objFilters[i].matrix = p_matrix.concat();
					found = true;
				}
			}
			if (!found) {
				// Has to create a new color matrix filter
				var cmtx:ColorMatrixFilter = new ColorMatrixFilter(p_matrix);
				objFilters[objFilters.length] = cmtx;
			}
			p_obj.filters = objFilters;
		}

	}

}