IndexLambdaKernel.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <agx/Kernel.h>
 
#include <stack>
 
namespace agx
{
  class AGXPHYSICS_EXPORT IndexLambdaKernel : public agx::LambdaKernel
  {
    public:
      using IndexCallback = std::function<void( agx::UInt )>;
 
    public:
      template<typename CallbackT, typename... Args>
      static IndexCallback generate( CallbackT callback, Args&&... args );
 
    public:
      IndexLambdaKernel();
 
      template<typename CallbackT, typename... Args>
      void execute( const agx::Name& name, agx::UInt numElements, CallbackT callback, Args&&... args );
 
      template<typename CallbackT, typename... Args>
      void executeEx( const agx::Name& name, agx::UInt numElements, agx::UInt jobSize, CallbackT callback, Args&&... args );
 
      void execute( IndexCallback callback,
                    const agx::Name& name,
                    agx::UInt numElements,
                    agx::UInt jobSize = agx::InvalidIndex );
 
    protected:
      virtual ~IndexLambdaKernel();
 
    private:
      struct ExecData
      {
        ExecData( IndexCallback callback, const agx::Name& name, agx::UInt numElements )
          : callback( callback ), name( name ), numElements( numElements )
        {
        }
 
        IndexCallback callback;
        agx::Name name;
        agx::UInt numElements;
      };
      using ExecStack = std::stack<ExecData>;
 
    private:
      agx::UInt getNumElements() const;
 
      void executeJob( const agx::RangeJob& job );
 
      void executeIndexRange( agx::UInt begin, agx::UInt end );
 
      void resetJobSize();
 
    private:
      ExecStack m_execStack;
      Mutex m_mutex;
  };
  using IndexLambdaKernelRef = agx::ref_ptr<IndexLambdaKernel>;
 
  template<typename CallbackT, typename... Args>
  IndexLambdaKernel::IndexCallback IndexLambdaKernel::generate( CallbackT callback, Args&&... args )
  {
    // Placeholder for UInt index as first argument.
    return std::bind( callback, std::placeholders::_1, std::forward<Args>( args )... );
  }
 
  template<typename CallbackT, typename... Args>
  void IndexLambdaKernel::execute( const agx::Name& name, agx::UInt numElements, CallbackT callback, Args&&... args )
  {
    this->executeEx( name, numElements, agx::InvalidIndex, std::forward<CallbackT>( callback ), std::forward<Args>( args )... );
  }
 
  template<typename CallbackT, typename... Args>
  void IndexLambdaKernel::executeEx( const agx::Name& name, agx::UInt numElements, agx::UInt jobSize, CallbackT callback, Args&&... args )
  {
    this->execute( generate( std::forward<CallbackT>( callback ), std::forward<Args>( args )... ), name, numElements, jobSize );
  }
}