 			
 			_numPushes--;
 			if (restore)
+			{
 				_matrix.copyRawDataFrom(_data, _numPushes * 16);
+				_invalidComponents = COMPONENT_ALL;
+			}
 			
 			if (!_locked)
 				_changed.execute(this);

		
	public class Matrix4x4 implements IWatchable
	{
		private static const FACTORY			: Factory			= Factory.getFactory(Matrix4x4);
		private static const RAD2DEG			: Number			= 180. / Math.PI;
		private static const DEG2RAD			: Number			= Math.PI / 180.;
		private static const EPSILON			: Number			= 1e-100;

		private static const TMP_VECTOR			: Vector.<Number>	= new <Number>[];
		private static const TMP_VECTOR4		: Vector4			= new Vector4();
		private static const TMP_MATRIX			: Matrix4x4			= new Matrix4x4();
		
		private var _data		: Vector.<Number>		= new <Number>[];
		private var _numPushes	: int					= 0;
		
		private var _locked		: Boolean				= false;
		private var _changed	: Signal				= new Signal('Matrix4x4.changed');
		
		minko_math var _matrix	: flash.geom.Matrix3D	= new flash.geom.Matrix3D();
		
		public function get translationX() : Number
		{
			return getTranslation(TMP_VECTOR4).x;
		}
		public function set translationX(value : Number) : void
		{
			setTranslation(value, NaN, NaN);
		}
		
		public function get translationY() : Number
		{
			return getTranslation(TMP_VECTOR4).y;
		}
		public function set translationY(value : Number) : void
		{
			setTranslation(NaN, value, NaN);
		}
		
		public function get translationZ() : Number
		{
			return getTranslation(TMP_VECTOR4).z;
		}
		public function set translationZ(value : Number) : void
		{
			setTranslation(NaN, NaN, value);
		}
		
		public function get rotationX() : Number
		{
			return getRotation(TMP_VECTOR4).x;
		}
		public function set rotationX(value : Number) : void
		{
			setRotation(value, NaN, NaN);
		}
		
		public function get rotationY() : Number
		{
			return getRotation(TMP_VECTOR4).y;
		}
		public function set rotationY(value : Number) : void
		{
			setRotation(NaN, value, NaN);
		}
		
		public function get rotationZ() : Number
		{
			return getRotation(TMP_VECTOR4).z;
		}
		public function set rotationZ(value : Number) : void
		{
			setRotation(NaN, NaN, value);
		}
		
		public function get scaleX() : Number
		{
			return getScale(TMP_VECTOR4).x;
		}
		public function set scaleX(value : Number) : void
		{
			setScale(value, NaN, NaN);
		}
		
		public function get scaleY() : Number
		{
			return getScale(TMP_VECTOR4).y;
		}
		public function set scaleY(value : Number) : void
		{
			setScale(NaN, value, NaN);
		}
		
		public function get scaleZ() : Number
		{
			return getScale(TMP_VECTOR4).z;
		}
		public function set scaleZ(value : Number) : void
		{
			setScale(NaN, NaN, value);
		}
		
		public function get determinant(): Number

		
		public function setScale(x : Number, y : Number, z : Number) : Matrix4x4
		{
			if (_invalidComponents)
				updateComponents();
			
			_scale.x = x;
			_scale.y = y;
			_scale.z = z;
			
			_scale._vector.setTo(x, y, z);
			
			_matrix.recompose(new <Vector3D>[
				_translation._vector,
				_rotation._vector,
				_scale._vector
			]);
			
			if (!_locked)
				_changed.execute(this);
