diff --git a/src/Tizen.NUI/src/public/Common/Matrix.cs b/src/Tizen.NUI/src/public/Common/Matrix.cs
index d6816da85ba..fd9a53aab5e 100755
--- a/src/Tizen.NUI/src/public/Common/Matrix.cs
+++ b/src/Tizen.NUI/src/public/Common/Matrix.cs
@@ -19,7 +19,21 @@
 using System.ComponentModel;
 
 namespace Tizen.NUI
-{    /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+{
+    /// <summary>
+    /// The Matrix class represents transformations and projections. <br/>
+    /// The matrix is stored as a flat array and is Column Major, i.e. the storage order is as follows (numbers represent indices of array): <br/>
+    /// <code>
+    /// 0   4   8   12
+    /// 1   5   9   13
+    /// 2   6   10  14
+    /// 3   7   11  15
+    /// </code>
+    /// Each axis is contiguous in memory, so the x-axis corresponds to elements 0, 1, 2 and 3, the y-axis corresponds to
+    /// elements 4, 5, 6, 7, the z-axis corresponds to elements 12, 13, 14 and 15, and the translation vector corresponds to
+    /// elements 12, 13 and 14.
+    /// </summary>
+    /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
     [EditorBrowsable(EditorBrowsableState.Never)]
     public class Matrix : Disposable
     {
@@ -27,44 +41,94 @@ internal Matrix(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemor
         {
         }
 
+        /// This will not be public opened.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
         {
             Interop.Matrix.DeleteMatrix(swigCPtr);
         }
 
+        /// <summary>
+        /// The constructor initialized as zero.
+        /// </summary>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix() : this(Interop.Matrix.NewMatrix(), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// The constructor whether initialize matrix or not.
+        /// </summary>
+        /// <param name="initialize">True if we want to initialize values as zero. False if we just allocate and do not initalize value.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix(bool initialize) : this(Interop.Matrix.NewMatrix(initialize), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// The constructor with continuous float array.
+        /// </summary>
+        /// <param name="array">Array of float value.</param>
+        /// <remark>
+        /// Please note that NUI using column major matrix.
+        /// </remark>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix(float[] array) : this(Interop.Matrix.NewMatrix(array), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// The constructor with Rotation to be rotation transform matrix.
+        /// </summary>
+        /// <param name="rotation">Rotation information.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix(Rotation rotation) : this(Interop.Matrix.NewMatrixQuaternion(Rotation.getCPtr(rotation)), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// The constructor.
+        /// </summary>
+        /// <param name="matrix">Matrix to create this matrix from</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix(Matrix matrix) : this(Interop.Matrix.NewMatrix(Matrix.getCPtr(matrix)), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
-        public Matrix Assign(Matrix matrix)
+        /// <summary>
+        /// Assign.
+        /// </summary>
+        /// <param name="rhs">A reference to the copied handle.</param>
+        /// <returns>A reference to this.</returns>
+        internal Matrix Assign(Matrix rhs)
         {
-            Matrix ret = new Matrix(Interop.Matrix.Assign(SwigCPtr, Matrix.getCPtr(matrix)), false);
+            Matrix ret = new Matrix(Interop.Matrix.Assign(SwigCPtr, Matrix.getCPtr(rhs)), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
 
-        public static Matrix IDENTITY
+        /// <summary>
+        /// The matrix as identity
+        /// </summary>
+        /// <code>
+        /// [[1, 0, 0, 0],
+        ///  [0, 1, 0, 0],
+        ///  [0, 0, 1, 0],
+        ///  [0, 0, 0, 1]]
+        /// </code>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static Matrix Identity
         {
             get
             {
@@ -75,6 +139,12 @@ public static Matrix IDENTITY
             }
         }
 
+        /// <summary>
+        /// Get/set the value of matrix by it's index.
+        /// </summary>
+        /// <param name="index">The index to get/set value.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public float this[uint index]
         {
             set
@@ -87,41 +157,99 @@ public float this[uint index]
             }
         }
 
-        public static Vector4 operator *(Matrix arg1, Vector4 arg2)
-        {
-            return arg1?.Multiply(arg2);
-        }
-
-        public static Matrix operator *(Matrix arg1, Rotation arg2)
+        /// <summary>
+        /// Multiply Matrix and Vector4.
+        /// </summary>
+        /// <code>
+        /// returns = lhs * rhs;
+        /// </code>
+        /// <param name="lhs">The left-hand-side Matrix.</param>
+        /// <param name="rhs">The right-hand-side Vector4.</param>
+        /// <returns>The vector multiply as lhs * rhs.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static Vector4 operator *(Matrix lhs, Vector4 rhs)
+        {
+            return lhs?.Multiply(rhs);
+        }
+
+        /// <summary>
+        /// Multiply Rotation matrix and Matrix.
+        /// </summary>
+        /// <code>
+        /// returns = lhs * rhs;
+        /// </code>
+        /// <param name="lhs">The left-hand-side Rotation.</param>
+        /// <param name="rhs">The right-hand-side Matrix.</param>
+        /// <returns>The Matrix multiply as lhs * rhs.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static Matrix operator *(Rotation lhs, Matrix rhs)
         {
             Matrix ret = new Matrix(false);
-            Matrix.Multiply(ret, arg1, arg2);
+            Matrix.Multiply(ret, rhs, lhs); // Note : Mutliply function be used for time-critical path. lhs and rhs is not matched as normal sense.
             return ret;
         }
 
-        public static Matrix operator *(Matrix arg1, Matrix arg2)
+        /// <summary>
+        /// Multiply Matrix and Matrix.
+        /// </summary>
+        /// <code>
+        /// returns = lhs * rhs;
+        /// </code>
+        /// <param name="lhs">The left-hand-side Matrix.</param>
+        /// <param name="rhs">The right-hand-side Matrix.</param>
+        /// <returns>The Matrix multiply as lhs * rhs.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static Matrix operator *(Matrix lhs, Matrix rhs)
         {
-            return arg1?.Multiply(arg2);
+            return lhs?.Multiply(rhs);
         }
 
+        /// <summary>
+        /// Make matrix as identity.
+        /// </summary>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetIdentity()
         {
             Interop.Matrix.SetIdentity(SwigCPtr);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Make matrix as identity and multiply scale.
+        /// </summary>
+        /// <param name="scale">The scale value to be multiplied into identity Matrix.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetIdentityAndScale(Vector3 scale)
         {
             Interop.Matrix.SetIdentityAndScale(SwigCPtr, Vector3.getCPtr(scale));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Inverts a transform Matrix.<br/>
+        /// Any Matrix representing only a rotation and/or translation
+        /// can be inverted using this function. It is faster and more accurate then using Invert().
+        /// </summary>
+        /// <param name="result">The inverse of this Matrix.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void InvertTransform(Matrix result)
         {
             Interop.Matrix.InvertTransform(SwigCPtr, Matrix.getCPtr(result));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Generic brute force matrix invert.
+        /// </summary>
+        /// <returns>True if successful.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public bool Invert()
         {
             bool ret = Interop.Matrix.Invert(SwigCPtr);
@@ -129,12 +257,23 @@ public bool Invert()
             return ret;
         }
 
+        /// <summary>
+        /// Swaps the rows to columns.
+        /// </summary>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void Transpose()
         {
             Interop.Matrix.Transpose(SwigCPtr);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Returns the X Axis from a Transform matrix.
+        /// </summary>
+        /// <returns>The X axis.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector3 GetXAxis()
         {
             Vector3 ret = new Vector3(Interop.Matrix.GetXAxis(SwigCPtr), true);
@@ -142,6 +281,12 @@ public Vector3 GetXAxis()
             return ret;
         }
 
+        /// <summary>
+        /// Returns the Y Axis from a Transform matrix.
+        /// </summary>
+        /// <returns>The Y axis.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector3 GetYAxis()
         {
             Vector3 ret = new Vector3(Interop.Matrix.GetYAxis(SwigCPtr), true);
@@ -149,6 +294,12 @@ public Vector3 GetYAxis()
             return ret;
         }
 
+        /// <summary>
+        /// Returns the Z Axis from a Transform matrix.
+        /// </summary>
+        /// <returns>The Z axis.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector3 GetZAxis()
         {
             Vector3 ret = new Vector3(Interop.Matrix.GetZAxis(SwigCPtr), true);
@@ -156,24 +307,52 @@ public Vector3 GetZAxis()
             return ret;
         }
 
+        /// <summary>
+        /// Sets the X Axis to a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <param name="axis">The X axis.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetXAxis(Vector3 axis)
         {
             Interop.Matrix.SetXAxis(SwigCPtr, Vector3.getCPtr(axis));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Sets the Y Axis to a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <param name="axis">The Y axis.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetYAxis(Vector3 axis)
         {
             Interop.Matrix.SetYAxis(SwigCPtr, Vector3.getCPtr(axis));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Sets the Z Axis to a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <param name="axis">The Z axis.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetZAxis(Vector3 axis)
         {
             Interop.Matrix.SetZAxis(SwigCPtr, Vector3.getCPtr(axis));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Gets the translate from a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <returns>The Translation.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector4 GetTranslation()
         {
             Vector4 ret = new Vector4(Interop.Matrix.GetTranslation(SwigCPtr), false);
@@ -181,6 +360,13 @@ public Vector4 GetTranslation()
             return ret;
         }
 
+        /// <summary>
+        /// Gets the x, y, and z components of translate from a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <returns>The Translation.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector3 GetTranslation3()
         {
             Vector3 ret = new Vector3(Interop.Matrix.GetTranslation3(SwigCPtr), false);
@@ -188,36 +374,99 @@ public Vector3 GetTranslation3()
             return ret;
         }
 
+        /// <summary>
+        /// Sets the translate to a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <returns>The Translation.</returns>
+        /// <param name="translation">The translation.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetTranslation(Vector4 translation)
         {
             Interop.Matrix.SetTranslationVector4(SwigCPtr, Vector4.getCPtr(translation));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Sets the translate to a Transform matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// <param name="translation">The translation.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetTranslation(Vector3 translation)
         {
             Interop.Matrix.SetTranslationVector3(SwigCPtr, Vector3.getCPtr(translation));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Makes the axes of the matrix orthogonal to each other and of unit length.<br/>
+        /// This function is used to correct floating point errors which would otherwise accumulate
+        /// as operations are applied to the matrix.<br/>
+        /// This assumes the matrix is a transform matrix.
+        /// </summary>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void OrthoNormalize()
         {
             Interop.Matrix.OrthoNormalize(SwigCPtr);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Function to multiply two matrices and store the result onto third.<br/>
+        /// Use this method in time critical path as it does not require temporaries.<br/>
+        /// </summary>
+        /// <remark>
+        /// This Mutliply function be used for time-critical path. lhs and rhs is not matched as normal sense.
+        /// </remark>
+        /// <code>
+        /// result = rhs * lhs;
+        /// </code>
+        /// <param name="result">Result of the multiplication.</param>
+        /// <param name="lhs">The left-hand-side Matrix. this can be same matrix as result.</param>
+        /// <param name="rhs">The right-hand-side Matrix. this cannot be same matrix as result.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public static void Multiply(Matrix result, Matrix lhs, Matrix rhs)
         {
             Interop.Matrix.Multiply(Matrix.getCPtr(result), Matrix.getCPtr(lhs), Matrix.getCPtr(rhs));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Function to multiply a matrix and rotataion and store the result onto third.<br/>
+        /// Use this method in time critical path as it does not require temporaries.<br/>
+        /// </summary>
+        /// <remark>
+        /// This Mutliply function be used for time-critical path. lhs and rhs is not matched as normal sense.
+        /// </remark>
+        /// <code>
+        /// result = rhs * lhs;
+        /// </code>
+        /// <param name="result">Result of the multiplication.</param>
+        /// <param name="lhs">The left-hand-side Matrix. this can be same matrix as result.</param>
+        /// <param name="rhs">The right-hand-side Rotation.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public static void Multiply(Matrix result, Matrix lhs, Rotation rhs)
         {
             Interop.Matrix.MultiplyQuaternion(Matrix.getCPtr(result), Matrix.getCPtr(lhs), Rotation.getCPtr(rhs));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Multiply the Matrix and Vector4.
+        /// </summary>
+        /// <code>
+        /// returns = this * rhs;
+        /// </code>
+        /// <param name="rhs">The right-hand-side Vector4.</param>
+        /// <returns>The vector multiply as this * rhs.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Vector4 Multiply(Vector4 rhs)
         {
             Vector4 ret = new Vector4(Interop.Matrix.MultiplyVector4(SwigCPtr, Vector4.getCPtr(rhs)), true);
@@ -225,6 +474,16 @@ public Vector4 Multiply(Vector4 rhs)
             return ret;
         }
 
+        /// <summary>
+        /// Multiply the Matrix and Matrix.
+        /// </summary>
+        /// <code>
+        /// returns = this * rhs;
+        /// </code>
+        /// <param name="rhs">The right-hand-side Matrix.</param>
+        /// <returns>The matrix multiply as this * rhs.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public Matrix Multiply(Matrix rhs)
         {
             Matrix ret = new Matrix(Interop.Matrix.Multiply(SwigCPtr, Matrix.getCPtr(rhs)), true);
@@ -232,17 +491,39 @@ public Matrix Multiply(Matrix rhs)
             return ret;
         }
 
+        /// <summary>
+        /// Multiply the Matrix and Matrix. Result will be stored into this Matrix.
+        /// </summary>
+        /// <code>
+        /// this = this * rhs;
+        /// </code>
+        /// <param name="rhs">The right-hand-side Matrix.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void MultiplyAssign(Matrix rhs)
         {
             Interop.Matrix.MultiplyAssign(SwigCPtr, Matrix.getCPtr(rhs));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Gets the hash code of this Matrix.
+        /// </summary>
+        /// <returns>The Hash Code.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public override int GetHashCode()
         {
             return SwigCPtr.Handle.GetHashCode();
         }
 
+        /// <summary>
+        /// Compares if rhs is equal to.
+        /// </summary>
+        /// <param name="rhs">The matrix to compare.</param>
+        /// <returns>Returns true if the two matrixes are equal, otherwise false.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public bool EqualTo(Matrix rhs)
         {
             bool ret = Interop.Matrix.EqualTo(SwigCPtr, Matrix.getCPtr(rhs));
@@ -250,6 +531,13 @@ public bool EqualTo(Matrix rhs)
             return ret;
         }
 
+        /// <summary>
+        /// Compares if rhs is not equal to.
+        /// </summary>
+        /// <param name="rhs">The matrix to compare.</param>
+        /// <returns>Returns true if the two matrixes are not equal, otherwise false.</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public bool NotEqualTo(Matrix rhs)
         {
             bool ret = Interop.Matrix.NotEqualTo(SwigCPtr, Matrix.getCPtr(rhs));
@@ -257,30 +545,77 @@ public bool NotEqualTo(Matrix rhs)
             return ret;
         }
 
+        /// <summary>
+        /// Sets this matrix to contain the position, scale and rotation components.<br/>
+        /// Performs scale, rotation, then translation
+        /// </summary>
+        /// <param name="scale">Scale to apply.</param>
+        /// <param name="rotation">Rotation to apply.</param>
+        /// <param name="translation">Translation to apply.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetTransformComponents(Vector3 scale, Rotation rotation, Vector3 translation)
         {
             Interop.Matrix.SetTransformComponents(SwigCPtr, Vector3.getCPtr(scale), Rotation.getCPtr(rotation), Vector3.getCPtr(translation));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Sets this matrix to contain the inverse of the position, scale and rotation components.<br/>
+        /// Performs scale, rotation, then translation
+        /// </summary>
+        /// <param name="scale">Scale to apply.</param>
+        /// <param name="rotation">Rotation to apply.</param>
+        /// <param name="translation">Translation to apply.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetInverseTransformComponents(Vector3 scale, Rotation rotation, Vector3 translation)
         {
             Interop.Matrix.SetInverseTransformComponents(SwigCPtr, Vector3.getCPtr(scale), Rotation.getCPtr(rotation), Vector3.getCPtr(translation));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+
+        /// <summary>
+        /// Sets this matrix to contain the inverse of the orthonormal basis and position components.<br/>
+        /// Performs scale, rotation, then translation
+        /// </summary>
+        /// <param name="xAxis">The X axis of the basis.</param>
+        /// <param name="yAxis">The Y axis of the basis.</param>
+        /// <param name="zAxis">The Z axis of the basis.</param>
+        /// <param name="translation">Translation to apply.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void SetInverseTransformComponents(Vector3 xAxis, Vector3 yAxis, Vector3 zAxis, Vector3 translation)
         {
             Interop.Matrix.SetInverseTransformComponents(SwigCPtr, Vector3.getCPtr(xAxis), Vector3.getCPtr(yAxis), Vector3.getCPtr(zAxis), Vector3.getCPtr(translation));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Gets the position, scale and rotation components from the given transform matrix.<br/>
+        /// </summary>
+        /// <remark>
+        /// This matrix must not contain skews or shears.
+        /// </remark>
+        /// <param name="position">Position to set.</param>
+        /// <param name="rotation">Rotation to set - only valid if the transform matrix has not been skewed or sheared</param>
+        /// <param name="scale">Scale to set - only valid if the transform matrix has not been skewed or sheared.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public void GetTransformComponents(Vector3 position, Rotation rotation, Vector3 scale)
         {
             Interop.Matrix.GetTransformComponents(SwigCPtr, Vector3.getCPtr(position), Rotation.getCPtr(rotation), Vector3.getCPtr(scale));
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Get the value of matrix by it's index.
+        /// </summary>
+        /// <param name="index">The index to get value.</param>
+        /// <returns>A value of index</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public float ValueOfIndex(uint index)
         {
             float ret = Interop.Matrix.ValueOfIndex(SwigCPtr, index);
@@ -288,6 +623,14 @@ public float ValueOfIndex(uint index)
             return ret;
         }
 
+        /// <summary>
+        /// Get the value of matrix by it's row index and column index.
+        /// </summary>
+        /// <param name="indexRow">The row index to get value.</param>
+        /// <param name="indexColumn">The column index to get value.</param>
+        /// <returns>A value of index</returns>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         public float ValueOfIndex(uint indexRow, uint indexColumn)
         {
             float ret = Interop.Matrix.ValueOfIndex(SwigCPtr, indexRow, indexColumn);
@@ -295,18 +638,38 @@ public float ValueOfIndex(uint indexRow, uint indexColumn)
             return ret;
         }
 
-        public void SetValueAtIndex(uint index, float val)
+        /// <summary>
+        /// Set the value at matrix by it's index.
+        /// </summary>
+        /// <param name="index">The index to set value.</param>
+        /// <param name="value">The value to set.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public void SetValueAtIndex(uint index, float value)
         {
-            Interop.Matrix.SetValueAtIndex(SwigCPtr, index, val);
+            Interop.Matrix.SetValueAtIndex(SwigCPtr, index, value);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
-        public void SetValueAtIndex(uint indexRow, uint indexColumn, float val)
+        /// <summary>
+        /// Set the value at matrix by it's row index and column index.
+        /// </summary>
+        /// <param name="indexRow">The row index to set value.</param>
+        /// <param name="indexColumn">The column index to set value.</param>
+        /// <param name="value">The value to set.</param>
+        /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public void SetValueAtIndex(uint indexRow, uint indexColumn, float value)
         {
-            Interop.Matrix.SetValueAtIndex(SwigCPtr, indexRow, indexColumn, val);
+            Interop.Matrix.SetValueAtIndex(SwigCPtr, indexRow, indexColumn, value);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// Get the matrix class from native IntPtr
+        /// </summary>
+        /// <param name="cPtr">The native IntPtr.</param>
+        /// <returns>New created matrix by inputed cPtr</returns>
         internal static Matrix GetMatrixFromPtr(global::System.IntPtr cPtr)
         {
             Matrix ret = new Matrix(cPtr, false);
diff --git a/src/Tizen.NUI/src/public/Common/Matrix3.cs b/src/Tizen.NUI/src/public/Common/Matrix3.cs
index 2de4ee44d74..5b875d72dc2 100755
--- a/src/Tizen.NUI/src/public/Common/Matrix3.cs
+++ b/src/Tizen.NUI/src/public/Common/Matrix3.cs
@@ -28,6 +28,8 @@ internal Matrix3(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemo
         {
         }
 
+        /// This will not be public opened.
+        [EditorBrowsable(EditorBrowsableState.Never)]
         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
         {
             Interop.Matrix.DeleteMatrix3(swigCPtr);
diff --git a/test/Tizen.NUI.Devel.Tests.Ubuntu/Tizen.NUI.Devel.Tests/testcase/public/Common/TSMatrix.cs b/test/Tizen.NUI.Devel.Tests.Ubuntu/Tizen.NUI.Devel.Tests/testcase/public/Common/TSMatrix.cs
index f799aa6700e..b3ff755f719 100755
--- a/test/Tizen.NUI.Devel.Tests.Ubuntu/Tizen.NUI.Devel.Tests/testcase/public/Common/TSMatrix.cs
+++ b/test/Tizen.NUI.Devel.Tests.Ubuntu/Tizen.NUI.Devel.Tests/testcase/public/Common/TSMatrix.cs
@@ -159,19 +159,19 @@ public void MatrixAssign()
 
         [Test]
         [Category("P1")]
-        [Description("Matrix IDENTITY.")]
-        [Property("SPEC", "Tizen.NUI.Matrix.IDENTITY A")]
+        [Description("Matrix Identity.")]
+        [Property("SPEC", "Tizen.NUI.Matrix.Identity A")]
         [Property("SPEC_URL", "-")]
         [Property("CRITERIA", "PRO")]
         [Property("AUTHOR", "guowei.wang@samsung.com")]
-        public void MatrixIDENTITY()
+        public void MatrixIdentity()
         {
-            tlog.Debug(tag, $"MatrixIDENTITY START");
+            tlog.Debug(tag, $"MatrixIdentity START");
 
             try
             {
-                var result = Matrix.IDENTITY;
-                tlog.Debug(tag, "IDENTITY : " + result);
+                var result = Matrix.Identity;
+                tlog.Debug(tag, "Identity : " + result);
             }
             catch (Exception e)
             {
@@ -179,7 +179,7 @@ public void MatrixIDENTITY()
                 Assert.Fail("Caught Exception : Failed!");
             }
 
-            tlog.Debug(tag, $"MatrixIDENTITY END (OK)");
+            tlog.Debug(tag, $"MatrixIdentity END (OK)");
         }
 
         [Test]
@@ -330,11 +330,14 @@ public void MatrixSetXAxis()
             {
                 testingTarget.SetXAxis(vector);
 
-                var result = testingTarget.GetXAxis();
-                Assert.AreEqual(1.0f, result.X, "Should be equal!");
-                Assert.AreEqual(2.0f, result.Y, "Should be equal!");
-                Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                using (var result = testingTarget.GetXAxis())
+                {
+                    Assert.AreEqual(1.0f, result.X, "Should be equal!");
+                    Assert.AreEqual(2.0f, result.Y, "Should be equal!");
+                    Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                }
             }
+            
 
             testingTarget.Dispose();
             tlog.Debug(tag, $"MatrixSetXAxis END (OK)");
@@ -360,10 +363,12 @@ public void MatrixSetYAxis()
             {
                 testingTarget.SetYAxis(vector);
 
-                var result = testingTarget.GetYAxis();
-                Assert.AreEqual(1.0f, result.X, "Should be equal!");
-                Assert.AreEqual(2.0f, result.Y, "Should be equal!");
-                Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                using (var result = testingTarget.GetYAxis())
+                {
+                    Assert.AreEqual(1.0f, result.X, "Should be equal!");
+                    Assert.AreEqual(2.0f, result.Y, "Should be equal!");
+                    Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                }
             }
 
             testingTarget.Dispose();
@@ -390,10 +395,12 @@ public void MatrixSetZAxis()
             {
                 testingTarget.SetZAxis(vector);
 
-                var result = testingTarget.GetZAxis();
-                Assert.AreEqual(1.0f, result.X, "Should be equal!");
-                Assert.AreEqual(2.0f, result.Y, "Should be equal!");
-                Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                using (var result = testingTarget.GetZAxis())
+                {
+                    Assert.AreEqual(1.0f, result.X, "Should be equal!");
+                    Assert.AreEqual(2.0f, result.Y, "Should be equal!");
+                    Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                }
             }
 
             testingTarget.Dispose();
@@ -419,11 +426,13 @@ public void MatrixGetTranslation()
             {
                 testingTarget.SetTranslation(vector);
 
-                var result = testingTarget.GetTranslation();
-                Assert.AreEqual(1.0f, result.X, "Should be equal!");
-                Assert.AreEqual(2.0f, result.Y, "Should be equal!");
-                Assert.AreEqual(3.0f, result.Z, "Should be equal!");
-                Assert.AreEqual(4.0f, result.W, "Should be equal!");
+                using (var result = testingTarget.GetTranslation())
+                {
+                    Assert.AreEqual(1.0f, result.X, "Should be equal!");
+                    Assert.AreEqual(2.0f, result.Y, "Should be equal!");
+                    Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                    Assert.AreEqual(4.0f, result.W, "Should be equal!");
+                }
             }
 
             testingTarget.Dispose();
@@ -449,10 +458,12 @@ public void MatrixSetTranslationWithVector3()
             {
                 testingTarget.SetTranslation(vector);
 
-                var result = testingTarget.GetTranslation3();
-                Assert.AreEqual(1.0f, result.X, "Should be equal!");
-                Assert.AreEqual(2.0f, result.Y, "Should be equal!");
-                Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                using (var result = testingTarget.GetTranslation3())
+                {
+                    Assert.AreEqual(1.0f, result.X, "Should be equal!");
+                    Assert.AreEqual(2.0f, result.Y, "Should be equal!");
+                    Assert.AreEqual(3.0f, result.Z, "Should be equal!");
+                }
             }
 
             testingTarget.Dispose();
@@ -1002,9 +1013,9 @@ public void MatrixMultiplyOperatorWithRotation()
 
             try
             {
-                Rotation rhs = new Rotation();
-                Matrix ret = testingTarget * rhs;
-                rhs.Dispose();
+                Rotation lhs = new Rotation();
+                Matrix ret = lhs * testingTarget;
+                lhs.Dispose();
                 ret.Dispose();
             }
             catch (Exception e)