agx.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.
*/
 
#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable: 4251) // warning C4251: class X needs to have dll-interface to be used by clients of class Y
#endif
 
#ifndef AGX_AGX_H
#define AGX_AGX_H
 
 
 
#include <agx/config.h>
#include <agx/macros.h>
#include <agx/build_flags.h>
 
#include <agx/agxPhysics_export.h>
#include <agx/agxCore_export.h>
#include <string.h>
 
#include <agx/Math.h>
#include <agx/stdint.h>
#include <agx/debug.h>
 
// Workaround for a bug in Visual Studio 2008-2013 where a C2039 could be issued when referencing a function foo
// defined in the same unnamed namespace with ::foo.
// See http://stackoverflow.com/questions/5503901/how-to-correctly-reference-a-function-in-an-anonymous-namespace
namespace {}
 
namespace agx
{
  void AGXPHYSICS_EXPORT init();
 
  void AGXPHYSICS_EXPORT shutdown();
 
  bool AGXPHYSICS_EXPORT isInitialized();
 
  bool AGXPHYSICS_EXPORT isShutdown();
 
  class AGXPHYSICS_EXPORT AutoInit
  {
  public:
    AutoInit();
    ~AutoInit();
  };
 
  enum BuildConfiguration {
    USE_64BIT_ARCHITECTURE,
    SABRE_USE_METIS,
    USE_OPENGL_INSTANCING,
    USE_PREFETCHING,
    USE_SSE,
    SABRE_USE_SSE3,
    SABRE_USE_PADDING,
    USE_TINYXML,
    USE_OPENGL,
    USE_OSG,
    UNITTEST_ENABLED,
    USE_AGXSENSOR,
    USE_AGXCALLABLE,
    USE_PARTICLE_SYSTEM,
    USE_OPENCL,
    USE_DEBUG,
    USE_COMPOSITE,
    WINDOWS_PLATFORM,
    USE_ASSIMP,
    NUM_BUILD_CONFIGURATIONS
  };
 
  bool AGXCORE_EXPORT isBuiltWith(BuildConfiguration config);
 
 
  std::string AGXCORE_EXPORT getBuildConfigurationString(BuildConfiguration config);
 
  void AGXCORE_EXPORT setNumThreads(size_t numThreads);
 
  agx::Index AGXCORE_EXPORT getNumThreads();
 
  agx::Index AGXCORE_EXPORT getNumThreadsIncludingRegistered();
 
  class Thread;
  AGXCORE_EXPORT Thread*  getCurrentThread();
 
 
  AGXCORE_EXPORT void setEntityCreationThreadSafe( bool );
 
  AGXCORE_EXPORT bool getEntityCreationThreadSafe();
 
  UInt64 AGXCORE_EXPORT getStartTick();
 
  void AGXCORE_EXPORT resetStartTick();
 
  struct AGXCORE_EXPORT InvalidIndexStruct {
    template <
      typename T,
      typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
    >
    AGX_FORCE_INLINE operator T() const {
      return (T) - 1;
    }
 
    // Comparison operators
    template <
      typename T,
      typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
    >
    AGX_FORCE_INLINE bool operator == (T val) const {
      return val == static_cast<T>(-1);
    }
 
    template <
      typename T,
      typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
    >
    AGX_FORCE_INLINE bool operator != (T val) const {
      return val != static_cast<T>(-1);
    }
  };
 
 
  // Comparison operators
  template <
    typename T,
    typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
  >
  AGX_FORCE_INLINE bool operator == (T val, InvalidIndexStruct)
  {
    return val == static_cast<T>(-1);
  }
 
  template <
    typename T,
    typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
  >
  AGX_FORCE_INLINE bool operator != (T val, InvalidIndexStruct)
  {
    return val != static_cast<T>(-1);
  }
 
  template <
    typename T,
    typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
  >
  AGX_FORCE_INLINE bool isInvalidIndex(T val)
  {
    return val == static_cast<T>(-1);
  }
 
  template <
    typename T,
    typename EnableT = std::enable_if_t<std::is_integral_v<T> || std::is_enum_v<T>>
  >
  AGX_FORCE_INLINE bool isValidIndex(T val)
  {
    return val != static_cast<T>(-1);
  }
 
  extern AGXCORE_EXPORT const InvalidIndexStruct InvalidIndex;
}
 
 
 
namespace agxCore
{
  void AGXCORE_EXPORT init();
 
  void AGXCORE_EXPORT shutdown();
 
  bool AGXCORE_EXPORT isShutdown();
}
 
#endif