Functions

float ACos(float theta)

Computes the arc cosine (inverse cosine) of a value.

float ASin(float theta)

Computes the arc sine (inverse sine) of a value.

float ATan(float theta)

Computes the arc tangent (inverse tangent) of a value.

float ATan2(float x, float y)

Computes the arc tangent of y/x using the signs to determine quadrant.

float Abs(float x)

Computes the absolute value of a float.

Matrix22 Add(const Matrix22 &a, const Matrix22 &b)

Adds two 2x2 matrices element-wise.

Matrix33 Add(const Matrix33 &a, const Matrix33 &b)

Adds two matrices element-wise.

XMatrix44< T > AffineInverse(const XMatrix44< T > &m)

Rotation AlignToVector(const Vec3 &vector)

Vec2 AngleToVector(float a)

void BasisFromVector(const Vec3 &w, Vec3 *u, Vec3 *v)

Colour BourkeColorMap(float low, float high, float v)

T Clamp(T a, T low, T high)

Clamps a value between a minimum and maximum range.

float ClosestPointBetweenLineSegmentAndTri(const Vec3 &p, const Vec3 &q, const Vec3 &a, const Vec3 &b, const Vec3 &c, float &outT, float &outV, float &outW)

void ClosestPointBetweenLineSegments(const Vec3 &p, const Vec3 &q, const Vec3 &r, const Vec3 &s, float &u, float &v)

Vec3 ClosestPointOnFatTriangle(const Vec3 &a, const Vec3 &b, const Vec3 &c, const Vec3 &p, const float thickness, float &v, float &w)

Vec3 ClosestPointOnTriangle(const Vec3 &a, const Vec3 &b, const Vec3 &c, const Vec3 &p, float &v, float &w)

Vec3 ClosestPointToAABB(const Vec3 &p, const Vec3 &lower, const Vec3 &upper)

uint32_t ColourToRGBA8(const Colour &c)

float Cos(float theta)

Computes the cosine of an angle.

Vec3 CosineSampleHemisphere()

T Cross(const XVector2< T > &a, const XVector2< T > &b)

Computes the 2D cross product of two vectors.

Vec3 Cross(const Vec3 &b, const Vec3 &c)

Computes the cross product of two 3D vectors.

T Cube(T x)

Computes the cube of a value.

float DegToRad(float t)

Converts degrees to radians.

float Determinant(const Matrix22 &m)

Calculates the determinant of a 2x2 matrix.

float Determinant(const Matrix33 &m)

Computes the determinant of a 3x3 matrix.

T Determinant(const XMatrix< n, n, T > &A, XMatrix< n, n, T > &L, XMatrix< n, n, T > &U)

Matrix33 Diagonalize(const Vec3 &v)

Creates a diagonal matrix from a 3D vector.

Vec3 DifferentiateQuat(const Quat &q1, const Quat &q0, float invdt)

T::value_type Distance(const T &v1, const T &v2)

Computes the distance between two vectors.

float Dot(const Plane &p, const Point3 &v)

float Dot(const Plane &p, const Vector3 &v)

float Dot(const Vector3 &v, const Plane &p)

T Dot(const XVector4< T > &v1, const XVector4< T > &v2)

float Dot(const Quat &a, const Quat &b)

T Dot(const XVector2< T > &v1, const XVector2< T > &v2)

Computes the dot product of two vectors.

T Dot(const XVector3< T > &v1, const XVector3< T > &v2)

Computes the dot product of two 3D vectors.

T::value_type Dot3(const T &v1, const T &v2)

Computes the dot product of two vectors with value_type return.

float Dot3(const float *v1, const float *v2)

Computes the dot product of two float arrays representing 3D vectors.

void EulerFromQuatZYX(const Quat &q, float &rotx, float &roty, float &rotz)

void ExtractFrustumPlanes(const Matrix44 &m, Plane *planes)

bool FileMove(const char *src, const char *dest)

bool FileScan(const char *pattern, std::vector< std::string > &files)

T FrobeniusNorm(const XMatrix< m, n, T > &A)

Vec3 GetBasisVector0(const Quat &q)

Vec3 GetBasisVector1(const Quat &q)

Vec3 GetBasisVector2(const Quat &q)

bool GetCmdLineArg(const char *arg, T &out, int argc, const char *const argv[])

std::string GetExePath()

std::string GetFilePathByPlatform(const char *path)

Quat GetRotationQuat(const Vec3 &_u, const Vec3 &_v)

double GetSeconds()

std::string GetWorkingDirectory()

bool GfIsClose(const pxr::GfQuatd &val1, const pxr::GfQuatd &val2, double tolerance)

Colour HSVToRGB(float h, float s, float v)

T HermiteInterpolate(const T &a, const T &b, const T &t1, const T &t2, float t)

T HermiteSecondDerivative(const T &a, const T &b, const T &t1, const T &t2, float t)

T HermiteTangent(const T &a, const T &b, const T &t1, const T &t2, float t)

Quat IntegrateQuat(const Vec3 &omega, const Quat &q0, float dt)

bool IntersectLineSegmentPlane(const Vec3 &start, const Vec3 &end, const Plane &plane, Vec3 &out)

bool IntersectLineTri(const Vec3 &p, const Vec3 &q, const Vec3 &a, const Vec3 &b, const Vec3 &c)

bool IntersectPlaneAABB(const Vec4 &plane, const Vec3 &center, const Vec3 &extents)

bool IntersectRayAABB(const Vec3 &start, const Vector3 &dir, const Vector3 &min, const Vector3 &max, float &t, Vector3 *normal)

bool IntersectRayAABBFast(const Vec3 &pos, const Vector3 &rcp_dir, const Vector3 &min, const Vector3 &max, float &t)

bool IntersectRayFatTriangle(const Vec3 &p, const Vec3 &dir, const Vec3 &a, const Vec3 &b, const Vec3 &c, float thickness, float threshold, float maxT, float &t, float &u, float &v, float &w, Vec3 *normal)

bool IntersectRayPlane(const Point3 &p, const Vector3 &dir, const Plane &plane, float &t)

bool IntersectRaySphere(const Point3 &sphereOrigin, float sphereRadius, const Point3 &rayOrigin, const Vec3 &rayDir, float &t, Vec3 *hitNormal=nullptr)

bool IntersectRaySphere(const Point3 &sphereOrigin, float sphereRadius, const Point3 &rayOrigin, const Vector3 &rayDir, float &minT, float &maxT, Vec3 *hitNormal=nullptr)

bool IntersectRayTri(const Point3 &p, const Vec3 &dir, const Point3 &a, const Point3 &b, const Point3 &c, float &t, float &u, float &v, float &w, Vec3 *normal)

bool IntersectRayTriTwoSided(const Vec3 &p, const Vec3 &dir, const Vec3 &a, const Vec3 &b, const Vec3 &c, float &t, float &u, float &v, float &w, float &sign, Vec3 *normal)

bool IntersectSegmentTri(const Vec3 &p, const Vec3 &q, const Vec3 &a, const Vec3 &b, const Vec3 &c, float &t, float &u, float &v, float &w, Vec3 *normal)

Bounds Intersection(const Bounds &a, const Bounds &b)

float InvSqrt(float x)

Computes the inverse square root of a value.

Matrix22 Inverse(const Matrix22 &m, float &det)

Computes the inverse of a 2x2 matrix.

Matrix33 Inverse(const Matrix33 &a, bool &success)

Computes the inverse of a 3x3 matrix using single precision.

Transform Inverse(const Transform &transform)

XMatrix< n, n, T > Inverse(const XMatrix< n, n, T > &A, T &det)

Quat Inverse(const Quat &q)

Matrix33 InverseDouble(const Matrix33 &a, bool &success)

Computes the inverse of a 3x3 matrix using double precision.

Vec3 InverseTransformPoint(const Transform &t, const Vec3 &v)

Vec3 InverseTransformVector(const Transform &t, const Vec3 &v)

Colour JetColorMap(float low, float high, float x)

float L2_magnitude(const Matrix33 &matrix)

Computes the L2 magnitude (Frobenius norm) of a matrix.

XMatrix< n, n, T > LU(const XMatrix< n, n, T > &m, XMatrix< n, n, T > &L)

T::value_type Length(const T &v)

Computes the length (magnitude) of a vector.

float Length(const Quat &a)

T::value_type LengthSq(const T v)

Computes the squared length of a vector.

V Lerp(const V &start, const V &end, const T &t)

Performs linear interpolation between two values.

Colour LinearToSrgb(const Colour &c)

float Log(float base, float x)

int Log2(int x)

Mat44 LookAtMatrix(const Point3 &viewer, const Point3 &target)

T Max(T a, T b)

Returns the maximum of two values.

Point3 Max(const Point3 &a, const Point3 &b)

Computes the component-wise maximum of two points.

XVector2< T > Max(const XVector2< T > &a, const XVector2< T > &b)

Computes the component-wise maximum of two vectors.

XVector3< T > Max(const XVector3< T > &a, const XVector3< T > &b)

Component-wise maximum of two vectors.

T Min(T a, T b)

Returns the minimum of two values.

Point3 Min(const Point3 &a, const Point3 &b)

Computes the component-wise minimum of two points.

XVector2< T > Min(const XVector2< T > &a, const XVector2< T > &b)

Computes the component-wise minimum of two vectors.

XVector3< T > Min(const XVector3< T > &a, const XVector3< T > &b)

Component-wise minimum of two vectors.

float Mod(float x, float y)

Computes the floating-point remainder of x/y.

Matrix22 Multiply(const Matrix22 &a, const Matrix22 &b)

Multiplies two 2x2 matrices.

Matrix22 Multiply(float s, const Matrix22 &m)

Multiplies a 2x2 matrix by a scalar value.

Vec2 Multiply(const Matrix22 &a, const Vec2 &x)

Multiplies a 2x2 matrix by a 2D vector.

Vec3 Multiply(const Matrix33 &a, const Vec3 &x)

Multiplies a matrix by a vector.

Matrix33 Multiply(float s, const Matrix33 &m)

Multiplies a matrix by a scalar.

Matrix33 Multiply(const Matrix33 &a, const Matrix33 &b)

Multiplies two matrices.

XVector3< T > Multiply(const XMatrix44< T > &mat, const XVector3< T > &v)

XVector4< T > Multiply(const XMatrix44< T > &mat, const XVector4< T > &v)

Point3 Multiply(const XMatrix44< T > &mat, const Point3 &v)

XMatrix< m, o > Multiply(const XMatrix< m, n, T > &lhs, const XMatrix< n, o, T > &rhs)

T Normalize(const T &v)

Normalizes a vector to unit length.

Quat Normalize(const Quat &q)

Vec4 NormalizePlane(const Vec4 &p)

Mat44 OrthographicMatrix(float left, float right, float bottom, float top, float n, float f)

Matrix22 Outer(const Vec2 &a, const Vec2 &b)

Computes the outer product of two 2D vectors.

Matrix33 Outer(const Vec3 &a, const Vec3 &b)

Computes the outer product of two vectors.

XMatrix44< float > Outer(const Vec4 &a, const Vec4 &b)

XMatrix< n, n > Permutation(int i, int j)

XVector2< T > PerpCCW(const XVector2< T > &v)

Returns the counter-clockwise perpendicular vector.

XVector2< T > PerpCW(const XVector2< T > &v)

Returns the clockwise perpendicular vector.

Vec4 PlaneFromPoints(const Vec3 &p, const Vec3 &q, const Vec3 &r)

bool PointInTriangle(Vec3 a, Vec3 b, Vec3 c, Vec3 p)

int PoissonSample3D(float radius, float separation, Vec3 *points, int maxPoints, int maxAttempts)

int PoissonSampleBox3D(Vec3 lower, Vec3 upper, float separation, Vec3 *points, int maxPoints, int maxAttempts)

Matrix22 PolarDecomposition(const Matrix22 &m)

Performs polar decomposition of a 2x2 matrix.

float Pow(float b, float e)

Computes b raised to the power e.

void PrintMatrix(const char *name, XMatrix< m, n > a)

Mat44 ProjectionMatrix(float fov, float aspect, float znear, float zfar)

Matrix22 QRDecomposition(const Matrix22 &m)

Performs QR decomposition of a 2x2 matrix.

Quat QuatFromAxisAngle(const Vec3 &axis, float angle)

Quat QuatFromEulerZYX(float rotx, float roty, float rotz)

float RadToDeg(float t)

Converts radians to degrees.

uint32_t Rand(uint32_t min, uint32_t max)

uint32_t Rand()

void RandInit(uint32_t seed=315645664)

Vec3 RandVec3()

Vec4 Randf(const Vec4 &range)

float Randf()

float Randf(float max)

float Randf(float min, float max)

float Random(float lo, float hi)

void RandomShuffle(T begin, T end)

float RandomSignedUnit()

float RandomUnit()

Vec3 RandomUnitVector()

T RangeMap(T value, T lower, T upper)

Vec3 Rotate(const Quat &q, const Vec3 &x)

Vec3 RotateInv(const Quat &q, const Vec3 &x)

Matrix22 RotationMatrix(float theta)

Creates a 2D rotation matrix for the given angle.

Mat44 RotationMatrix(float angle, const Vec3 &axis)

Mat44 RotationMatrix(const Quat &q)

int Round(float f)

Rounds a float value to the nearest integer.

T SafeNormalize(const T &v, const T &fallback=T())

Safely normalizes a vector with fallback for zero-length vectors.

float ScalarTriple(const Vec3 &a, const Vec3 &b, const Vec3 &c)

Mat44 ScaleMatrix(const Vector3 &s)

float Sgn(float x)

Computes the sign of a value.

float Sign(float x)

Computes the sign of a float value.

double Sign(double x)

Computes the sign of a double value.

float Sin(float theta)

Computes the sine of an angle.

void SinCos(float theta, float &s, float &c)

Computes both sine and cosine of an angle simultaneously.

Matrix33 Skew(const Vec3 &v)

Creates a skew-symmetric matrix from a vector.

void Sleep(double seconds)

float SmoothStep(float a, float b, float t)

XMatrix< m, 1, T > Solve(const XMatrix< m, m, T > &L, const XMatrix< m, m, T > &U, const XMatrix< m, 1, T > &b)

bool SolveQuadratic(T a, T b, T c, T &minT, T &maxT)

float SpecularExponentToRoughness(float exponent, float maxExponent=2048.0f)

float SpecularRoughnessToExponent(float roughness, float maxExponent=2048.0f)

Vec3 SphericalToXYZ(float theta, float phi)

float SqDistPointSegment(Vec3 a, Vec3 b, Vec3 c)

T Sqr(T x)

Computes the square of a value.

double Sqrt(double x)

Computes the square root of a double value.

float Sqrt(float x)

Computes the square root of a float value.

Colour SrgbToLinear(const Colour &c)

float SurfaceArea(const Bounds &b)

void Swap(T &a, T &b)

Swaps two values.

float Tan(float theta)

Computes the tangent of an angle.

bool TestSphereAgainstFrustum(const Plane *planes, Vec3 center, float radius)

int TightPack3D(float radius, float separation, Vec3 *points, int maxPoints)

Colour ToneMap(const Colour &s)

float Trace(const Matrix22 &a)

Calculates the trace of a 2x2 matrix.

float Trace(const Matrix33 &a)

Computes the trace (sum of diagonal elements) of a matrix.

void TransformBounds(const Quat &q, Vec3 extents, Vec3 &newExtents)

void TransformBounds(const Vec3 &localLower, const Vec3 &localUpper, const Vec3 &translation, const Quat &rotation, float scale, Vec3 &lower, Vec3 &upper)

Mat44 TransformFromVector(const Vec3 &w, const Point3 &t=Point3(0.0f, 0.0f, 0.0f))

Mat44 TransformMatrix(const Rotation &r, const Point3 &p)

Mat44 TransformMatrix(const Transform &t)

Vec3 TransformPoint(const Transform &t, const Vec3 &v)

Vec3 TransformVector(const Transform &t, const Vec3 &v)

Mat44 TranslationMatrix(const Point3 &t)

Matrix22 Transpose(const Matrix22 &a)

Computes the transpose of a 2x2 matrix.

Matrix33 Transpose(const Matrix33 &a)

Computes the transpose of a matrix.

XMatrix44< T > Transpose(const XMatrix44< T > &m)

XMatrix< n, m > Transpose(const XMatrix< m, n > &a)

Vec2 UniformSampleDisc()

Vec3 UniformSampleHemisphere()

Vec3 UniformSampleSphere()

Vec3 UniformSampleSphereVolume()

void UniformSampleTriangle(float &u, float &v)

Bounds Union(const Bounds &a, const Bounds &b)

Bounds Union(const Bounds &a, const Vec3 &b)

float VectorToAngle(const Vec2 &v)

Mat44 ViewMatrix(const Point3 &pos)

Colour XYZToLinear(float x, float y, float z)

Colour YxyToXYZ(float Y, float x, float y)

std::unique_ptr< isaacsim::ros2::core::Ros2Factory > createFactory()

Factory creation function exported by the library.

isaacsim::ros2::core::Ros2Factory * createFactoryC()

C wrapper for factory creation function for dynamic symbol loading.

Quat euler_xyz2quat(const float x_rot, const float y_rot, const float z_rot)

int getClosestAxis(const Vec3 &vec)

void getEulerXYZ(const XQuat< float > &q, float &X, float &Y, float &Z)

Extracts Euler angles from a quaternion using XYZ rotation order.

void getEulerZYX(const Quat &q, float &yawZ, float &pitchY, float &rollX)

bool isaacsim::core::cloner::fabricClone(long int stageId, const std::string &sourcePrimPath, const std::vector< std::string > &primPaths)

Creates clones of a source prim at specified target paths in the USD stage.

uint64_t isaacsim::core::experimental::prims::sdfPathToToken(const pxr::SdfPath &path)

pxr::SdfPath isaacsim::core::experimental::prims::tokenToSdfPath(uint64_t token)

carb::ColorRgba isaacsim::core::includes::color::distToRgba(double ratio)

Converts a ratio value to a carb::ColorRgba struct.

carb::Float3 isaacsim::core::includes::conversions::asCarbFloat3(const pxr::GfVec3d &v)

Converts pxr::GfVec3d to carb::Float3.

carb::Float3 isaacsim::core::includes::conversions::asCarbFloat3(const pxr::GfVec3f &v)

Converts pxr::GfVec3f to carb::Float3.

carb::Float4 isaacsim::core::includes::conversions::asCarbFloat4(const pxr::GfQuatf &v)

Converts pxr::GfQuatf to carb::Float4.

carb::Float4 isaacsim::core::includes::conversions::asCarbFloat4(const physx::PxQuat &q)

convert physx::PxQuat to carb::Float4

carb::Float4 isaacsim::core::includes::conversions::asCarbFloat4(const pxr::GfQuatd &v)

Converts pxr::GfQuatd to carb::Float4.

pxr::GfQuatd isaacsim::core::includes::conversions::asGfQuatd(const carb::Float4 &q)

Converts a carb::Float4 into a pxr::GfQuatd.

pxr::GfQuatf isaacsim::core::includes::conversions::asGfQuatf(const carb::Float4 &q)

Converts a carb::Float4 into a pxr::GfQuatf.

pxr::GfRotation isaacsim::core::includes::conversions::asGfRotation(const carb::Float4 &q)

Converts a carb::Float4 into a pxr::GfRotation.

pxr::GfTransform isaacsim::core::includes::conversions::asGfTransform(const carb::Float3 &p, const carb::Float4 &r)

Converts position and rotation into a pxr::GfTransform.

pxr::GfVec3d isaacsim::core::includes::conversions::asGfVec3d(const carb::Float3 &v)

Converts a carb::Float3 into a pxr::GfVec3d.

pxr::GfVec3f isaacsim::core::includes::conversions::asGfVec3f(const carb::Float3 &v)

Converts a carb::Float3 into a pxr::GfVec3f.

inline ::physx::PxQuat isaacsim::core::includes::conversions::asPxQuat(const usdrt::GfQuatf &v)

Converts usdrt::GfQuatf into PhysX quaternion.

inline ::physx::PxQuat isaacsim::core::includes::conversions::asPxQuat(const pxr::GfQuatd &v)

Converts pxr::GfQuatd into PhysX quaternion.

inline ::physx::PxQuat isaacsim::core::includes::conversions::asPxQuat(const usdrt::GfQuatd &v)

Converts usdrt::GfQuatd into PhysX quaternion.

inline ::physx::PxQuat isaacsim::core::includes::conversions::asPxQuat(const pxr::GfQuatf &v)

Converts pxr::GfQuatf into PhysX quaternion.

inline ::physx::PxQuat isaacsim::core::includes::conversions::asPxQuat(const carb::Float4 &q)

Converts carb::Float4 into PhysX quaternion.

inline ::physx::PxTransform isaacsim::core::includes::conversions::asPxTransform(const pxr::GfTransform &trans)

Converts USD transform into PhysX transform.

inline ::physx::PxTransform isaacsim::core::includes::conversions::asPxTransform(const usdrt::GfVec3d &translation, const usdrt::GfQuatd &orientation)

Converts USD runtime translation and orientation into PhysX transform.

inline ::physx::PxTransform isaacsim::core::includes::conversions::asPxTransform(const usdrt::GfMatrix4d &mat)

Converts USD runtime matrix into PhysX transform.

inline ::physx::PxVec3 isaacsim::core::includes::conversions::asPxVec3(const pxr::GfVec3d &v)

Converts pxr::GfVec3d into PhysX vector.

inline ::physx::PxVec3 isaacsim::core::includes::conversions::asPxVec3(const carb::Float3 &v)

Converts carb::Float3 into PhysX vector.

inline ::physx::PxVec3 isaacsim::core::includes::conversions::asPxVec3(const usdrt::GfVec3d &v)

Converts usdrt::GfVec3d into PhysX vector.

inline ::physx::PxVec3 isaacsim::core::includes::conversions::asPxVec3(const pxr::GfVec3f &v)

Converts pxr::GfVec3f into PhysX vector.

inline ::physx::PxVec3 isaacsim::core::includes::conversions::asPxVec3(const usdrt::GfVec3f &v)

Converts usdrt::GfVec3f into PhysX vector.

void isaacsim::core::includes::copyTimeSamplesFromWeakerLayer(pxr::UsdStage &stage, const pxr::UsdAttribute &attr)

Copy TimeSample From Waker Layer.

py::class_< InterfaceType, PyClassArgs… > isaacsim::core::includes::defineInterfaceClass(py::module &m, const char *className, const char *acquireFuncName, const char *releaseFuncName=nullptr, const char *classDocstring=nullptr)

Define a pybind11 class for a Carbonite interface with acquire/release functions.

pxr::GfMatrix4d isaacsim::core::includes::findInnerTransform(pxr::UsdPrim prim, const pxr::GfMatrix4d &mtx, bool &foundTransformOp, pxr::UsdTimeCode timecode=pxr::UsdTimeCode::Default(), bool skipEqualSetForTimeSample=false)

Given a target local transform matrix for a prim, determine what value to set just the transformOp when other xformOps are present.

const char * isaacsim::core::includes::getActivePhysicsEngineName()

Return the name of the first active physics simulation, or nullptr if none is active.

TimeSamplesOnLayer isaacsim::core::includes::getAttributeEffectiveTimeSampleLayerInfo(const pxr::UsdStage &stage, const pxr::UsdAttribute &attr, pxr::SdfLayerRefPtr *outLayer=nullptr)

check if attribute has efficient timesample and these data are on currentlayer/strongerlayer/weakerlayer

pxr::UsdAttribute isaacsim::core::includes::getCameraAttributeFromRenderProduct(const std::string &attributeString, const std::string &renderProductPathString)

Retrieves a specific attribute from a camera associated with a render product.

pxr::UsdPrim isaacsim::core::includes::getCameraPrimFromRenderProduct(const std::string &renderProductPathString)

Retrieves the camera prim associated with a render product.

PXR_NS::SdfLayerRefPtr isaacsim::core::includes::getLayerIfDefOnSessionOrItsSublayers(PXR_NS::UsdStageRefPtr stage, const PXR_NS::SdfPath &path)

Finds if the given prim path has a "def" primSpec on session layer or its sublayers.

PXR_NS::SdfLayerRefPtr isaacsim::core::includes::getLayerIfSpecOnSessionOrItsSublayers(PXR_NS::UsdStageRefPtr stage, const PXR_NS::SdfPath &path, const std::function< bool(PXR_NS::SdfSpecHandle)> &predicate=nullptr)

Finds if the given path has a spec on session layer or its sublayers.

pxr::GfMatrix4d isaacsim::core::includes::getLocalTransformMatrix(const pxr::UsdPrim &prim, pxr::UsdTimeCode time=pxr::UsdTimeCode::Default())

Gets local transform matrix of a prim.

std::string isaacsim::core::includes::getName(const pxr::UsdPrim &prim)

Retrieves the name of a USD prim, with support for custom overrides.

pxr::SdfPath isaacsim::core::includes::getSdfPathFromUint64(uint64_t pathToken)

Converts a uint64_t token to a USD path.

pxr::GfMatrix4d isaacsim::core::includes::getWorldTransformMatrix(const pxr::UsdPrim &prim, pxr::UsdTimeCode time=pxr::UsdTimeCode::Default())

Gets world transform matrix of a prim.

bool isaacsim::core::includes::hasTimeSample(const pxr::UsdAttribute &attribute, pxr::UsdTimeCode timeCode)

Checks if a UsdAttribute instance has time sample on key timeCode.

bool isaacsim::core::includes::isTimeSampled(const pxr::UsdAttribute &attribute)

Checks if a UsdAttribute instance is time sampled.

carb::Float3 isaacsim::core::includes::math::cross(const carb::Float3 &b, const carb::Float3 &c)

Computes the cross product of two 3D vectors.

float isaacsim::core::includes::math::dot(const carb::Float4 &v1, const carb::Float4 &v2)

Computes the dot product of two 4D vectors.

float isaacsim::core::includes::math::dot(const carb::Float3 &v1, const carb::Float3 &v2)

Computes the dot product of two 3D vectors.

carb::Float3 isaacsim::core::includes::math::getBasisVectorX(const carb::Float4 &q)

Gets the X basis vector from a rotation quaternion.

carb::Float3 isaacsim::core::includes::math::getBasisVectorY(const carb::Float4 &q)

Gets the Y basis vector from a rotation quaternion.

carb::Float3 isaacsim::core::includes::math::getBasisVectorZ(const carb::Float4 &q)

Gets the Z basis vector from a rotation quaternion.

carb::Float4 isaacsim::core::includes::math::inverse(const carb::Float4 &q)

Computes the inverse of a quaternion.

carb::Float3 isaacsim::core::includes::math::lerp(const carb::Float3 &start, const carb::Float3 &end, const float t)

Linearly interpolates between two 3D vectors.

carb::Float4 isaacsim::core::includes::math::lerp(const carb::Float4 &start, const carb::Float4 &end, const float t)

Linearly interpolates between two quaternions.

pxr::GfQuatf isaacsim::core::includes::math::lookAt(const pxr::GfVec3f &camera, const pxr::GfVec3f &target, const pxr::GfVec3f &up)

Computes a look-at quaternion rotation.

carb::Float3 isaacsim::core::includes::math::normalize(const carb::Float3 &q)

Normalizes a 3D vector to unit length.

carb::Float4 isaacsim::core::includes::math::normalize(const carb::Float4 &q)

Normalizes a quaternion to unit length.

carb::Float4 isaacsim::core::includes::math::operator*(const carb::Float4 &a, const carb::Float4 &b)

Performs quaternion multiplication.

carb::Float4 isaacsim::core::includes::math::operator*(const carb::Float4 &a, const float x)

Scales a 4D vector/quaternion by a scalar value.

carb::Float3 isaacsim::core::includes::math::operator*(const carb::Float3 &a, const float x)

Scales a 3D vector by a scalar value.

carb::Float4 isaacsim::core::includes::math::operator+(const carb::Float4 &a, const carb::Float4 &b)

Adds two 4D vectors/quaternions.

carb::Float3 isaacsim::core::includes::math::operator+(const carb::Float3 &a, const carb::Float3 &b)

Adds two 3D vectors.

carb::Float3 isaacsim::core::includes::math::operator-(const carb::Float3 &a, const carb::Float3 &b)

Subtracts two 3D vectors.

carb::Float4 isaacsim::core::includes::math::operator-(const carb::Float4 &a, const carb::Float4 &b)

Subtracts two 4D vectors/quaternions.

carb::Float3 isaacsim::core::includes::math::rotate(const carb::Float4 &q, const carb::Float3 x)

Rotates a vector by a quaternion.

double isaacsim::core::includes::math::roundNearest(double input, double place)

Rounds a number to the nearest multiple of a given value.

carb::Float4 isaacsim::core::includes::math::slerp(const carb::Float4 &start, const carb::Float4 &end, const float t)

Performs spherical linear interpolation between quaternions.

pxr::GfTransform isaacsim::core::includes::math::transformInv(const pxr::GfTransform &a, const pxr::GfTransform &b)

Computes the local transform of b relative to transform a.

usdrt::GfMatrix4d isaacsim::core::includes::pose::computeWorldXformNoCache(pxr::UsdStageRefPtr usdStage, usdrt::UsdStageRefPtr usdrtStage, const pxr::SdfPath &path, pxr::UsdTimeCode timecode=pxr::UsdTimeCode::Default(), bool useFabricHierarchy=true, bool logWarningOnFallback=false)

Computes the world transform of a prim.

usdrt::GfMatrix4d isaacsim::core::includes::pose::getRelativeTransform(pxr::UsdStageRefPtr usdStage, usdrt::UsdStageRefPtr usdrtStage, const pxr::SdfPath &sourcePrim, const pxr::SdfPath &targetPrim)

Computes the relative transform matrix between two prims.

void isaacsim::core::includes::posetree::createTensorDesc(TensorDesc &tensorDesc, void *dataPtr, int numXforms, TensorDataType type, int device)

void isaacsim::core::includes::safeGetAttribute(const pxr::UsdAttribute &attr, T &inputValue)

Safely retrieves a USD attribute value with error handling.

bool isaacsim::core::includes::setAttribute(const pxr::UsdAttribute &attribute, const ValueType &val, pxr::UsdTimeCode timeCode=pxr::UsdTimeCode::Default(), bool skipEqualSetForTimeSample=false, bool autoTargetSessionLayer=true)

Sets attribute value with optional time sampling and session layer targeting.

bool isaacsim::core::includes::setLocalTransformMatrix(pxr::UsdPrim prim, const pxr::GfMatrix4d &mtxIn, pxr::UsdTimeCode timecode=pxr::UsdTimeCode::Default(), bool skipEqualSetForTimeSample=false, std::unique_ptr< PXR_NS::SdfChangeBlock > *parentChangeBlock=nullptr)

Sets local transform matrix of a prim.

bool isaacsim::core::includes::setValueWithPrecision(pxr::UsdGeomXformOp &xformOp, const ValueType &value, pxr::UsdTimeCode timeCode=pxr::UsdTimeCode::Default(), bool skipEqualSetForTimeSample=false)

Set value with precision based on the UsdGeomXformOp precision type.

void isaacsim::core::includes::transforms::createTensorDesc(TensorDesc &tensorDesc, void *dataPtr, int numElements, TensorDataType type)

void isaacsim::core::includes::transforms::setScale(pxr::UsdPrim &prim, pxr::GfVec3f pxBodyScale)

Sets the scale of a USD prim.

void isaacsim::core::includes::transforms::setTransform(pxr::UsdPrim &prim, pxr::GfVec3f bodyTranslation, pxr::GfQuatf bodyRotation)

Sets the transform (position and rotation) of a USD prim.

std::string isaacsim::core::includes::utils::path::MakeRelativePath(const std::string &filePath, const std::string &fileRelativePath)

bool isaacsim::core::includes::utils::path::createSymbolicLink(const std::string &target, const std::string &link)

std::string isaacsim::core::includes::utils::path::getParent(const std::string &filePath)

std::string isaacsim::core::includes::utils::path::getPathStem(const char *path)

bool isaacsim::core::includes::utils::path::hasExtension(const std::string &filename, const std::string &extension)

bool isaacsim::core::includes::utils::path::isAbsolutePath(const char *path)

bool isaacsim::core::includes::utils::path::isFile(const std::string &path)

std::string isaacsim::core::includes::utils::path::normalizeUrl(const char *url)

std::string isaacsim::core::includes::utils::path::pathJoin(const std::string &path1, const std::string &path2)

std::string isaacsim::core::includes::utils::path::resolve_absolute(std::string parent, std::string relative)

std::string isaacsim::core::includes::utils::path::resolve_path(const std::string &path)

Calculates the final path by resolving the relative path and removing any unnecessary components.

std::string isaacsim::core::includes::utils::path::resolve_relative(const std::string &base, const std::string &target)

Calculates the relative path of target relative to base.

std::vector< std::string > isaacsim::core::includes::utils::path::split_path(const std::string &path)

PathType isaacsim::core::includes::utils::path::testPath(const char *path)

std::string isaacsim::core::includes::utils::path::toLowercase(const std::string &str)

pxr::GfMatrix4d isaacsim::core::includes::utils::usd::GetGlobalTransform(const pxr::UsdPrim &prim)

std::string isaacsim::core::includes::utils::usd::GetNewSdfPathString(pxr::UsdStageWeakPtr stage, std::string path, int nameClashNum=0)

std::string isaacsim::core::includes::utils::usd::makeValidUSDIdentifier(const std::string &name)

bool isaacsim::core::includes::utils::usd::setAuthoringLayer(pxr::UsdStageRefPtr stage, const std::string &layerIdentifier)

Select a existing layer as edit target.

std::vector< std::string > isaacsim::core::simulation_manager::getPhysicsScenePaths(uint64_t stageId)

Gets the paths of all PhysicsScene prims in the specified stage.

std::vector< std::string > isaacsim::core::simulation_manager::getPhysicsScenePaths()

Gets the paths of all PhysicsScene prims in the default stage.

std::vector< std::string > isaacsim::core::simulation_manager::getPhysicsScenePaths(const pxr::UsdStagePtr &stage)

Gets the paths of all PhysicsScene prims in the specified stage.

void isaacsim::core::utils::findMatchingChildren(pxr::UsdPrim root, const std::string &pattern, std::vector< pxr::UsdPrim > &primsRet)

Finds child prims matching a specified name pattern.

std::vector< std::string > isaacsim::core::utils::findMatchingPrimPaths(const std::string &pattern, long int stageId, const std::string &api=std::string(""))

Finds USD prims matching a specified path pattern.

void isaacsim::hsb::core::launchBayer8pTo10p(const uint8_t *src, uint8_t *dest, uint32_t width, uint32_t height, uint32_t lineBytes, void *stream=nullptr)

void isaacsim::hsb::core::launchBayer8pToTX2Rc10Rb10Ra10(const uint8_t *src, uint8_t *dest, uint32_t width, uint32_t height, uint32_t lineBytes, void *stream=nullptr)

void isaacsim::hsb::core::launchRGBToGBRG(const uint8_t *src, uint8_t *dest, uint32_t width, uint32_t height, uint8_t channels, void *stream=nullptr)

uint32_t isaacsim::hsb::core::lineBytesRaw10(uint32_t width)

uint32_t isaacsim::hsb::core::lineBytesRaw10Coe(uint32_t width)

uint32_t isaacsim::hsb::core::vb1940CsiCoeFrameSize(uint32_t w, uint32_t h)

uint32_t isaacsim::hsb::core::vb1940CsiLinuxFrameSize(uint32_t w, uint32_t h)

void isaacsim::physics::newton::tensors::cpuContactData(const int *contactCount, const int *shape0, const int *shape1, const float *point0, const float *point1, const float *normal, const float *contactForce, const float *thickness0, const float *thickness1, const int *shapeBody, const float *bodyQ, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int filterCount, int worldBodyIdx, float dtScale, int maxContactDataCount, float *outForces, float *outPoints, float *outNormals, float *outSeparations, uint32_t *outCounts, const uint32_t *startIndices, int rigidContactMax, bool pointsInWorldSpace=false)

void isaacsim::physics::newton::tensors::cpuContactForceMatrix(const int *contactCount, const int *shape0, const int *shape1, const float *contactForce, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int worldBodyIdx, float dtScale, int filterCount, float *forceMatrix, int rigidContactMax)

void isaacsim::physics::newton::tensors::cpuCountContactsPerPair(const int *contactCount, const int *shape0, const int *shape1, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int filterCount, int worldBodyIdx, uint32_t *counts, int rigidContactMax)

void isaacsim::physics::newton::tensors::cpuCountRawContactsPerSensor(const int *contactCount, const int *shape0, const int *shape1, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, uint32_t *counts, int rigidContactMax)

void isaacsim::physics::newton::tensors::cpuExtractVec3FromSpatial(const float *spatialSrc, float *vec3Dst, int n)

void isaacsim::physics::newton::tensors::cpuNetContactForces(const int *contactCount, const int *shape0, const int *shape1, const float *contactForce, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, float dtScale, float *netForces, int rigidContactMax)

void isaacsim::physics::newton::tensors::cpuRawContactData(const int *contactCount, const int *shape0, const int *shape1, const float *point0, const float *point1, const float *normal, const float *contactForce, const float *thickness0, const float *thickness1, const int *shapeBody, const float *bodyQ, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, float dtScale, int maxContactDataCount, float *outForces, float *outPoints, float *outNormals, float *outSeparations, uint32_t *outCounts, const uint32_t *startIndices, uint64_t *otherActorIds, int rigidContactMax, bool pointsInWorldSpace=false)

const float * isaacsim::physics::newton::tensors::ensureGpuSrc(const TensorDesc *srcTensor, float *devStagingBuf, size_t maxFloats)

Ensures source data resides on the GPU. If srcTensor is already on device, returns its pointer. If on CPU, performs H2D copy into devStagingBuf. Returns nullptr on error.

void isaacsim::physics::newton::tensors::gatherCenterOfMass(const wp::vec3 *src, float *dst, const int *indices, size_t n, const float *cachedOrientation)

void isaacsim::physics::newton::tensors::gatherFloat(const float *src, float *dst, const int *indices, size_t n)

void isaacsim::physics::newton::tensors::gatherMat33(const wp::mat33 *src, float *dst, const int *indices, size_t n)

void isaacsim::physics::newton::tensors::gatherPairedFloat(const float *srcA, const float *srcB, float *dst, const int *indices, size_t n)

void isaacsim::physics::newton::tensors::gatherSpatialVector(const wp::spatial_vector *src, float *dst, const int *indices, size_t n)

void isaacsim::physics::newton::tensors::gatherTransform(const wp::transform *src, float *dst, const int *indices, size_t n)

int isaacsim::physics::newton::tensors::getWarpArrayDevice(py::object pyArray)

Returns the CUDA device ordinal of a wp.array (-1 for CPU, >= 0 for GPU).

std::vector< int64_t > isaacsim::physics::newton::tensors::getWarpArrayShape(py::object pyArray)

Returns the shape of a wp.array as a vector of dimension sizes.

size_t isaacsim::physics::newton::tensors::getWarpArraySize(py::object pyArray)

Returns the total number of elements in a wp.array (product of all dimensions).

bool isaacsim::physics::newton::tensors::gpuGather(LaunchFn &&launch, const TensorDesc *dstTensor, int n, size_t elemFloats, float *stagingBuffer)

Launches a CUDA gather kernel and stages the result to dstTensor.

void isaacsim::physics::newton::tensors::indirectAddFloat(const float *src, float *dst, const int *srcOffsets, const int *dstIndices, size_t n)

void isaacsim::physics::newton::tensors::indirectScatterFloat(const float *src, float *dst, const int *srcOffsets, const int *dstIndices, size_t n)

bool isaacsim::physics::newton::tensors::launchContactData(const int *contactCount, const int *shape0, const int *shape1, const float *point0, const float *point1, const float *normal, const float *contactForce, const float *thickness0, const float *thickness1, const int *shapeBody, const float *bodyQ, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int filterCount, int worldBodyIdx, float dtScale, int maxContactDataCount, float *outForces, float *outPoints, float *outNormals, float *outSeparations, uint32_t *outCounts, const uint32_t *startIndices, int rigidContactMax, bool pointsInWorldSpace=false, void *stream=nullptr)

Emit per-contact data (force, point, normal, separation) for each sensor/filter pair.

bool isaacsim::physics::newton::tensors::launchContactForceMatrix(const int *contactCount, const int *shape0, const int *shape1, const float *contactForce, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int worldBodyIdx, float dtScale, int filterCount, float *forceMatrix, int rigidContactMax, void *stream=nullptr)

Accumulate per-(sensor, filter) contact forces into a dense matrix.

bool isaacsim::physics::newton::tensors::launchCopyUint8(const uint8_t *src, uint8_t *dst, int n, void *stream=nullptr)

Device-to-device byte copy of a flat uint8 buffer.

bool isaacsim::physics::newton::tensors::launchCountContactsPerPair(const int *contactCount, const int *shape0, const int *shape1, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, const int *bodyFilterMap, int numBodies, int filterCount, int worldBodyIdx, uint32_t *counts, int rigidContactMax, void *stream=nullptr)

Count the number of contacts per (sensor, filter) pair.

bool isaacsim::physics::newton::tensors::launchCountRawContactsPerSensor(const int *contactCount, const int *shape0, const int *shape1, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, uint32_t *counts, int rigidContactMax, void *stream=nullptr)

Count raw contacts per sensor (ignoring filters).

bool isaacsim::physics::newton::tensors::launchExtractVec3FromSpatial(const float *spatialSrc, float *vec3Dst, int n, void *stream=nullptr)

Extract the linear component of each :class: wp::spatial_vector into a vec3.

bool isaacsim::physics::newton::tensors::launchFusedDofScatter(const float *src, float *dst, const int *devArtiIndices, const int *devDofMapping, int numArti, int maxDofs, void *stream=nullptr)

Fused indexed DOF scatter: writes view-scoped DOF values into a flat model DOF array.

bool isaacsim::physics::newton::tensors::launchFusedLinkAdd(const float *src, float *dst, const int *devArtiIndices, const int *devLinkMapping, int numArti, int maxLinks, int srcElemSize, int dstElemSize, int dstElemOffset, int numComponents, void *stream=nullptr)

Same as :func: launchFusedLinkScatter but performs an atomic add into dst .

bool isaacsim::physics::newton::tensors::launchFusedLinkScatter(const float *src, float *dst, const int *devArtiIndices, const int *devLinkMapping, int numArti, int maxLinks, int srcElemSize, int dstElemSize, int dstElemOffset, int numComponents, void *stream=nullptr)

Fused link scatter for articulation link properties.

bool isaacsim::physics::newton::tensors::launchFusedPairedDofScatter(const float *src, float *dstA, float *dstB, const int *devArtiIndices, const int *devDofMapping, int numArti, int maxDofs, void *stream=nullptr)

Fused indexed DOF scatter that writes the same value into two destinations.

bool isaacsim::physics::newton::tensors::launchFusedRootFlatScatter(const float *src, float *dst, const int *devArtiIndices, const int *devRootFlatMapping, int numArti, int elemSize, void *stream=nullptr)

Fused scatter for articulation root into a flat joint-qd-style layout.

bool isaacsim::physics::newton::tensors::launchFusedRootScatter(const float *src, float *dst, const int *devArtiIndices, const int *devRootMapping, int numArti, int elemSize, void *stream=nullptr)

Fused scatter for articulation root properties (transforms, velocities).

bool isaacsim::physics::newton::tensors::launchGatherCenterOfMass(const wp::vec3 *src, float *dst, const int *devIndices, int numIndices, const float *cachedOrientation, void *stream=nullptr)

Gather center-of-mass vec3 entries and pair with cached orientation quaternions.

bool isaacsim::physics::newton::tensors::launchGatherFloat(const float *src, float *dst, const int *devIndices, int numIndices, void *stream=nullptr)

Gather scalar floats by index, writing zero for -1 entries.

bool isaacsim::physics::newton::tensors::launchGatherMat33(const wp::mat33 *src, float *dst, const int *devIndices, int numIndices, void *stream=nullptr)

Gather :class: wp::mat33 entries (9 floats each, row-major).

bool isaacsim::physics::newton::tensors::launchGatherPairedFloat(const float *srcA, const float *srcB, float *dst, const int *devIndices, int numIndices, void *stream=nullptr)

Interleaved gather from two parallel source arrays.

bool isaacsim::physics::newton::tensors::launchGatherSpatialVector(const wp::spatial_vector *src, float *dst, const int *devIndices, int numIndices, void *stream=nullptr)

Gather :class: wp::spatial_vector entries (6 floats each).

bool isaacsim::physics::newton::tensors::launchGatherTransform(const wp::transform *src, float *dst, const int *devIndices, int numIndices, void *stream=nullptr)

Gather :class: wp::transform entries (7 floats each) into a packed output.

bool isaacsim::physics::newton::tensors::launchNetContactForces(const int *contactCount, const int *shape0, const int *shape1, const float *contactForce, const int *shapeBody, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, float dtScale, float *netForces, int rigidContactMax, void *stream=nullptr)

Accumulate per-sensor net contact forces.

bool isaacsim::physics::newton::tensors::launchRawContactData(const int *contactCount, const int *shape0, const int *shape1, const float *point0, const float *point1, const float *normal, const float *contactForce, const float *thickness0, const float *thickness1, const int *shapeBody, const float *bodyQ, const int *bodySensorMap, int bodySensorMapSize, int worldBodyIdx, float dtScale, int maxContactDataCount, float *outForces, float *outPoints, float *outNormals, float *outSeparations, uint32_t *outCounts, const uint32_t *startIndices, uint64_t *otherActorIds, int rigidContactMax, bool pointsInWorldSpace=false, void *stream=nullptr)

Emit raw per-sensor contact data with the "other actor" identifier.

bool isaacsim::physics::newton::tensors::launchScatterComOrientation(const float *src, float *dst, const int *devArtiIndices, int count, int elemPerSlot, int srcStride, void *stream=nullptr)

Extract orientation quaternions from a COM tensor and scatter to a flat cache.

bool isaacsim::physics::newton::tensors::launchUpdateInverseInertia(const wp::mat33 *inertia, wp::mat33 *inverseInertia, int n, void *stream=nullptr)

Compute per-element inverse inertia matrix on device.

bool isaacsim::physics::newton::tensors::launchUpdateInverseMass(const float *mass, float *inverseMass, int n, void *stream=nullptr)

Compute per-element inverse mass on device.

GpuIndexGuard isaacsim::physics::newton::tensors::resolveGpuViewIndices(const TensorDesc *indexTensor, uint32_t defaultCount, int *devScratchBuf=nullptr)

Resolves an index tensor for GPU kernel use. If the tensor is on GPU, returns its pointer directly. If on CPU and devScratchBuf is provided, performs H2D copy into the scratch buffer. If indexTensor is null, returns count = defaultCount with ptr = nullptr (signaling identity/all-elements to the kernel).

void isaacsim::physics::newton::tensors::resolveViewIndices(const TensorDesc *indexTensor, uint32_t defaultCount, std::vector< uint32_t > &out)

Resolves an index tensor into a list of uint32_t view indices. If indexTensor is null, fills out with [0, 1, …, defaultCount-1]. Writes into the caller-provided vector to avoid per-call allocation. Handles both CPU and GPU source tensors (D2H copy for GPU).

void isaacsim::physics::newton::tensors::safeCudaFree(void *p)

Safely frees a CUDA pointer, clearing any pending error state.

bool isaacsim::physics::newton::tensors::updateInverseInertia(float *inertia, float *inverseInertia, int deviceOrdinal, size_t count)

bool isaacsim::physics::newton::tensors::updateInverseMass(float *mass, float *inverseMass, int deviceOrdinal, size_t count)

Recompute inverse mass/inertia arrays from their forward counterparts. Dispatches to CPU or GPU based on deviceOrdinal (-1 = CPU, >= 0 = GPU).

bool isaacsim::physics::newton::tensors::validateCudaContext(int deviceOrdinal)

Validates that a CUDA context exists for the given device ordinal, creating one if needed.

bool isaacsim::physics::newton::tensors::validateFloat32Tensor(const TensorDesc *tensor, int expectedDevice, size_t expectedElements, const char *tensorName, const char *funcName)

Validates that a tensor is non-null, resides on the expected device, is float32, and has an exact total element count. Logs a descriptive error and returns false on any mismatch.

bool isaacsim::physics::newton::tensors::validateFloat32TensorAnyDevice(const TensorDesc *tensor, size_t expectedElements, const char *tensorName, const char *funcName)

Validates a float32 tensor's dtype and size but allows the tensor to reside on any device. Used by GPU views that internally stage CPU tensors via H2D copy (GC configuration).

bool isaacsim::physics::newton::tensors::validateOptionalIndexTensor(const TensorDesc *indexTensor, int expectedDevice, const char *funcName)

Validates an optional index tensor. If provided, it must reside on the expected device and be int32/uint32. A null/empty index tensor is accepted (identity mapping).

bool isaacsim::physics::newton::tensors::validateOptionalIndexTensorAnyDevice(const TensorDesc *indexTensor, const char *funcName)

Validates an optional index tensor's dtype (int32/uint32) but allows any device. Used by GPU views that internally stage CPU index tensors via H2D copy (GC configuration).

bool isaacsim::physics::newton::tensors::validateUint8Tensor(const TensorDesc *tensor, int expectedDevice, size_t expectedElements, const char *tensorName, const char *funcName)

Validates that a tensor is non-null, resides on the expected device, and has an exact total element count. The data type check is skipped (caller should pick the appropriate variant above when a dtype constraint applies).

wp::array_t< T > isaacsim::physics::newton::tensors::warpArrayFromPython(py::object pyArray)

Extracts a wp::array_t<T> descriptor from a Python wp.array, reading ptr, shape, strides.

void isaacsim::robot::schema::ApplyAttachmentPointAPI(pxr::UsdPrim &prim)

Apply the IsaacAttachmentPointAPI schema to a prim.

void isaacsim::robot::schema::ApplyJointAPI(pxr::UsdPrim &prim)

Apply the IsaacJointAPI schema to a prim.

void isaacsim::robot::schema::ApplyLinkAPI(pxr::UsdPrim &prim)

Apply the IsaacLinkAPI schema to a prim.

void isaacsim::robot::schema::ApplyReferencePointAPI(pxr::UsdPrim &prim)

Apply the IsaacReferencePointAPI schema to a prim.

void isaacsim::robot::schema::ApplyRobotAPI(pxr::UsdPrim &prim)

Apply the IsaacRobotAPI schema to a prim.

void isaacsim::robot::schema::ApplySiteAPI(pxr::UsdPrim &prim)

Apply the IsaacSiteAPI schema to a prim.

pxr::UsdPrim isaacsim::robot::schema::CreateSurfaceGripper(pxr::UsdStagePtr stage, const std::string &primPath)

Create a Surface Gripper prim.

std::shared_ptr< RobotLinkNode > isaacsim::robot::schema::GenerateRobotLinkTree(const pxr::UsdStagePtr &stage, const pxr::UsdPrim &robotLinkPrim)

Build a RobotLinkNode tree from a robot prim.

std::vector< pxr::UsdPrim > isaacsim::robot::schema::GetAllRobotComponents(const pxr::UsdStagePtr &stage, const pxr::UsdPrim &robotPrim)

Collect every prim in a robot's subtree that applies an Isaac robot-schema API.

std::vector< pxr::UsdPrim > isaacsim::robot::schema::GetAllRobotJoints(const pxr::UsdStagePtr &stage, const pxr::UsdPrim &robotLinkPrim, bool parseNestedRobots=true)

Gather all joint prims referenced by a robot prim.

std::vector< pxr::UsdPrim > isaacsim::robot::schema::GetAllRobotLinks(const pxr::UsdStagePtr &stage, const pxr::UsdPrim &robotLinkPrim, bool includeReferencePoints=false)

Gather all link prims referenced by a robot prim.

pxr::SdfPath isaacsim::robot::schema::GetJointBodyRelationship(const pxr::UsdPrim &jointPrim, int bodyIndex)

Obtain the path of a joint body relationship.

std::optional< pxr::GfMatrix4d > isaacsim::robot::schema::GetJointPose(const pxr::UsdPrim &robotPrim, const pxr::UsdPrim &jointPrim)

Compute a joint pose relative to the robot prim.

std::pair< std::vector< pxr::UsdPrim >, std::vector< pxr::UsdPrim > > isaacsim::robot::schema::GetLinksFromJoint(const std::shared_ptr< RobotLinkNode > &root, const pxr::UsdPrim &jointPrim)

Split links before and after a joint.

std::unordered_map< std::string, std::string > isaacsim::robot::schema::GetRobotLinkParentMap(const pxr::UsdStagePtr &stage, const pxr::UsdPrim &robotPrim)

Build a child-link to parent-link path map from an IsaacRobotAPI prim.

std::pair< pxr::UsdPrim, pxr::UsdPrim > isaacsim::robot::schema::PopulateRobotSchemaFromArticulation(const pxr::UsdStagePtr &stage, pxr::UsdPrim &robotPrim, pxr::UsdPrim articulationPrim)

Populate robot schema data from a physics articulation.

void isaacsim::robot::schema::PrintRobotTree(const std::shared_ptr< RobotLinkNode > &root, size_t indent=0)

Print the link tree to stdout.

void isaacsim::robot::schema::UpdateDeprecatedSchemas(pxr::UsdPrim &robotPrim)

Update deprecated schemas on a robot prim hierarchy.

const pxr::TfToken isaacsim::robot::schema::className(Classes name)

Get the TfToken for a schema class.

bool isaacsim::robot::schema::details::UpdateDeprecatedJointDofOrder(pxr::UsdPrim &jointPrim)

Update deprecated joint DOF order attributes.

bool isaacsim::robot::schema::details::axisHasValidLimits(const pxr::UsdPrim &jointPrim, const pxr::TfToken &axisToken)

Check if a joint axis has valid limit values.

std::vector< std::string > isaacsim::robot::schema::details::collectDeprecatedDofEntries(const pxr::UsdPrim &jointPrim)

Collect deprecated DOF entries from a joint prim.

size_t isaacsim::robot::schema::details::computeFallbackOrder(const std::string &tokenName, int orderIndex)

Compute the fallback order index for a DOF token.

bool isaacsim::robot::schema::details::isMultiAxisJoint(const pxr::UsdPrim &jointPrim)

Check if a joint prim is a multi-axis joint.

pxr::TfToken isaacsim::robot::schema::getAttributeName(Attributes attr)

Get the full attribute name token for an attribute type.

GripperStatus isaacsim::robot::surface_gripper::GripperStatusFromToken(const pxr::TfToken &token)

std::string isaacsim::robot::surface_gripper::GripperStatusToString(GripperStatus status)

pxr::TfToken isaacsim::robot::surface_gripper::GripperStatusToToken(GripperStatus status)

void isaacsim::robot::surface_gripper::parallelForIndex(size_t count, Func func)

bool isaacsim::ros2::core::isRos2DistroSupported(const std::string &distro)

Checks if a ROS 2 distribution name is valid.

const bool isaacsim::ros2::core::jsonToRos2QoSProfile(Ros2QoSProfile &qos, const std::string &jsonString)

Converts a JSON string to a ROS 2 QoS profile.

SrtxFrameCallbackDescriptor * isaacsim::ros2::nodes::createCameraInfoPublisherDescriptor(const std::string &topicName, const std::string &frameId, const std::string &nodeNamespace, uint64_t queueSize, const std::string &qosProfile, uint32_t width, uint32_t height, const std::string &distortionModel, const std::vector< double > &k, const std::vector< double > &r, const std::vector< double > &p, const std::vector< double > &d)

Create a camera info publisher callback descriptor. Returns a heap-allocated descriptor (caller owns it), or nullptr on failure.

SrtxFrameCallbackDescriptor * isaacsim::ros2::nodes::createImagePublisherDescriptor(const std::string &topicName, const std::string &frameId, const std::string &nodeNamespace, uint64_t queueSize, const std::string &qosProfile)

Create an image publisher callback descriptor. Returns a heap-allocated descriptor (caller owns it), or nullptr on failure. The descriptor's destructor will clean up the publisher when called.

SrtxFrameCallbackDescriptor * isaacsim::ros2::nodes::createLaserScanPublisherDescriptor(const std::string &topicName, const std::string &frameId, const std::string &nodeNamespace, uint64_t queueSize, const std::string &qosProfile, float azimuthRangeStart, float azimuthRangeEnd, float depthRangeMin, float depthRangeMax, float rotationRate, float horizontalResolution, float horizontalFov)

Create a laser scan publisher callback descriptor. Returns a heap-allocated descriptor (caller owns it), or nullptr on failure. The extra parameters provide scan metadata read from the lidar prim.

SrtxFrameCallbackDescriptor * isaacsim::ros2::nodes::createLidarPublisherDescriptor(const std::string &topicName, const std::string &frameId, const std::string &nodeNamespace, uint64_t queueSize, const std::string &qosProfile)

Create a lidar publisher callback descriptor. Returns a heap-allocated descriptor (caller owns it), or nullptr on failure.

void isaacsim::ros2::nodes::fillPointCloudBuffer(uint8_t *buffer, const struct float3 *pointCloudData, const std::vector< std::tuple< void *, size_t, size_t > > &orderedFields, size_t pointWidth, size_t numPoints, int maxThreadsPerBlock, int multiProcessorCount, int cudaDeviceIndex, void *stream)

CUDA kernel that interleaves XYZ point data with metadata fields into a single contiguous buffer on the device. Defined in FillPointCloudBuffer.cu (or ROS2PublishPointCloud.cu).

void isaacsim::ros2::nodes::fillPointCloudBufferHost(uint8_t *buffer, const struct float3 *pointCloudData, const std::vector< std::tuple< void *, size_t, size_t > > &orderedFields, size_t pointWidth, size_t numPoints)

Host-side version that interleaves xyz + metadata into a contiguous buffer.

bool isaacsim::ros2::omnigraph_utils::checkCondition(const void *ptr, std::string message)

Verifies that a pointer is not null and logs an error message if it is.

bool isaacsim::ros2::omnigraph_utils::createOgAttributesForFields(OgnROS2DatabaseDerivedType &db, const NodeObj &nodeObj, std::vector< DynamicMessageField > messageFields, const std::string prependStr, std::string messageType)

Creates OmniGraph attributes for message fields.

bool isaacsim::ros2::omnigraph_utils::createOgAttributesForMessage(OgnROS2DatabaseDerivedType &db, const NodeObj &nodeObj, const std::string &messagePackage, const std::string &messageSubfolder, const std::string &messageName, std::shared_ptr< Ros2Message > message, const std::string prependStr)

Creates OmniGraph attributes for a ROS 2 message.

bool isaacsim::ros2::omnigraph_utils::findMatchingAttribute(OgnROS2DatabaseDerivedType &db, const NodeObj &nodeObj, std::vector< DynamicMessageField > messageFields, const std::string prependStr)

Checks if node attributes match message fields.

T const * isaacsim::ros2::omnigraph_utils::getAttributeReadableArrayData(const NodeObj &nodeObj, const std::string &attrName, size_t &newCount)

Gets read-only data for an array attribute.

T const * isaacsim::ros2::omnigraph_utils::getAttributeReadableData(const NodeObj &nodeObj, const std::string &attrName)

Gets read-only data for a simple attribute.

T * isaacsim::ros2::omnigraph_utils::getAttributeWritableArrayData(const NodeObj &nodeObj, const std::string &attrName, size_t newCount)

Gets writable data for an array attribute with resizing.

T * isaacsim::ros2::omnigraph_utils::getAttributeWritableData(const NodeObj &nodeObj, const std::string &attrName)

Gets writable data for a simple attribute.

std::string isaacsim::ros2::omnigraph_utils::inputOutput(bool isOutput)

Returns the OmniGraph attribute prefix based on direction.

bool isaacsim::ros2::omnigraph_utils::removeDynamicAttributes(const NodeObj &nodeObj)

Removes dynamic attributes from a node.

bool isaacsim::ros2::omnigraph_utils::writeMessageDataFromNode(OmniGraphDatabase &db, std::shared_ptr< Ros2Message > message, std::string prependStr, bool isOutput)

Reads attribute data from an OmniGraph node and writes it to a ROS 2 message.

bool isaacsim::ros2::omnigraph_utils::writeNodeAttributeFromMessage(OmniGraphDatabase &db, std::shared_ptr< Ros2Message > message, std::string prependStr, bool isOutput)

Reads data from a ROS 2 message and writes it to OmniGraph node attributes.

uint64_t isaacsim::sensors::physics::asInt(const pxr::SdfPath &path)

Converts a USD path to an integer representation.

float isaacsim::sensors::physics::lerp(const float &start, const float &end, const float t)

Linear interpolation between two values.

void isaacsim::sensors::rtx::getTransformFromSensorPose(const omni::sensors::FrameAtTime &inPose, omni::math::linalg::matrix4d &matrixOutput)

Converts a sensor pose to a 4x4 transformation matrix.

UcxRequestWaitResult isaacsim::ucx::core::waitForRequestWithTimeout(std::shared_ptr< ucxx::Request > request, uint32_t timeoutMs, std::string &errorMessage, uint32_t pollIntervalUs=1000)

Wait for a UCX request to complete with timeout.

float maxf(const float a, const float b)

float minf(const float a, const float b)

bool operator!=(const Colour &lhs, const Colour &rhs)

Vec2 operator*(const Matrix22 &a, const Vec2 &x)

Matrix-vector multiplication operator.

Matrix22 operator*(const Matrix22 &a, const Matrix22 &b)

Matrix-matrix multiplication operator.

Matrix22 operator*(float s, const Matrix22 &a)

Scalar-matrix multiplication operator (scalar on left).

Matrix22 operator*(const Matrix22 &a, float s)

Matrix-scalar multiplication operator (scalar on right).

Matrix33 operator*(const Matrix33 &a, float s)

Matrix-scalar multiplication operator (scalar on right)

Vec3 operator*(const Matrix33 &a, const Vec3 &x)

Matrix-vector multiplication operator.

Matrix33 operator*(const Matrix33 &a, const Matrix33 &b)

Matrix multiplication operator.

Matrix33 operator*(float s, const Matrix33 &a)

Scalar-matrix multiplication operator (scalar on left)

XVector4< T > operator*(const XMatrix44< T > &mat, const XVector4< T > &v)

XVector3< T > operator*(const XMatrix44< T > &mat, const XVector3< T > &v)

Point3 operator*(const XMatrix44< T > &mat, const Point3 &v)

Colour operator*(float lhs, const Colour &rhs)

Point3 operator*(float lhs, const Point3 &rhs)

Scales a point by a scalar value (left-hand side scalar).

Vec3 operator*(const Quat &q, const Vec3 &v)

XQuat< T > operator*(T lhs, const XQuat< T > &rhs)

XVector2< T > operator*(T lhs, const XVector2< T > &rhs)

Scales a vector by a scalar value (left-hand side scalar).

XVector2< T > operator*(const XVector2< T > &lhs, const XVector2< T > &rhs)

Multiplies two vectors component-wise.

XVector3< T > operator*(T lhs, const XVector3< T > &rhs)

Scalar multiplication operator (left-hand side)

XVector4< T > operator*(T lhs, const XVector4< T > &rhs)

Matrix22 & operator*=(Matrix22 &a, float s)

Scalar multiplication assignment operator.

Matrix33 & operator*=(Matrix33 &a, float s)

Scalar multiplication assignment operator.

Matrix22 operator+(const Matrix22 &a, const Matrix22 &b)

Matrix addition operator.

Matrix33 operator+(const Matrix33 &a, const Matrix33 &b)

Matrix addition operator.

XMatrix< m, n, T > operator+(const XMatrix< m, n, T > &lhs, const XMatrix< m, n, T > &rhs)

Point3 operator+(const Point3 &lhs, const Point3 &rhs)

Adds two points component-wise.

Matrix22 & operator+=(Matrix22 &a, const Matrix22 &b)

Matrix addition assignment operator.

Matrix33 & operator+=(Matrix33 &a, const Matrix33 &b)

Matrix addition assignment operator.

Matrix22 operator-(const Matrix22 &a, const Matrix22 &b)

Matrix subtraction operator.

Matrix33 operator-(const Matrix33 &a, const Matrix33 &b)

Matrix subtraction operator.

XMatrix< m, n, T > operator-(const XMatrix< m, n, T > &lhs, const XMatrix< m, n, T > &rhs)

Vec3 operator-(const Point3 &lhs, const Point3 &rhs)

Computes the vector from one point to another.

Matrix22 & operator-=(Matrix22 &a, const Matrix22 &b)

Matrix subtraction assignment operator.

Matrix33 & operator-=(Matrix33 &a, const Matrix33 &b)

Matrix subtraction assignment operator.

bool operator==(const Colour &lhs, const Colour &rhs)

bool operator==(const Point3 &lhs, const Point3 &rhs)

Tests for equality between two points.

bool operator==(const XQuat< T > &lhs, const XQuat< T > &rhs)

bool operator==(const XVector2< T > &lhs, const XVector2< T > &rhs)

Tests for equality between two vectors.

bool operator==(const XVector3< T > &lhs, const XVector3< T > &rhs)

Equality comparison operator for vectors.

bool operator==(const XVector4< T > &lhs, const XVector4< T > &rhs)

void quat2Mat(const XQuat< float > &q, Matrix33 &m)

Converts a quaternion to a 3x3 rotation matrix.

void quat2rpy(const Quat &q1, float &bank, float &attitude, float &heading)

Quat quaternionFromVectors(const Vec3 &vec1, const Vec3 &vec2)

Vec3 rotate(const Vec3 &q, float w, const Vec3 &x)

Vec3 rotateInv(const Vec3 &q, float w, const Vec3 &x)

Quat rpy2quat(const float roll, const float pitch, const float yaw)

float sign(float x)

void zUpQuat2rpy(const Quat &q1, float &roll, float &pitch, float &yaw)