Merge branch 'develop' of github.com:3dJan/gladius_playground into develop

Author: 3dJan

.github/chatmodes/planning.chatmode.md

@@ -1,7 +1,7 @@
 ---
 description: 'Planning chat mode.'
-tools: ['changes', 'codebase', 'editFiles', 'findTestFiles', 'githubRepo', 'openSimpleBrowser', 'search', 'searchResults', 'usages']
+tools: ['edit', 'search', 'usages', 'changes', 'openSimpleBrowser', 'githubRepo']
 ---
 You are a planning assistant. Your task is to help users outline and organize their ideas, projects, or tasks. You should focus on providing structured guidance, suggesting relevant tools or frameworks, and helping users break down their goals into actionable steps.
 
-You store your plans in a structured format in gladius/thegreatplan/. You outline the plan step by step and explain the reasoning behind each step. You can also suggest relevant libraries, frameworks, or tools that can assist in the planning process. When suggesting libs, frameworks, or tools, ensure they are well-documented and widely used in the community. Provide links to their official documentation or repositories when possible. Availability through VCPKG is preferable, but not mandatory.
+You store your plans in a structured format in gladius/thegreatplan/. You outline the plan step by step and explain the reasoning behind each step. You can also suggest relevant libraries, frameworks, or tools that can assist in the planning process. When suggesting libs, frameworks, or tools, ensure they are well-documented and widely used in the community. Provide links to their official documentation or repositories when possible. Availability through VCPKG is preferable, but not mandatory. Please do not make any code changes.

.github/copilot-instructions.md

@@ -16,6 +16,7 @@
 - **DRY Principle**: Don't repeat yourself. Avoid code duplication.
 - **YAGNI Principle**: You aren't gonna need it. Avoid adding features until they are necessary.
 - **Tool usage**: Prefer using tools rather than doing things manually in the terminal.
+- **Keep files small**: Prefer smaller files (e.g., <400 lines) for better readability and maintainability.
 
 ## Code Structure
 - **Headers**: Use `.h` for declarations, `.cpp` for definitions.

.github/workflows/build.yml

@@ -12,9 +12,15 @@ on:
   workflow_dispatch:
   workflow_call:  # Allow this workflow to be called by other workflows
 
+permissions:
+  packages: write  # Required for vcpkg binary caching with GitHub Packages
+
 jobs:
   build:
     runs-on: ${{ matrix.os }}
+    
+    env:
+      VCPKG_BINARY_SOURCES: "clear;nuget,https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json,readwrite"
 
     strategy:
       # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
@@ -89,6 +95,75 @@ jobs:
       run: ./bootstrap-vcpkg.bat
       working-directory: ${{ github.workspace }}/vcpkg
 
+    - name: Install mono for NuGet (Linux)
+      if: runner.os != 'Windows'
+      run: sudo apt-get install -y mono-complete
+
+    - name: Install buildcache (Linux)
+      if: runner.os != 'Windows'
+      run: |
+        wget https://github.com/mbitsnbites/buildcache/releases/download/v0.28.1/buildcache-linux.tar.gz
+        tar -xzf buildcache-linux.tar.gz
+        sudo cp buildcache/bin/buildcache /usr/local/bin/
+        buildcache --version
+
+    - name: Install buildcache (Windows)
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        Invoke-WebRequest -Uri "https://github.com/mbitsnbites/buildcache/releases/download/v0.28.1/buildcache-windows.zip" -OutFile "buildcache.zip"
+        Expand-Archive -Path "buildcache.zip" -DestinationPath "buildcache" -Force
+        Copy-Item -Path "buildcache\buildcache\bin\buildcache.exe" -Destination "C:\Windows\System32\buildcache.exe" -Force
+        buildcache --version
+
+    - name: Cache buildcache (Linux)
+      if: runner.os != 'Windows'
+      uses: actions/cache@v4
+      with:
+        path: ~/.buildcache
+        key: buildcache-${{ matrix.os }}-${{ matrix.c_compiler }}-${{ github.sha }}
+        restore-keys: |
+          buildcache-${{ matrix.os }}-${{ matrix.c_compiler }}-
+
+    - name: Cache buildcache (Windows)
+      if: runner.os == 'Windows'
+      uses: actions/cache@v4
+      with:
+        path: ~\AppData\Local\buildcache
+        key: buildcache-${{ matrix.os }}-${{ matrix.c_compiler }}-${{ github.sha }}
+        restore-keys: |
+          buildcache-${{ matrix.os }}-${{ matrix.c_compiler }}-
+
+    - name: Setup NuGet authentication for vcpkg binary caching (Linux)
+      if: runner.os != 'Windows'
+      shell: bash
+      run: |
+        mono `${{ github.workspace }}/vcpkg/vcpkg fetch nuget | tail -n 1` \
+          sources add \
+          -Source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" \
+          -StorePasswordInClearText \
+          -Name GitHubPackages \
+          -UserName "${{ github.repository_owner }}" \
+          -Password "${{ secrets.GITHUB_TOKEN }}"
+        mono `${{ github.workspace }}/vcpkg/vcpkg fetch nuget | tail -n 1` \
+          setapikey "${{ secrets.GITHUB_TOKEN }}" \
+          -Source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json"
+
+    - name: Setup NuGet authentication for vcpkg binary caching (Windows)
+      if: runner.os == 'Windows'
+      shell: pwsh
+      run: |
+        & "$(${{ github.workspace }}/vcpkg/vcpkg fetch nuget)" `
+          sources add `
+          -Source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" `
+          -StorePasswordInClearText `
+          -Name GitHubPackages `
+          -UserName "${{ github.repository_owner }}" `
+          -Password "${{ secrets.GITHUB_TOKEN }}"
+        & "$(${{ github.workspace }}/vcpkg/vcpkg fetch nuget)" `
+          setapikey "${{ secrets.GITHUB_TOKEN }}" `
+          -Source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json"
+
     - name: Set reusable strings
       # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
       id: strings
@@ -104,6 +179,7 @@ jobs:
         -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
         -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
         -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+        -DUSE_CACHE=ON
         -G Ninja
         -S ${{ github.workspace }}/gladius
       env:

gladius/CMakePresets.json

@@ -108,7 +108,8 @@
                 "USE_CACHE": "true",
                 "VCPKG_OVERLAY_PORTS": "${sourceDir}/vcpkg-overlay-ports",
                 "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
-                "ENABLE_COVERAGE": "OFF"
+                "ENABLE_COVERAGE": "OFF",
+                "ENABLE_TRACY": "TRUE"
             }
         },
         {

gladius/src/CLProgram.h

@@ -94,11 +94,11 @@ namespace gladius
         void finishCompilation();
 
         template <typename... ArgumentTypes>
-        void runNonBlocking(cl::CommandQueue const & queue,
-                            const std::string & methodName,
-                            cl::NDRange origin,
-                            cl::NDRange range,
-                            const ArgumentTypes &... args)
+        [[nodiscard]] cl::Event runNonBlocking(cl::CommandQueue const & queue,
+                                               const std::string & methodName,
+                                               cl::NDRange origin,
+                                               cl::NDRange range,
+                                               const ArgumentTypes &... args)
         {
             ProfileFunction;
 
@@ -139,7 +139,7 @@ namespace gladius
             if (!isValid())
             {
                 logError("Program not valid - returning");
-                return;
+                return cl::Event{};
             }
             std::scoped_lock lock(m_compilationMutex);
 
@@ -263,16 +263,19 @@ namespace gladius
                 throw;
             }
 
+            cl::Event kernelEvent;
             try
             {
                 CL_ERROR(
-                  queue.enqueueNDRangeKernel(m_kernels[methodName], origin, range, cl::NullRange));
+                  queue.enqueueNDRangeKernel(m_kernels[methodName], origin, range, cl::NullRange, nullptr, &kernelEvent));
             }
             catch (const OpenCLError & e)
             {
                 logError("Kernel enqueue failed", e.what());
                 throw;
             }
+
+            return kernelEvent;
         }
 
         template <typename... ArgumentTypes>
@@ -329,16 +332,11 @@ namespace gladius
 
             try
             {
-                runNonBlocking(queue, methodName, origin, range, args...);
-            }
-            catch (const std::exception & e)
-            {
-                logError("RunNonBlocking failed", e.what());
-                throw;
-            }
-
-            try
-            {
+                cl::Event const event = runNonBlocking(queue, methodName, origin, range, args...);
+                if (event())
+                {
+                    event.wait();
+                }
                 CL_ERROR(queue.finish());
             }
             catch (const OpenCLError & e)
@@ -347,6 +345,11 @@ namespace gladius
 
                 throw;
             }
+            catch (const std::exception & e)
+            {
+                logError("RunNonBlocking failed", e.what());
+                throw;
+            }
         }
 
         template <typename... ArgumentTypes>

gladius/src/ComputeContext.h

@@ -80,6 +80,10 @@ namespace gladius
 
         [[nodiscard]] const cl::CommandQueue & GetQueue();
 
+        /// @brief Create a new OpenCL command queue for the current context
+        /// @return A new command queue
+        cl::CommandQueue createQueue() const;
+
         [[nodiscard]] bool isValid() const;
 
         [[nodiscard]] const cl::Device & GetDevice() const;
@@ -196,7 +200,6 @@ namespace gladius
         void checkMemoryLayoutConflicts(const std::string & operationName) const;
 
       private:
-        cl::CommandQueue createQueue() const;
         void initContext();
         void queryDeviceMemoryCaps();
         bool tryQueryVendorFreeMem(size_t & freeBytesOut) const; // best-effort

gladius/src/Document.cpp

@@ -139,13 +139,66 @@ namespace gladius
         updateFlatAssembly();
 
         m_core->refreshProgram(m_flatAssembly);
-        m_core->recompileBlockingNoLock();
-        m_core->invalidatePreCompSdf();
+        
+        // Use non-blocking compilation with polling
+        m_core->recompileIfRequired();
+        
+        // Wait for compilation to complete with periodic checks
+        while (m_core->isCompilationInProgress())
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+
+        // One more pass ensures ProgramManager updates its internal ModelState flags
+        // (signalCompilationFinished) so subsequent steps observe up-to-date slicer state.
+        m_core->recompileIfRequired();
+        
+        // Don't invalidate SDF - let it stay valid during recomputation to avoid flicker
+        // The async computation will atomically replace it
         m_core->resetBoundingBox();
-        if (m_core->precomputeSdfForWholeBuildPlatform())
+        
+        // Launch async SDF precomputation with OpenCL events
+        auto const & queue = m_core->getComputeContext()->GetQueue();
+        cl::Event sdfEvent = m_core->precomputeSdfAsync(queue);
+        bool const sdfEventValid = sdfEvent() != nullptr;
+
+        bool sdfUpdated = false;
+        bool sdfUpdatedViaAsync = false;
+
+        // Wait for SDF computation to complete (non-blocking on CPU, async on GPU)
+        if (sdfEventValid)
+        {
+            sdfEvent.wait();
+            sdfUpdated = true;
+            sdfUpdatedViaAsync = true;
+        }
+        else
+        {
+            // Fallback to synchronous computation if async launch failed
+            if (m_core->precomputeSdfForWholeBuildPlatform())
+            {
+                sdfUpdated = true;
+            }
+            else
+            {
+            }
+        }
+
+        if (sdfUpdated)
         {
-            meshResourceState->signalCompilationFinished();
+            m_core->setSdfValid(true);
+            if (sdfUpdatedViaAsync)
+            {
+                // Now that the SDF exists, update the bounding box serially (still off the UI thread)
+                m_core->updateBBox();
+            }
         }
+        else
+        {
+            m_core->invalidatePreCompSdf("refreshWorkerFailure");
+        }
+
+        meshResourceState->signalCompilationFinished();
     }
 
     void Document::updateFlatAssembly()
@@ -334,18 +387,43 @@ namespace gladius
 
         updatePayload();
 
+        // Check if we can use the fast path (parameter structure unchanged)
+        bool const canUseFastPath = m_core->isParameterSignatureCompatible(*m_assembly);
+
+        auto attemptParameterUpdate = [&]() -> bool
         {
-            m_parameterDirty = m_core->tryToupdateParameter(*m_assembly);
-        }
+            if (!m_core->tryToupdateParameter(*m_assembly))
+            {
+                return false;
+            }
+            return true;
+        };
 
-        if (m_parameterDirty)
+        bool updateSucceeded = false;
+
+        if (canUseFastPath)
         {
-            m_parameterDirty = !m_core->precomputeSdfForWholeBuildPlatform();
+            updateSucceeded = attemptParameterUpdate();
         }
         else
         {
-            m_parameterDirty = true;
+            // Slow path: parameter structure changed
+            // NOTE: We don't call refreshModelAsync() here because updateParameter()
+            // is often called FROM WITHIN refreshWorker(), which would cause recursion.
+            // Instead, we just update normally and let the signature be recaptured
+            // on the next full refresh cycle.
+            auto logger = getSharedLogger();
+            if (logger)
+            {
+                logger->addEvent(
+                  {"Parameter structure mismatch detected (will be updated on next refresh)",
+                   events::Severity::Info});
+            }
+
+            updateSucceeded = attemptParameterUpdate();
         }
+
+        m_parameterDirty = !updateSucceeded;
     }
 
     void Document::updateParameterRegistration()

gladius/src/Profiling.h

@@ -6,6 +6,9 @@
 #include <thread>
 #include <tracy/Tracy.hpp>
 
+// Enable debug output for async rendering diagnostics
+//#define ASYNC_DEBUG_OUTPUT
+
 namespace gladius
 {
     class ScopedProfilingFrame
@@ -30,6 +33,16 @@ namespace gladius
     // #define LOG_LOCATION std::cout << "Method: " << __FUNCTION__ << " line: " << __LINE__ << ",
     // Thread ID: " << std::this_thread::get_id() << std::endl; #define ProfileFunction ZoneScoped;
 
+#ifdef ASYNC_DEBUG_OUTPUT
+    /// For debugging: prints text to console instead of Tracy
+    #define DebugText(text, len) std::cout << "[" << std::this_thread::get_id() << "] " << text << std::endl
+    #define DebugValue(value) std::cout << "[" << std::this_thread::get_id() << "] " << #value << " = " << value << std::endl
+#else
+    /// For profiling: sends text to Tracy
+    #define DebugText(text, len) ZoneText(text, len)
+    #define DebugValue(value) ZoneValue(value)
+#endif
+
     class ScopedTimeLogger
     {
       public:
@@ -45,7 +58,7 @@ namespace gladius
             auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - m_start);
             constexpr int64_t threshold = 1;
 
-            if (duration.count() > threshold)
+            //if (duration.count() > threshold)
             {
                 std::cout << m_name << " took " << duration.count() << "ms" << std::endl;
             }
@@ -58,6 +71,6 @@ namespace gladius
 #define LOG_SCOPE_DURATION ScopedTimeLogger scopedTimeLogger(__FUNCTION__);
 #define LOG_SCOPE_DURATION_NAMED(name) ScopedTimeLogger scopedTimeLogger(name);
 // #define ProfileFunction LOG_SCOPE_DURATION
-// #define ProfileFunction ZoneScoped;
-#define ProfileFunction
+#define ProfileFunction ZoneScoped;
+// #define ProfileFunction
 }