Rotation help

  public class Transform
  {
    private Vector3 _Rotation;
    Matrix _World;
    private bool _Dirty;
    public bool Dirty
    {
      get
      {
        return _Dirty;
      }
      set
      {
        _Dirty = value;
      }
    }
    private Matrix _MatScale;
    private Quaternion _Orientation;
    private Quaternion _OrientationDelta;
    private Matrix _MatRotation;
    private Matrix _MatTranslation;
    private Vector3 _Left = Vector3.Left;
    private Vector3 _Up = Vector3.Up;
    private Vector3 _Forward = Vector3.Forward;
    public Transform()
    {
      _Scale = Vector3.One;
      _Position = Vector3.Zero;
      _Rotation = Vector3.Zero;
      _Orientation = Quaternion.Identity;
      _Dirty = true;
    }
    public Matrix World
    {
      get
      {  
        if (_Dirty)
        {
          Matrix.CreateScale(ref _Scale, out _MatScale);
          Matrix.CreateFromQuaternion(ref _Orientation, out _MatRotation);
          Matrix.CreateTranslation(ref _Position, out _MatTranslation);

          _World = _MatScale *
                 _MatRotation *
                 _MatTranslation;

          _Dirty = false;
        }

        return _World;
      }

    }
    #region Position
    private Vector3 _Position;

    ///<summary>
    ///Set the position
    ///</summary>
    ///<param name="x"></param>
    ///<param name="y"></param>
    ///<param name="z"></param>
    ///<returns></returns>
    public void SetPosition(float x, float y, float z)
    {
      _Position.X = x;
      _Position.Y = y;
      _Position.Z = z;
      _Dirty = true;
    }
    public void SetPosition(Vector3 position)
    {
      _Position = position;
      _Dirty = true;
    }

    public void SetPosition(ref Vector3 position)
    {
      _Position.X = position.X;
      _Position.Y = position.Y;
      _Position.Z = position.Z;
      _Dirty = true;
    }
    ///<summary>
    ///Get the position
    ///</summary>
    public Vector3 Position
    {
      get
      {
        return _Position;
      }
    }

    ///<summary>
    ///Set the X component of position
    ///</summary>
    public float PositionX
    {
      get
      {
        return _Position.X;
      }
      set
      {
        _Position.X = value;
        _Dirty = true;
      }
    }

    ///<summary>
    ///Set the Y component of position
    ///</summary>
    public float PositionY
    {
      get
      {
        return _Position.Y;
      }
      set
      {
        _Position.Y = value;
        _Dirty = true;
      }
    }

    ///<summary>
    ///Set the Z component of position
    ///</summary>
    public float PositionZ
    {
      get
      {
        return _Position.Z;
      }
      set
      {
        _Position.Z = value;
        _Dirty = true;
      }
    }
    #endregion
    #region Scale
    private Vector3 _Scale;

    ///<summary>
    ///Set the Scale
    ///</summary>
    ///<param name="x"></param>
    ///<param name="y"></param>
    ///<param name="z"></param>
    ///<returns></returns>
    public void SetScale(float x, float y, float z)
    {
      _Scale.X = x;
      _Scale.Y = y;
      _Scale.Z = z;
      _Dirty = true;
    }

    ///<summary>
    ///Get the Scale
    ///</summary>
    public Vector3 Scale
    {
      get
      {
        return _Scale;
      }
    }

    ///<summary>
    ///Set the X component of Scale
    ///</summary>
    public float ScaleX
    {
      get
      {
        return _Scale.X;
      }
      set
      {
        _Scale.X = value;
        _Dirty = true;
      }
    }

    ///<summary>
    ///Set the Y component of Scale
    ///</summary>
    public float ScaleY
    {
      get
      {
        return _Scale.Y;
      }
      set
      {
        _Scale.Y = value;
        _Dirty = true;
      }
    }

    ///<summary>
    ///Set the Z component of Scale
    ///</summary>
    public float ScaleZ
    {
      get
      {
        return _Scale.Z;
      }
      set
      {
        _Scale.Z = value;
        _Dirty = true;
      }
    }
    #endregion

    public void AddPitch(float pitch)
    {
      Quaternion.CreateFromAxisAngle(ref _Left, pitch, out _OrientationDelta);
      _Orientation *= _OrientationDelta;
      _Dirty = true;
    }
    public void AddYaw(float yaw)
    {
      Quaternion.CreateFromAxisAngle(ref _Up, yaw, out _OrientationDelta);
      _Orientation *= _OrientationDelta;
      _Dirty = true;

    }
    public void AddRoll(float roll)
    {
      Quaternion.CreateFromAxisAngle(ref _Forward, roll, out _OrientationDelta);
      _Orientation *= _OrientationDelta;
      _Dirty = true;
    }
  }