Version 0.1.8

.github/workflows/cmake-multi-platform.yml

@@ -14,6 +14,12 @@ jobs:
           uses: actions/checkout@v4
           with:
             submodules: recursive
+        - name: Checkout deps/ldeps
+          uses: actions/checkout@v4
+          with:
+            repository: lnd3/ldeps
+            path: deps/ldeps
+            submodules: recursive
         - name: Create Build Environment
           run: cmake -E make_directory ${{github.workspace}}/build
         - name: Configure CMake
@@ -35,6 +41,12 @@ jobs:
         uses: actions/checkout@v4
         with:
           submodules: recursive
+      - name: Checkout deps/ldeps
+        uses: actions/checkout@v4
+        with:
+          repository: lnd3/ldeps
+          path: deps/ldeps
+          submodules: recursive
       - name: Install Dependencies
         run: |
           sudo apt-get update

CMakeLists.txt

@@ -24,13 +24,14 @@ else()
 		filesystem
 		meta
 		memory
+		math
 		concurrency
 		serialization
 		crypto
-		math
 		audio
 		hid
 		nodegraph
+		nn
 
 		network
 		storage
@@ -43,4 +44,52 @@ else()
 
 
 	bs_configure_packages("packages" "${PACKAGE_NAMES}")
+
+	option(LTOOLS_ENABLE_UNITY_BUILD "Enable unity builds for faster compilation" OFF)
+	if(LTOOLS_ENABLE_UNITY_BUILD)
+	  set_target_properties(logging PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(testing PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(filesystem PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(meta PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(memory PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(concurrency PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(serialization PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(crypto PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(math PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(audio PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(hid PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(nodegraph PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(nn PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(network PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(storage PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(tools PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(physics PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(ecs PROPERTIES UNITY_BUILD ON)
+	  #set_target_properties(rendering PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(testing_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(filesystem_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(meta_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(memory_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(concurrency_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(serialization_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(crypto_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(math_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(audio_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(hid_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(nodegraph_test PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(network_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(storage_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(tools_test PROPERTIES UNITY_BUILD ON)
+
+	  set_target_properties(physics_test PROPERTIES UNITY_BUILD ON)
+	  #set_target_properties(ecs_test PROPERTIES UNITY_BUILD ON)
+	  set_target_properties(rendering_test PROPERTIES UNITY_BUILD ON)
+
+	endif()
+
 endif()

packages/audio/source/common/PortAudio.cpp

@@ -73,13 +73,13 @@ namespace l::audio {
         auto maxDevices = Pa_GetDeviceCount();
         for (int32_t index = 0; index < maxDevices; index++) {
             auto deviceInfo = Pa_GetDeviceInfo(index);
-            LOG(LogInfo) << "Audio device " << index << ": " << deviceInfo->name;
+            LLOG(LogInfo) << "Audio device " << index << ": " << deviceInfo->name;
         }
 
         mInputParameters.device = Pa_GetDefaultInputDevice(); /* default input device */
         mOutputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */
         if (mOutputParameters.device == paNoDevice) {
-            LOG(LogError) << "Error: No default output device.";
+            LLOG(LogError) << "Error: No default output device.";
             return false;
         }
 
@@ -104,10 +104,10 @@ namespace l::audio {
 
             //auto inputInfo = Pa_GetDeviceInfo(mInputParameters.device);
             mInputParameters.suggestedLatency = latencyMs / 1000.0f; // inputInfo->defaultHighInputLatency;
-            LOG(LogInfo) << "Port Audio set latency ms: " << static_cast<int32_t>(latencyMs);
+            LLOG(LogInfo) << "Port Audio set latency ms: " << static_cast<int32_t>(latencyMs);
         }
         else {
-            LOG(LogInfo) << "Port Audio recommended latency ms: " << static_cast<int32_t>(defaultLatency * 1000.0f);
+            LLOG(LogInfo) << "Port Audio recommended latency ms: " << static_cast<int32_t>(defaultLatency * 1000.0f);
             mOutputParameters.suggestedLatency = defaultLatency;
         }
         mOutputParameters.hostApiSpecificStreamInfo = NULL;
@@ -149,7 +149,7 @@ namespace l::audio {
             &mAudioStreamData);
 
         if (err != paNoError) {
-            LOG(LogError) << "Failed to open stream: " << err;
+            LLOG(LogError) << "Failed to open stream: " << err;
             return false;
         }
         return true;
@@ -159,7 +159,7 @@ namespace l::audio {
     bool AudioStream::StartStream() {
         auto err = Pa_StartStream(mPaStream);
         if (err != paNoError) {
-            LOG(LogError) << "Failed to start stream: " << err;
+            LLOG(LogError) << "Failed to start stream: " << err;
             return false;
         }
 
@@ -212,7 +212,7 @@ namespace l::audio {
         }
         auto err = Pa_CloseStream(mPaStream);
         if (err != paNoError) {
-            LOG(LogError) << "Failed to close stream: " << err;
+            LLOG(LogError) << "Failed to close stream: " << err;
             return false;
         }
         return true;
@@ -237,7 +237,7 @@ namespace l::audio {
     bool AudioManager::Init() {
         auto err = Pa_Initialize();
         if (err != paNoError) {
-            LOG(LogError) << "Failed to initialize port audio.";
+            LLOG(LogError) << "Failed to initialize port audio.";
             return false;
         }
         return true;

packages/audio/tests/common/PortAudioTest.cpp

@@ -58,7 +58,7 @@ TEST(PortAudio, Setup) {
 
 
     if (!stream->StopStream()) {
-        LOG(LogError) << "Failed to stop stream";
+        LLOG(LogError) << "Failed to stop stream";
     }
 
     manager.CloseOutStream("speaker");

packages/concurrency/include/concurrency/ExecutorService.h

@@ -95,7 +95,7 @@ namespace l::concurrency {
 		Worker(Worker&&) = default;
 		Worker(const Worker&) = default;
 		virtual ~Worker() override {
-			//LOG(LogDebug) << "Destroying " << mName;
+			//LLOG(LogDebug) << "Destroying " << mName;
 		}
 
 		RunnableResult run(const RunState& state) override;

packages/concurrency/source/common/ExecutorService.cpp

@@ -56,7 +56,7 @@ namespace l::concurrency {
 	}
 
 	RunnableResult Runnable::run(const RunState&) {
-		LOG(LogInfo) << "Default run implementation";
+		LLOG(LogInfo) << "Default run implementation";
 		return RunnableResult::SUCCESS;
 	}
 
@@ -85,7 +85,7 @@ namespace l::concurrency {
 		if (mRunState.mDestructing) {
 			return;
 		}
-		if (gDebugLogging) LOG(LogDebug) << "Executor service shutdown is imminent";
+		if (gDebugLogging) LLOG(LogDebug) << "Executor service shutdown is imminent";
 		{
 			std::lock_guard<std::mutex> lock(mRunnablesMutex);
 			mRunState.mDestructing = true;
@@ -96,12 +96,12 @@ namespace l::concurrency {
 		}
 
 		do {
-			if (gDebugLogging) LOG(LogDebug) << "Executor service notifying threads of imminent shutdown";
+			if (gDebugLogging) LLOG(LogDebug) << "Executor service notifying threads of imminent shutdown";
 			std::this_thread::sleep_for(std::chrono::milliseconds(50));
 			mCondition.notify_all();
 		} while (!mRunState.IsShutdown());
 
-		if (gDebugLogging) LOG(LogDebug) << "Executor service notified all waiting schedulers to exit immediately";
+		if (gDebugLogging) LLOG(LogDebug) << "Executor service notified all waiting schedulers to exit immediately";
 
 		for (auto& t : mPoolThreads) {
 			if (t.joinable()) {
@@ -117,18 +117,18 @@ namespace l::concurrency {
 	}
 
 	void ExecutorService::startJobs() {
-		LOG(LogDebug) << "Start jobs " << mName;
+		LLOG(LogDebug) << "Start jobs " << mName;
 		mRunState.mRunning = true;
 		mCondition.notify_all();
 	}
 
 	void ExecutorService::pauseJobs() {
-		LOG(LogDebug) << "Pause jobs " << mName;
+		LLOG(LogDebug) << "Pause jobs " << mName;
 		mRunState.mRunning = false;
 	}
 
 	void ExecutorService::clearJobs() {
-		LOG(LogDebug) << "Clear jobs " << mName;
+		LLOG(LogDebug) << "Clear jobs " << mName;
 
 		std::lock_guard<std::mutex> lock(mRunnablesMutex);
 		mRunState.mRunning = false;
@@ -138,13 +138,13 @@ namespace l::concurrency {
 	bool ExecutorService::queueJob(std::unique_ptr<Runnable> runnable) {
 		{
 			if (mRunState.mDestructing) {
-				LOG(LogWarning) << "Service is shutdown and waiting for destruction";
+				LLOG(LogWarning) << "Service is shutdown and waiting for destruction";
 				return false;
 			}
 
 			std::lock_guard<std::mutex> lock(mRunnablesMutex);
 			if (mMaxQueuedJobs > 0 && mRunnables.size() > mMaxQueuedJobs) {
-				LOG(LogWarning) << "Too many jobs!";
+				LLOG(LogWarning) << "Too many jobs!";
 				return false;
 			}
 			mRunnables.push_back(std::move(runnable));
@@ -173,16 +173,16 @@ namespace l::concurrency {
 			}
 
 			std::unique_ptr<Runnable> runnable = nullptr;
-			if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " started";
+			if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " started";
 			if (!mRunState.mRunning) {
 				std::unique_lock<std::mutex> lock(mRunnablesMutex);
-				if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " is paused";
+				if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " is paused";
 				mCondition.wait(lock);
 			}
 			else {
 				std::unique_lock<std::mutex> lock(mRunnablesMutex);
 				if (mRunnables.empty()) {
-					if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " is waiting for work";
+					if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " is waiting for work";
 					mCondition.wait(lock);
 				}
 				else {
@@ -194,10 +194,10 @@ namespace l::concurrency {
 
 							if (gDebugLogging) {
 								if (runnable->NumTries() > 0) {
-									LOG(LogDebug) << "Scheduler " << id << " picked up requeued(" << runnable->NumTries() << ") job";
+									LLOG(LogDebug) << "Scheduler " << id << " picked up requeued(" << runnable->NumTries() << ") job";
 								}
 								else {
-									LOG(LogDebug) << "Scheduler " << id << " picked up new job";
+									LLOG(LogDebug) << "Scheduler " << id << " picked up new job";
 								}
 							}
 							break;
@@ -206,58 +206,58 @@ namespace l::concurrency {
 					lock.unlock();
 
 					if (!runnable) {
-						if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " sleeping";
+						if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " sleeping";
 						std::this_thread::sleep_for(std::chrono::milliseconds(50));
 					}
 				}
 			}
 
 			if (runnable) {
-				if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " executes task";
+				if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " executes task";
 				mRunState.mNumRunningJobs++;
 				RunnableResult result = runnable->run(mRunState);
 				mRunState.mNumRunningJobs--;
 				switch (result) {
 				case l::concurrency::RunnableResult::FAILURE:
-					if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " task failed";
+					if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " task failed";
 					runnable.reset();
 					break;
 				case l::concurrency::RunnableResult::CANCELLED:
-					if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " task was cancelled";
+					if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " task was cancelled";
 					runnable.reset();
 					break;
 				case l::concurrency::RunnableResult::SUCCESS:
-					if (gDebugLogging) LOG(LogDebug) << "Scheduler " << id << " task succeeded";
+					if (gDebugLogging) LLOG(LogDebug) << "Scheduler " << id << " task succeeded";
 					mNumCompletedJobs++;
 					runnable.reset();
 					break;
 				case l::concurrency::RunnableResult::REQUEUE_DELAYED:
 					runnable->Reschedule();
-					if (gDebugLogging) LOG(LogDebug) << "Job '" + runnable->Name() + "' could not run yet and was requeued ";
+					if (gDebugLogging) LLOG(LogDebug) << "Job '" + runnable->Name() + "' could not run yet and was requeued ";
 					queueJob(std::move(runnable));
 					break;
 				case l::concurrency::RunnableResult::REQUEUE_BACKOFF:
 					runnable->Backoff();
 					if (!runnable->Failed()) {
 
-						if (gDebugLogging) LOG(LogDebug) << "Job '" + runnable->Name() + "' was delayed and then requeued with backoff";
+						if (gDebugLogging) LLOG(LogDebug) << "Job '" + runnable->Name() + "' was delayed and then requeued with backoff";
 						queueJob(std::move(runnable));
 					}
 					else {
-						if (gDebugLogging) LOG(LogDebug) << "Job '" + runnable->Name() + "' failed and was cancelled";
+						if (gDebugLogging) LLOG(LogDebug) << "Job '" + runnable->Name() + "' failed and was cancelled";
 						runnable.reset();
 					}
 					break;
 				case l::concurrency::RunnableResult::REQUEUE_IMMEDIATE:
-					if (gDebugLogging) LOG(LogInfo) << "Scheduler " << mName << " task was requeued";
+					if (gDebugLogging) LLOG(LogInfo) << "Scheduler " << mName << " task was requeued";
 					queueJob(std::move(runnable));
 					break;
 				}
 			}
 		}
 		mRunState.mNumRunningJobThreads--;
 
-		if (gDebugLogging) LOG(LogInfo) << "Scheduler " << mName << " exited";
+		if (gDebugLogging) LLOG(LogInfo) << "Scheduler " << mName << " exited";
 	}
 
 }

packages/concurrency/tests/common/ContainersTest.cpp

@@ -100,9 +100,9 @@ TEST(Containers, Polymorphic) {
 		TEST_TRUE(meta::Type<Base>::hash_code() != meta::Type<DoubleDerived>::hash_code(), "");
 		TEST_TRUE(meta::Type<Derived>::hash_code() != meta::Type<DoubleDerived>::hash_code(), "");
 
-		LOG(LogInfo) << meta::Type<Base>::hash_code();
-		LOG(LogInfo) << meta::Type<Derived>::hash_code();
-		LOG(LogInfo) << meta::Type<DoubleDerived>::hash_code();
+		LLOG(LogInfo) << meta::Type<Base>::hash_code();
+		LLOG(LogInfo) << meta::Type<Derived>::hash_code();
+		LLOG(LogInfo) << meta::Type<DoubleDerived>::hash_code();
 	}
 
 	{