[Mono] Tabs -> Spaces

3 files changed, 135 insertions, 135 deletions

diff --git a/modules/mono/glue/cs_files/Basis.cs b/modules/mono/glue/cs_files/Basis.cs
index 10286f3832..ec96a9e2fa 100644
--- a/modules/mono/glue/cs_files/Basis.cs
+++ b/modules/mono/glue/cs_files/Basis.cs
@@ -378,51 +378,51 @@ namespace Godot
             );
         }
 
-		public Quat Quat() {
-			real_t trace = _x[0] + _y[1] + _z[2];
-
-			if (trace > 0.0f) {
-				real_t s = Mathf.Sqrt(trace + 1.0f) * 2f;
-				real_t inv_s = 1f / s;
-				return new Quat(
-					(_z[1] - _y[2]) * inv_s,
-					(_x[2] - _z[0]) * inv_s,
-					(_y[0] - _x[1]) * inv_s,
-					s * 0.25f
-				);
-			}
-
-		    if (_x[0] > _y[1] && _x[0] > _z[2]) {
-		        real_t s = Mathf.Sqrt(_x[0] - _y[1] - _z[2] + 1.0f) * 2f;
-		        real_t inv_s = 1f / s;
-		        return new Quat(
-		            s * 0.25f,
-		            (_x[1] + _y[0]) * inv_s,
-		            (_x[2] + _z[0]) * inv_s,
-		            (_z[1] - _y[2]) * inv_s
-		        );
-		    }
-
-		    if (_y[1] > _z[2]) {
-		        real_t s = Mathf.Sqrt(-_x[0] + _y[1] - _z[2] + 1.0f) * 2f;
-		        real_t inv_s = 1f / s;
-		        return new Quat(
-		            (_x[1] + _y[0]) * inv_s,
-		            s * 0.25f,
-		            (_y[2] + _z[1]) * inv_s,
-		            (_x[2] - _z[0]) * inv_s
-		        );
-		    } else {
-		        real_t s = Mathf.Sqrt(-_x[0] - _y[1] + _z[2] + 1.0f) * 2f;
-		        real_t inv_s = 1f / s;
-		        return new Quat(
-		            (_x[2] + _z[0]) * inv_s,
-		            (_y[2] + _z[1]) * inv_s,
-		            s * 0.25f,
-		            (_y[0] - _x[1]) * inv_s
-		        );
-		    }
-		}
+        public Quat Quat() {
+            real_t trace = _x[0] + _y[1] + _z[2];
+
+            if (trace > 0.0f) {
+                real_t s = Mathf.Sqrt(trace + 1.0f) * 2f;
+                real_t inv_s = 1f / s;
+                return new Quat(
+                    (_z[1] - _y[2]) * inv_s,
+                    (_x[2] - _z[0]) * inv_s,
+                    (_y[0] - _x[1]) * inv_s,
+                    s * 0.25f
+                );
+            }
+
+            if (_x[0] > _y[1] && _x[0] > _z[2]) {
+                real_t s = Mathf.Sqrt(_x[0] - _y[1] - _z[2] + 1.0f) * 2f;
+                real_t inv_s = 1f / s;
+                return new Quat(
+                    s * 0.25f,
+                    (_x[1] + _y[0]) * inv_s,
+                    (_x[2] + _z[0]) * inv_s,
+                    (_z[1] - _y[2]) * inv_s
+                );
+            }
+
+            if (_y[1] > _z[2]) {
+                real_t s = Mathf.Sqrt(-_x[0] + _y[1] - _z[2] + 1.0f) * 2f;
+                real_t inv_s = 1f / s;
+                return new Quat(
+                    (_x[1] + _y[0]) * inv_s,
+                    s * 0.25f,
+                    (_y[2] + _z[1]) * inv_s,
+                    (_x[2] - _z[0]) * inv_s
+                );
+            } else {
+                real_t s = Mathf.Sqrt(-_x[0] - _y[1] + _z[2] + 1.0f) * 2f;
+                real_t inv_s = 1f / s;
+                return new Quat(
+                    (_x[2] + _z[0]) * inv_s,
+                    (_y[2] + _z[1]) * inv_s,
+                    s * 0.25f,
+                    (_y[0] - _x[1]) * inv_s
+                );
+            }
+        }
 
         public Basis(Quat quat)
         {
diff --git a/modules/mono/glue/cs_files/GodotSynchronizationContext.cs b/modules/mono/glue/cs_files/GodotSynchronizationContext.cs
index da3c7bac83..e727781d63 100644
--- a/modules/mono/glue/cs_files/GodotSynchronizationContext.cs
+++ b/modules/mono/glue/cs_files/GodotSynchronizationContext.cs
@@ -4,22 +4,22 @@ using System.Threading;
 
 namespace Godot
 {
-	public class GodotSynchronizationContext : SynchronizationContext
-	{
-		private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> queue = new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
+    public class GodotSynchronizationContext : SynchronizationContext
+    {
+        private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> queue = new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
 
-		public override void Post(SendOrPostCallback d, object state)
-		{
-			queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
-		}
+        public override void Post(SendOrPostCallback d, object state)
+        {
+            queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
+        }
 
-		public void ExecutePendingContinuations()
-		{
-			KeyValuePair<SendOrPostCallback, object> workItem;
-			while (queue.TryTake(out workItem))
-			{
-				workItem.Key(workItem.Value);
-			}
-		}
-	}
+        public void ExecutePendingContinuations()
+        {
+            KeyValuePair<SendOrPostCallback, object> workItem;
+            while (queue.TryTake(out workItem))
+            {
+                workItem.Key(workItem.Value);
+            }
+        }
+    }
 }
diff --git a/modules/mono/glue/cs_files/GodotTaskScheduler.cs b/modules/mono/glue/cs_files/GodotTaskScheduler.cs
index 3d23ec10f1..9a40fef5a9 100644
--- a/modules/mono/glue/cs_files/GodotTaskScheduler.cs
+++ b/modules/mono/glue/cs_files/GodotTaskScheduler.cs
@@ -6,89 +6,89 @@ using System.Threading.Tasks;
 
 namespace Godot
 {
-	public class GodotTaskScheduler : TaskScheduler
-	{
-		private GodotSynchronizationContext Context { get; set; }
-		private readonly LinkedList<Task> _tasks = new LinkedList<Task>();
+    public class GodotTaskScheduler : TaskScheduler
+    {
+        private GodotSynchronizationContext Context { get; set; }
+        private readonly LinkedList<Task> _tasks = new LinkedList<Task>();
 
-		public GodotTaskScheduler()
-		{
-			Context = new GodotSynchronizationContext();
-			SynchronizationContext.SetSynchronizationContext(Context);
-		}
+        public GodotTaskScheduler()
+        {
+            Context = new GodotSynchronizationContext();
+            SynchronizationContext.SetSynchronizationContext(Context);
+        }
 
-		protected sealed override void QueueTask(Task task)
-		{
-			lock (_tasks)
-			{
-				_tasks.AddLast(task);
-			}
-		}
+        protected sealed override void QueueTask(Task task)
+        {
+            lock (_tasks)
+            {
+                _tasks.AddLast(task);
+            }
+        }
 
-		protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
-		{
-			if (SynchronizationContext.Current != Context)
-			{
-				return false;
-			}
+        protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
+        {
+            if (SynchronizationContext.Current != Context)
+            {
+                return false;
+            }
 
-			if (taskWasPreviouslyQueued)
-			{
-				TryDequeue(task);
-			}
+            if (taskWasPreviouslyQueued)
+            {
+                TryDequeue(task);
+            }
 
-			return TryExecuteTask(task);
-		}
+            return TryExecuteTask(task);
+        }
 
-		protected sealed override bool TryDequeue(Task task)
-		{
-			lock (_tasks)
-			{
-				return _tasks.Remove(task);
-			}
-		}
+        protected sealed override bool TryDequeue(Task task)
+        {
+            lock (_tasks)
+            {
+                return _tasks.Remove(task);
+            }
+        }
 
-		protected sealed override IEnumerable<Task> GetScheduledTasks()
-		{
-			lock (_tasks)
-			{
-				return _tasks.ToArray();
-			}
-		}
+        protected sealed override IEnumerable<Task> GetScheduledTasks()
+        {
+            lock (_tasks)
+            {
+                return _tasks.ToArray();
+            }
+        }
 
-		public void Activate()
-		{
-			ExecuteQueuedTasks();
-			Context.ExecutePendingContinuations();
-		}
+        public void Activate()
+        {
+            ExecuteQueuedTasks();
+            Context.ExecutePendingContinuations();
+        }
 
-		private void ExecuteQueuedTasks()
-		{
-			while (true)
-			{
-				Task task;
+        private void ExecuteQueuedTasks()
+        {
+            while (true)
+            {
+                Task task;
 
-				lock (_tasks)
-				{
-					if (_tasks.Any())
-					{
-						task = _tasks.First.Value;
-						_tasks.RemoveFirst();
-					}
-					else
-					{
-						break;
-					}
-				}
+                lock (_tasks)
+                {
+                    if (_tasks.Any())
+                    {
+                        task = _tasks.First.Value;
+                        _tasks.RemoveFirst();
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
 
-				if (task != null)
-				{
-					if (!TryExecuteTask(task))
-					{
-						throw new InvalidOperationException();
-					}
-				}
-			}
-		}
-	}
+                if (task != null)
+                {
+                    if (!TryExecuteTask(task))
+                    {
+                        throw new InvalidOperationException();
+                    }
+                }
+            }
+        }
+    }
 }