| 
      abs
     | 
    
      Absolute value of an integer
     | 
  
  
    | 
      acos
     | 
    
      Inverse cosine
     | 
  
  
    | 
      acosh
     | 
    
      Inverse hyperbolic cosine
     | 
  
  
    | 
      acospi
     | 
    
      Inverse cosine divided by pi
     | 
  
  
    | 
      asin
     | 
    
      Inverse sine
     | 
  
  
    | 
      asinh
     | 
    
      Inverse hyperbolic sine
     | 
  
  
    | 
      asinpi
     | 
    
      Inverse sine divided by pi
     | 
  
  
    | 
      atan
     | 
    
      Inverse tangent
     | 
  
  
    | 
      atan2
     | 
    
      Inverse tangent of a ratio
     | 
  
  
    | 
      atan2pi
     | 
    
      Inverse tangent of a ratio, divided by pi
     | 
  
  
    | 
      atanh
     | 
    
      Inverse hyperbolic tangent
     | 
  
  
    | 
      atanpi
     | 
    
      Inverse tangent divided by pi
     | 
  
  
    | 
      cbrt
     | 
    
      Cube root
     | 
  
  
    | 
      ceil
     | 
    
      Smallest integer not less than a value
     | 
  
  
    | 
      clamp
     | 
    
      Restrain a value to a range
     | 
  
  
    | 
      clz
     | 
    
      Number of leading 0 bits
     | 
  
  
    | 
      convert
     | 
    
      Convert numerical vectors
     | 
  
  
    | 
      copysign
     | 
    
      Copies the sign of a number to another
     | 
  
  
    | 
      cos
     | 
    
      Cosine
     | 
  
  
    | 
      cosh
     | 
    
      Hypebolic cosine
     | 
  
  
    | 
      cospi
     | 
    
      Cosine of a number multiplied by pi
     | 
  
  
    | 
      cross
     | 
    
      Cross product of two vectors
     | 
  
  
    | 
      degrees
     | 
    
      Converts radians into degrees
     | 
  
  
    | 
      distance
     | 
    
      Distance between two points
     | 
  
  
    | 
      dot
     | 
    
      Dot product of two vectors
     | 
  
  
    | 
      erf
     | 
    
      Mathematical error function
     | 
  
  
    | 
      erfc
     | 
    
      Mathematical complementary error function
     | 
  
  
    | 
      exp
     | 
    
      e raised to a number
     | 
  
  
    | 
      exp10
     | 
    
      10 raised to a number
     | 
  
  
    | 
      exp2
     | 
    
      2 raised to a number
     | 
  
  
    | 
      expm1
     | 
    
      e raised to a number minus one
     | 
  
  
    | 
      fabs
     | 
    
      Absolute value of a float
     | 
  
  
    | 
      fast_distance
     | 
    
      Approximate distance between two points
     | 
  
  
    | 
      fast_length
     | 
    
      Approximate length of a vector
     | 
  
  
    | 
      fast_normalize
     | 
    
      Approximate normalized vector
     | 
  
  
    | 
      fdim
     | 
    
      Positive difference between two values
     | 
  
  
    | 
      floor
     | 
    
      Smallest integer not greater than a value
     | 
  
  
    | 
      fma
     | 
    
      Multiply and add
     | 
  
  
    | 
      fmax
     | 
    
      Maximum of two floats
     | 
  
  
    | 
      fmin
     | 
    
      Minimum of two floats
     | 
  
  
    | 
      fmod
     | 
    
      Modulo
     | 
  
  
    | 
      fract
     | 
    
      Positive fractional part
     | 
  
  
    | 
      frexp
     | 
    
      Binary mantissa and exponent
     | 
  
  
    | 
      half_recip
     | 
    
      Reciprocal computed to 16 bit precision
     | 
  
  
    | 
      half_rsqrt
     | 
    
      Reciprocal of a square root computed to 16 bit precision
     | 
  
  
    | 
      half_sqrt
     | 
    
      Square root computed to 16 bit precision
     | 
  
  
    | 
      hypot
     | 
    
      Hypotenuse
     | 
  
  
    | 
      ilogb
     | 
    
      Base two exponent
     | 
  
  
    | 
      ldexp
     | 
    
      Creates a floating point from mantissa and exponent
     | 
  
  
    | 
      length
     | 
    
      Length of a vector
     | 
  
  
    | 
      lgamma
     | 
    
      Natural logarithm of the gamma function
     | 
  
  
    | 
      log
     | 
    
      Natural logarithm
     | 
  
  
    | 
      log10
     | 
    
      Base 10 logarithm
     | 
  
  
    | 
      log1p
     | 
    
      Natural logarithm of a value plus 1
     | 
  
  
    | 
      log2
     | 
    
      Base 2 logarithm
     | 
  
  
    | 
      logb
     | 
    
      Base two exponent
     | 
  
  
    | 
      mad
     | 
    
      Multiply and add
     | 
  
  
    | 
      max
     | 
    
      Maximum
     | 
  
  
    | 
      min
     | 
    
      Minimum
     | 
  
  
    | 
      mix
     | 
    
      Mixes two values
     | 
  
  
    | 
      modf
     | 
    
      Integral and fractional components
     | 
  
  
    | 
      nan
     | 
    
      Not a Number
     | 
  
  
    | 
      nan_half
     | 
    
      Not a Number
     | 
  
  
    | 
      native_acos
     | 
    
      Approximate inverse cosine
     | 
  
  
    | 
      native_acosh
     | 
    
      Approximate inverse hyperbolic cosine
     | 
  
  
    | 
      native_acospi
     | 
    
      Approximate inverse cosine divided by pi
     | 
  
  
    | 
      native_asin
     | 
    
      Approximate inverse sine
     | 
  
  
    | 
      native_asinh
     | 
    
      Approximate inverse hyperbolic sine
     | 
  
  
    | 
      native_asinpi
     | 
    
      Approximate inverse sine divided by pi
     | 
  
  
    | 
      native_atan
     | 
    
      Approximate inverse tangent
     | 
  
  
    | 
      native_atan2
     | 
    
      Approximate inverse tangent of a ratio
     | 
  
  
    | 
      native_atan2pi
     | 
    
      Approximate inverse tangent of a ratio, divided by pi
     | 
  
  
    | 
      native_atanh
     | 
    
      Approximate inverse hyperbolic tangent
     | 
  
  
    | 
      native_atanpi
     | 
    
      Approximate inverse tangent divided by pi
     | 
  
  
    | 
      native_cbrt
     | 
    
      Approximate cube root
     | 
  
  
    | 
      native_cos
     | 
    
      Approximate cosine
     | 
  
  
    | 
      native_cosh
     | 
    
      Approximate hypebolic cosine
     | 
  
  
    | 
      native_cospi
     | 
    
      Approximate cosine of a number multiplied by pi
     | 
  
  
    | 
      native_distance
     | 
    
      Approximate distance between two points
     | 
  
  
    | 
      native_divide
     | 
    
      Approximate division
     | 
  
  
    | 
      native_exp
     | 
    
      Approximate e raised to a number
     | 
  
  
    | 
      native_exp10
     | 
    
      Approximate 10 raised to a number
     | 
  
  
    | 
      native_exp2
     | 
    
      Approximate 2 raised to a number
     | 
  
  
    | 
      native_expm1
     | 
    
      Approximate e raised to a number minus one
     | 
  
  
    | 
      native_hypot
     | 
    
      Approximate hypotenuse
     | 
  
  
    | 
      native_length
     | 
    
      Approximate length of a vector
     | 
  
  
    | 
      native_log
     | 
    
      Approximate natural logarithm
     | 
  
  
    | 
      native_log10
     | 
    
      Approximate base 10 logarithm
     | 
  
  
    | 
      native_log1p
     | 
    
      Approximate natural logarithm of a value plus 1
     | 
  
  
    | 
      native_log2
     | 
    
      Approximate base 2 logarithm
     | 
  
  
    | 
      native_normalize
     | 
    
      Approximately normalize a vector
     | 
  
  
    | 
      native_powr
     | 
    
      Approximate positive base raised to an exponent
     | 
  
  
    | 
      native_recip
     | 
    
      Approximate reciprocal
     | 
  
  
    | 
      native_rootn
     | 
    
      Approximate nth root
     | 
  
  
    | 
      native_rsqrt
     | 
    
      Approximate reciprocal of a square root
     | 
  
  
    | 
      native_sin
     | 
    
      Approximate sine
     | 
  
  
    | 
      native_sincos
     | 
    
      Approximate sine and cosine
     | 
  
  
    | 
      native_sinh
     | 
    
      Approximate hyperbolic sine
     | 
  
  
    | 
      native_sinpi
     | 
    
      Approximate sine of a number multiplied by pi
     | 
  
  
    | 
      native_sqrt
     | 
    
      Approximate square root
     | 
  
  
    | 
      native_tan
     | 
    
      Approximate tangent
     | 
  
  
    | 
      native_tanh
     | 
    
      Approximate hyperbolic tangent
     | 
  
  
    | 
      native_tanpi
     | 
    
      Approximate tangent of a number multiplied by pi
     | 
  
  
    | 
      nextafter
     | 
    
      Next floating point number
     | 
  
  
    | 
      normalize
     | 
    
      Normalize a vector
     | 
  
  
    | 
      pow
     | 
    
      Base raised to an exponent
     | 
  
  
    | 
      pown
     | 
    
      Base raised to an integer exponent
     | 
  
  
    | 
      powr
     | 
    
      Positive base raised to an exponent
     | 
  
  
    | 
      radians
     | 
    
      Converts degrees into radians
     | 
  
  
    | 
      remainder
     | 
    
      Remainder of a division
     | 
  
  
    | 
      remquo
     | 
    
      Remainder and quotient of a division
     | 
  
  
    | 
      rint
     | 
    
      Round to even
     | 
  
  
    | 
      rootn
     | 
    
      Nth root
     | 
  
  
    | 
      round
     | 
    
      Round away from zero
     | 
  
  
    | 
      rsAllocationCopy1DRange
     | 
    
      Copy consecutive cells between allocations
     | 
  
  
    | 
      rsAllocationCopy2DRange
     | 
    
      Copy a rectangular region of cells between allocations
     | 
  
  
    | 
      rsAllocationGetDimFaces
     | 
    
      Presence of more than one face
     | 
  
  
    | 
      rsAllocationGetDimLOD
     | 
    
      Presence of levels of detail
     | 
  
  
    | 
      rsAllocationGetDimX
     | 
    
      Size of the X dimension
     | 
  
  
    | 
      rsAllocationGetDimY
     | 
    
      Size of the Y dimension
     | 
  
  
    | 
      rsAllocationGetDimZ
     | 
    
      Size of the Z dimension
     | 
  
  
    | 
      rsAllocationGetElement
     | 
    
      Get the object that describes the cell of an Allocation
     | 
  
  
    | 
      rsAllocationIoReceive
     | 
    
      Receive new content from the queue
     | 
  
  
    | 
      rsAllocationIoSend
     | 
    
      Send new content to the queue
     | 
  
  
    | 
      rsAllocationVLoadX
     | 
    
      Get a vector from an allocation of scalars
     | 
  
  
    | 
      rsAllocationVStoreX
     | 
    
      Store a vector into an allocation of scalars
     | 
  
  
    | 
      rsAtomicAdd
     | 
    
      Thread-safe addition
     | 
  
  
    | 
      rsAtomicAnd
     | 
    
      Thread-safe bitwise and
     | 
  
  
    | 
      rsAtomicCas
     | 
    
      Thread-safe compare and set
     | 
  
  
    | 
      rsAtomicDec
     | 
    
      Thread-safe decrement
     | 
  
  
    | 
      rsAtomicInc
     | 
    
      Thread-safe increment
     | 
  
  
    | 
      rsAtomicMax
     | 
    
      Thread-safe maximum
     | 
  
  
    | 
      rsAtomicMin
     | 
    
      Thread-safe minimum
     | 
  
  
    | 
      rsAtomicOr
     | 
    
      Thread-safe bitwise or
     | 
  
  
    | 
      rsAtomicSub
     | 
    
      Thread-safe subtraction
     | 
  
  
    | 
      rsAtomicXor
     | 
    
      Thread-safe bitwise exclusive or
     | 
  
  
    | 
      rsClearObject
     | 
    
      Release an object
     | 
  
  
    | 
      rsCreateAllocation
     | 
    
      Create an rs_allocation object of given Type.
     | 
  
  
    | 
      rsCreateElement
     | 
    
      Creates an rs_element object of the specified data type
     | 
  
  
    | 
      rsCreatePixelElement
     | 
    
      Creates an rs_element object of the specified data type and data kind
     | 
  
  
    | 
      rsCreateType
     | 
    
      Creates an rs_type object with the specified Element and shape attributes
     | 
  
  
    | 
      rsCreateVectorElement
     | 
    
      Creates an rs_element object of the specified data type and vector width
     | 
  
  
    | 
      rsDebug
     | 
    
      Log a message and values
     | 
  
  
    | 
      rsElementGetBytesSize
     | 
    
      Size of an Element
     | 
  
  
    | 
      rsElementGetDataKind
     | 
    
      Kind of an Element
     | 
  
  
    | 
      rsElementGetDataType
     | 
    
      Data type of an Element
     | 
  
  
    | 
      rsElementGetSubElement
     | 
    
      Sub-element of a complex Element
     | 
  
  
    | 
      rsElementGetSubElementArraySize
     | 
    
      Array size of a sub-element of a complex Element
     | 
  
  
    | 
      rsElementGetSubElementCount
     | 
    
      Number of sub-elements
     | 
  
  
    | 
      rsElementGetSubElementName
     | 
    
      Name of a sub-element
     | 
  
  
    | 
      rsElementGetSubElementNameLength
     | 
    
      Length of the name of a sub-element
     | 
  
  
    | 
      rsElementGetSubElementOffsetBytes
     | 
    
      Offset of the instantiated sub-element
     | 
  
  
    | 
      rsElementGetVectorSize
     | 
    
      Vector size of the Element
     | 
  
  
    | 
      rsExtractFrustumPlanes
     | 
    
      Compute frustum planes
     | 
  
  
    | 
      rsForEach
     | 
    
      Launches a kernel
     | 
  
  
    | 
      rsForEachInternal
     | 
    
      (Internal API) Launch a kernel in the current Script (with the slot number)
     | 
  
  
    | 
      rsForEachWithOptions
     | 
    
      Launches a kernel with options
     | 
  
  
    | 
      rsGetArray0
     | 
    
      Index in the Array0 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetArray1
     | 
    
      Index in the Array1 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetArray2
     | 
    
      Index in the Array2 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetArray3
     | 
    
      Index in the Array3 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimArray0
     | 
    
      Size of the Array0 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimArray1
     | 
    
      Size of the Array1 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimArray2
     | 
    
      Size of the Array2 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimArray3
     | 
    
      Size of the Array3 dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimHasFaces
     | 
    
      Presence of more than one face for the specified kernel context
     | 
  
  
    | 
      rsGetDimLod
     | 
    
      Number of levels of detail for the specified kernel context
     | 
  
  
    | 
      rsGetDimX
     | 
    
      Size of the X dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimY
     | 
    
      Size of the Y dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDimZ
     | 
    
      Size of the Z dimension for the specified kernel context
     | 
  
  
    | 
      rsGetDt
     | 
    
      Elapsed time since last call
     | 
  
  
    | 
      rsGetElementAt
     | 
    
      Return a cell from an allocation
     | 
  
  
    | 
      rsGetElementAtYuv_uchar_U
     | 
    
      Get the U component of an allocation of YUVs
     | 
  
  
    | 
      rsGetElementAtYuv_uchar_V
     | 
    
      Get the V component of an allocation of YUVs
     | 
  
  
    | 
      rsGetElementAtYuv_uchar_Y
     | 
    
      Get the Y component of an allocation of YUVs
     | 
  
  
    | 
      rsGetFace
     | 
    
      Coordinate of the Face for the specified kernel context
     | 
  
  
    | 
      rsGetLod
     | 
    
      Index in the Levels of Detail dimension for the specified kernel context
     | 
  
  
    | 
      rsIsObject
     | 
    
      Check for an empty handle
     | 
  
  
    | 
      rsIsSphereInFrustum
     | 
    
      Checks if a sphere is within the frustum planes
     | 
  
  
    | 
      rsLocaltime
     | 
    
      Convert to local time
     | 
  
  
    | 
      rsMatrixGet
     | 
    
      Get one element
     | 
  
  
    | 
      rsMatrixInverse
     | 
    
      Inverts a matrix in place
     | 
  
  
    | 
      rsMatrixInverseTranspose
     | 
    
      Inverts and transpose a matrix in place
     | 
  
  
    | 
      rsMatrixLoad
     | 
    
      Load or copy a matrix
     | 
  
  
    | 
      rsMatrixLoadFrustum
     | 
    
      Load a frustum projection matrix
     | 
  
  
    | 
      rsMatrixLoadIdentity
     | 
    
      Load identity matrix
     | 
  
  
    | 
      rsMatrixLoadMultiply
     | 
    
      Multiply two matrices
     | 
  
  
    | 
      rsMatrixLoadOrtho
     | 
    
      Load an orthographic projection matrix
     | 
  
  
    | 
      rsMatrixLoadPerspective
     | 
    
      Load a perspective projection matrix
     | 
  
  
    | 
      rsMatrixLoadRotate
     | 
    
      Load a rotation matrix
     | 
  
  
    | 
      rsMatrixLoadScale
     | 
    
      Load a scaling matrix
     | 
  
  
    | 
      rsMatrixLoadTranslate
     | 
    
      Load a translation matrix
     | 
  
  
    | 
      rsMatrixMultiply
     | 
    
      Multiply a matrix by a vector or another matrix
     | 
  
  
    | 
      rsMatrixRotate
     | 
    
      Apply a rotation to a transformation matrix
     | 
  
  
    | 
      rsMatrixScale
     | 
    
      Apply a scaling to a transformation matrix
     | 
  
  
    | 
      rsMatrixSet
     | 
    
      Set one element
     | 
  
  
    | 
      rsMatrixTranslate
     | 
    
      Apply a translation to a transformation matrix
     | 
  
  
    | 
      rsMatrixTranspose
     | 
    
      Transpose a matrix place
     | 
  
  
    | 
      rsPackColorTo8888
     | 
    
      Create a uchar4 RGBA from floats
     | 
  
  
    | 
      rsQuaternionAdd
     | 
    
      Add two quaternions
     | 
  
  
    | 
      rsQuaternionConjugate
     | 
    
      Conjugate a quaternion
     | 
  
  
    | 
      rsQuaternionDot
     | 
    
      Dot product of two quaternions
     | 
  
  
    | 
      rsQuaternionGetMatrixUnit
     | 
    
      Get a rotation matrix from a quaternion
     | 
  
  
    | 
      rsQuaternionLoadRotate
     | 
    
      Create a rotation quaternion
     | 
  
  
    | 
      rsQuaternionLoadRotateUnit
     | 
    
      Quaternion that represents a rotation about an arbitrary unit vector
     | 
  
  
    | 
      rsQuaternionMultiply
     | 
    
      Multiply a quaternion by a scalar or another quaternion
     | 
  
  
    | 
      rsQuaternionNormalize
     | 
    
      Normalize a quaternion
     | 
  
  
    | 
      rsQuaternionSet
     | 
    
      Create a quaternion
     | 
  
  
    | 
      rsQuaternionSlerp
     | 
    
      Spherical linear interpolation between two quaternions
     | 
  
  
    | 
      rsRand
     | 
    
      Pseudo-random number
     | 
  
  
    | 
      rsSample
     | 
    
      Sample a value from a texture allocation
     | 
  
  
    | 
      rsSamplerGetAnisotropy
     | 
    
      Anisotropy of the Sampler
     | 
  
  
    | 
      rsSamplerGetMagnification
     | 
    
      Sampler magnification value
     | 
  
  
    | 
      rsSamplerGetMinification
     | 
    
      Sampler minification value
     | 
  
  
    | 
      rsSamplerGetWrapS
     | 
    
      Sampler wrap S value
     | 
  
  
    | 
      rsSamplerGetWrapT
     | 
    
      Sampler wrap T value
     | 
  
  
    | 
      rsSendToClient
     | 
    
      Send a message to the client, non-blocking
     | 
  
  
    | 
      rsSendToClientBlocking
     | 
    
      Send a message to the client, blocking
     | 
  
  
    | 
      rsSetElementAt
     | 
    
      Set a cell of an allocation
     | 
  
  
    | 
      rsTime
     | 
    
      Seconds since January 1, 1970
     | 
  
  
    | 
      rsUnpackColor8888
     | 
    
      Create a float4 RGBA from uchar4
     | 
  
  
    | 
      rsUptimeMillis
     | 
    
      System uptime in milliseconds
     | 
  
  
    | 
      rsUptimeNanos
     | 
    
      System uptime in nanoseconds
     | 
  
  
    | 
      rsYuvToRGBA
     | 
    
      Convert a YUV value to RGBA
     | 
  
  
    | 
      rsqrt
     | 
    
      Reciprocal of a square root
     | 
  
  
    | 
      sign
     | 
    
      Sign of a value
     | 
  
  
    | 
      sin
     | 
    
      Sine
     | 
  
  
    | 
      sincos
     | 
    
      Sine and cosine
     | 
  
  
    | 
      sinh
     | 
    
      Hyperbolic sine
     | 
  
  
    | 
      sinpi
     | 
    
      Sine of a number multiplied by pi
     | 
  
  
    | 
      sqrt
     | 
    
      Square root
     | 
  
  
    | 
      step
     | 
    
      0 if less than a value, 0 otherwise
     | 
  
  
    | 
      tan
     | 
    
      Tangent
     | 
  
  
    | 
      tanh
     | 
    
      Hyperbolic tangent
     | 
  
  
    | 
      tanpi
     | 
    
      Tangent of a number multiplied by pi
     | 
  
  
    | 
      tgamma
     | 
    
      Gamma function
     | 
  
  
    | 
      trunc
     | 
    
      Truncates a floating point
     |