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

		
		public function setRotation(x : Number, y : Number, z : Number) : Matrix4x4
		{
			var components 	: Vector.<Vector3D>	= _matrix.decompose();
			var rotation	: Vector3D			= components[1];
			
			if (!isNaN(x))
				rotation.x = x;
			if (!isNaN(y))
				rotation.y = y;
			if (!isNaN(z))
				rotation.z = z;
			
			_matrix.recompose(components);
			
			if (!_locked)
				_changed.execute(this);
			
			return this;
		}
		
		public function getScale(output : Vector4 = null) : Vector4

		
	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 static const COMPONENT_TRANSLATION	: uint				= 1;
		private static const COMPONENT_ROTATION		: uint				= 2;
		private static const COMPONENT_SCALE		: uint				= 4;
		private static const COMPONENT_ALL			: uint				= 7;
		
		private var _data				: Vector.<Number>	= new <Number>[];
		private var _rotation			: Vector4			= new Vector4();
		private var _scale				: Vector4			= new Vector4();
		private var _translation		: Vector4			= new Vector4();
		private var _invalidComponents	: uint				= 7;
		private var _numPushes			: uint				= 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
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_TRANSLATION);
			
			return _translation.x;
		}
		public function set translationX(value : Number) : void
		{
			setTranslation(value, _translation.y, _translation.z);
		}
		
		public function get translationY() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_TRANSLATION);
			
			return _translation.y;
		}
		public function set translationY(value : Number) : void
		{
			setTranslation(_translation.x, value, _translation.z);
		}
		
		public function get translationZ() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_TRANSLATION);
			
			return _translation.z;
		}
		public function set translationZ(value : Number) : void
		{
			setTranslation(_translation.x, _translation.y, value);
		}
		
		public function get rotationX() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_ROTATION);
			
			return _rotation.x;
		}
		public function set rotationX(value : Number) : void
		{
			setRotation(value, _rotation.y, _rotation.z);
		}
		
		public function get rotationY() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_ROTATION);
			
			return _rotation.y;
		}
		public function set rotationY(value : Number) : void
		{
			setRotation(_rotation.x, value, _rotation.z);
		}
		
		public function get rotationZ() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_ROTATION);
			
			return _rotation.z;
		}
		public function set rotationZ(value : Number) : void
		{
			setRotation(_rotation.x, _rotation.y, value);
		}
		
		public function get scaleX() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_SCALE);
			
			return _scale.x;
		}
		public function set scaleX(value : Number) : void
		{
			setScale(value, _scale.y, _scale.z);
		}
		
		public function get scaleY() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_SCALE);
			
			return _scale.y;
		}
		public function set scaleY(value : Number) : void
		{
			setScale(_scale.x, value, _scale.z);
		}
		
		public function get scaleZ() : Number
		{
			if (_invalidComponents)
				updateComponents(COMPONENT_SCALE);
			
			return _scale.z;
		}
		public function set scaleZ(value : Number) : void
		{
			setScale(_scale.x, _scale.y, value);
		}
		
		public function get determinant(): Number
