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;
                  }
  
          }
  
  }