private static void _UpdateScale(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 scl = obj.transform.localScale;

        switch (pType)
        {
        case GameObjectPropertyType.Scale_X:
            scl.x = val;
            break;

        case GameObjectPropertyType.Scale_Y:
            scl.y = val;
            break;

        case GameObjectPropertyType.Scale_Z:
            scl.z = val;
            break;

        case GameObjectPropertyType.Uniform_Scale:
            scl.x = val;
            scl.y = val;
            scl.z = val;
            break;
        }
        obj.transform.localScale = scl;
    }
    private static void _UpdateAngularVelocity(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 rot = obj.transform.localRotation.eulerAngles;

        switch(pType) {
        case GameObjectPropertyType.AngularVelocity_X_Euler:
            rot.x += val;
        break;
        case GameObjectPropertyType.AngularVelocity_Y_Euler:
            rot.y += val;
        break;
        case GameObjectPropertyType.AngularVelocity_Z_Euler:
            rot.z += val;
        break;
        }
        obj.transform.localRotation = Quaternion.Euler(rot);
    }
 public static void UpdateGameObject(GameObject obj, GameObjectPropertyType pType, float val )
 {
     if( pType == GameObjectPropertyType.Position_X 	||
     pType == GameObjectPropertyType.Position_Y 		||
     pType == GameObjectPropertyType.Position_Z 		)
     {
         _UpdatePosition(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.LocalPosition_X ||
     pType == GameObjectPropertyType.LocalPosition_Y 		 ||
     pType == GameObjectPropertyType.LocalPosition_Z 		 )
     {
         _UpdateLocalPosition(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.Rotation_X_Euler 	||
     pType == GameObjectPropertyType.Rotation_Y_Euler 			||
     pType == GameObjectPropertyType.Rotation_Z_Euler 			)
     {
         _UpdateRotation(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.LocalRotation_X_Euler 	||
     pType == GameObjectPropertyType.LocalRotation_Y_Euler 			||
     pType == GameObjectPropertyType.LocalRotation_Z_Euler 			)
     {
         _UpdateLocalRotation(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.Scale_X 	||
     pType == GameObjectPropertyType.Scale_Y 			||
     pType == GameObjectPropertyType.Scale_Z 			||
     pType == GameObjectPropertyType.Uniform_Scale 		)
     {
         _UpdateScale(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.Velocity_X ||
     pType == GameObjectPropertyType.Velocity_Y 			||
     pType == GameObjectPropertyType.Velocity_Z 			)
     {
         _UpdateVelocity(obj, pType, val);
     }
     else if( pType == GameObjectPropertyType.AngularVelocity_X_Euler ||
     pType == GameObjectPropertyType.AngularVelocity_Y_Euler 		 ||
     pType == GameObjectPropertyType.AngularVelocity_Z_Euler 		 )
     {
         _UpdateAngularVelocity(obj, pType, val);
     }
 }
 public static void UpdateGameObject(GameObject obj, GameObjectPropertyType pType, float val)
 {
     if (pType == GameObjectPropertyType.Position_X ||
         pType == GameObjectPropertyType.Position_Y ||
         pType == GameObjectPropertyType.Position_Z)
     {
         _UpdatePosition(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.LocalPosition_X ||
              pType == GameObjectPropertyType.LocalPosition_Y ||
              pType == GameObjectPropertyType.LocalPosition_Z)
     {
         _UpdateLocalPosition(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.Rotation_X_Euler ||
              pType == GameObjectPropertyType.Rotation_Y_Euler ||
              pType == GameObjectPropertyType.Rotation_Z_Euler)
     {
         _UpdateRotation(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.LocalRotation_X_Euler ||
              pType == GameObjectPropertyType.LocalRotation_Y_Euler ||
              pType == GameObjectPropertyType.LocalRotation_Z_Euler)
     {
         _UpdateLocalRotation(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.Scale_X ||
              pType == GameObjectPropertyType.Scale_Y ||
              pType == GameObjectPropertyType.Scale_Z ||
              pType == GameObjectPropertyType.Uniform_Scale)
     {
         _UpdateScale(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.Velocity_X ||
              pType == GameObjectPropertyType.Velocity_Y ||
              pType == GameObjectPropertyType.Velocity_Z)
     {
         _UpdateVelocity(obj, pType, val);
     }
     else if (pType == GameObjectPropertyType.AngularVelocity_X_Euler ||
              pType == GameObjectPropertyType.AngularVelocity_Y_Euler ||
              pType == GameObjectPropertyType.AngularVelocity_Z_Euler)
     {
         _UpdateAngularVelocity(obj, pType, val);
     }
 }
    private static void _UpdateAngularVelocity(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 rot = obj.transform.localRotation.eulerAngles;

        switch (pType)
        {
        case GameObjectPropertyType.AngularVelocity_X_Euler:
            rot.x += val;
            break;

        case GameObjectPropertyType.AngularVelocity_Y_Euler:
            rot.y += val;
            break;

        case GameObjectPropertyType.AngularVelocity_Z_Euler:
            rot.z += val;
            break;
        }
        obj.transform.localRotation = Quaternion.Euler(rot);
    }
    private static void _UpdateVelocity(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 pos = obj.transform.localPosition;

        switch (pType)
        {
        case GameObjectPropertyType.Velocity_X:
            pos.x += val;
            break;

        case GameObjectPropertyType.Velocity_Y:
            pos.y += val;
            break;

        case GameObjectPropertyType.Velocity_Z:
            pos.z += val;
            break;
        }
        obj.transform.localPosition = pos;
    }
    private static void _UpdateLocalRotation(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 rot = obj.transform.localRotation.eulerAngles;

        switch (pType)
        {
        case GameObjectPropertyType.LocalRotation_X_Euler:
            rot.x = val;
            break;

        case GameObjectPropertyType.LocalRotation_Y_Euler:
            rot.y = val;
            break;

        case GameObjectPropertyType.LocalRotation_Z_Euler:
            rot.z = val;
            break;
        }
        obj.transform.localRotation = Quaternion.Euler(rot);
    }
    private static void _UpdateLocalPosition(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 pos = obj.transform.localPosition;

        switch (pType)
        {
        case GameObjectPropertyType.LocalPosition_X:
            pos.x = val;
            break;

        case GameObjectPropertyType.LocalPosition_Y:
            pos.y = val;
            break;

        case GameObjectPropertyType.LocalPosition_Z:
            pos.z = val;
            break;
        }
        obj.transform.localPosition = pos;
    }
    private static void _UpdateLocalPosition(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 pos = obj.transform.localPosition;

        switch(pType) {
        case GameObjectPropertyType.LocalPosition_X:
            pos.x = val;
        break;
        case GameObjectPropertyType.LocalPosition_Y:
            pos.y = val;
        break;
        case GameObjectPropertyType.LocalPosition_Z:
            pos.z = val;
        break;
        }
        obj.transform.localPosition = pos;
    }
    private static void _UpdateVelocity(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 pos = obj.transform.localPosition;

        switch(pType) {
        case GameObjectPropertyType.Velocity_X:
            pos.x += val;
        break;
        case GameObjectPropertyType.Velocity_Y:
            pos.y += val;
        break;
        case GameObjectPropertyType.Velocity_Z:
            pos.z += val;
        break;
        }
        obj.transform.localPosition = pos;
    }
    private static void _UpdateScale(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 scl = obj.transform.localScale;

        switch(pType) {
        case GameObjectPropertyType.Scale_X:
            scl.x = val;
        break;
        case GameObjectPropertyType.Scale_Y:
            scl.y = val;
        break;
        case GameObjectPropertyType.Scale_Z:
            scl.z = val;
        break;
        case GameObjectPropertyType.Uniform_Scale:
            scl.x = val;
            scl.y = val;
            scl.z = val;
        break;
        }
        obj.transform.localScale = scl;
    }
    private static void _UpdateRotation(GameObject obj, GameObjectPropertyType pType, float val)
    {
        Vector3 rot = obj.transform.rotation.eulerAngles;

        switch(pType) {
        case GameObjectPropertyType.Rotation_X_Euler:
            rot.x = val;
        break;
        case GameObjectPropertyType.Rotation_Y_Euler:
            rot.y = val;
        break;
        case GameObjectPropertyType.Rotation_Z_Euler:
            rot.z = val;
        break;
        }
        obj.transform.rotation = Quaternion.Euler(rot);
    }