Start the process of standardizing the formatting of documentation inside our header files.

Source/Integration/LockedWrapper.h

@@ -1,77 +1,99 @@
+////////////////////////////////////////////////////////////
+//
+// LockedWrapper.h
+//
+// Mutex-guarded access to the EngineWrapper.
+//
+////////////////////////////////////////////////////////////
+
 #pragma once
 
 #include "CoreMinimal.h"
 #include "lpx-enginewrapper.hpp"
 #include "Common.h"
 
-
-// Class FlxLockableWrapper
-// 
-// Contains the EngineWrapper and a Mutex to lock it.
-// This class has no methods.  To access the EngineWrapper,
-// construct a FlxLockedWrapper, and then dereference it
-// using operator right arrow.
+////////////////////////////////////////////////////////////
 //
+// FlxLockableWrapper
+//
+// Contains the EngineWrapper and a Mutex to lock it.
+// This class has no methods. To access the
+// EngineWrapper, construct a FlxLockedWrapper.
+//
+////////////////////////////////////////////////////////////
+
 class FlxLockableWrapper {
 private:
 	FCriticalSection Mutex;
 	EngineWrapper Wrapper;
 
-	// Temporary buffers. These are only used
-	// inside wrapper methods.  There's nothing
-	// persistent in these.
+	// Temporary buffers used only inside wrapper
+	// methods. Nothing persistent in these.
 	//
 	TArray<uint32> AQLenBuffer;
 	TArray<const char*> AQStrBuffer;
-	
+
 public:
 	friend class FlxLockedWrapper;
 };
 
+////////////////////////////////////////////////////////////
+//
+// FlxLockedWrapper
+//
+// RAII lock guard. The constructor claims the mutex,
+// the destructor releases it. Use operator-> to
+// access the EngineWrapper.
+//
+////////////////////////////////////////////////////////////
+
 class FlxLockedWrapper {
 private:
 	FlxLockableWrapper& Lockable;
 
-	// This function is called by luprex to output debugging
-	// messages.  It is a thin wrapper around UE_LOG.
+	// Called by luprex to output debugging messages.
+	// A thin wrapper around UE_LOG.
 	//
 	static void DPrintHook(const char *Msg, size_t Size);
 
 public:
-	// Import these types into our Namespace.
+	// Import these types into our namespace.
+	//
 	using IdArray       = LpxCommonTypes::IdArray;
 	using IdView        = LpxCommonTypes::IdView;
 	using StringViewVec = LpxCommonTypes::StringViewVec;
 
-
 public:
-	// The constructor of the FlxLockedWrapper claims the mutex.
+	// The constructor claims the mutex.
+	//
 	FlxLockedWrapper(FlxLockableWrapper& w) : Lockable(w) {
 		Lockable.Mutex.Lock();
 	}
 
-	// The destructor of the FlxLockedWrapper releases the mutex.
+	// The destructor releases the mutex.
+	//
 	~FlxLockedWrapper() {
 		Lockable.Mutex.Unlock();
 	}
 
-	// Operator right arrow accesses the EngineWrapper.
+	// Operator-> accesses the EngineWrapper.
+	//
 	EngineWrapper* operator ->() {
 		return &Lockable.Wrapper;
 	}
 
-	// Get a pointer to the enginewrapper.  This is not
-	// very safe because you could keep the pointer after
-	// the LockedWrapper is destroyed.  Don't do that.
+	// Get a pointer to the EngineWrapper. Not very
+	// safe because you could keep the pointer after
+	// the LockedWrapper is destroyed. Don't do that.
+	//
 	EngineWrapper* Get() {
 		return &Lockable.Wrapper;
 	}
 
-	// Initialize the engine wrapper if it's not already.
-	//
-	// All this does is open the DLL and hook up all
-	// the function pointers in the wrapper to point into
-	// the DLL.
+	// Initialize the engine wrapper if it's not
+	// already. All this does is open the DLL and
+	// hook up all the function pointers in the
+	// wrapper to point into the DLL.
 	//
 	void InitWrapper();
 
@@ -85,9 +107,9 @@ public:
 
 	// Get the list of tangibles near the actor.
 	//
-	// This function is fast but not free.  You should fetch this
-	// once per frame and then store the IdView somewhere (like
-	// in the TangibleManager, for example).
+	// This function is fast but not free. You should
+	// fetch this once per frame and then store the
+	// IdView somewhere (like in the TangibleManager).
 	//
 	IdView GetNear(int64 id, double rx, double ry, double rz);