optix_types.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2021 NVIDIA Corporation.  All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property and proprietary
 * rights in and to this software, related documentation and any modifications thereto.
 * Any use, reproduction, disclosure or distribution of this software and related
 * documentation without an express license agreement from NVIDIA Corporation is strictly
 * prohibited.
 *
 * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS*
 * AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS OR IMPLIED,
 * INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY
 * SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT
 * LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF
 * BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
 * INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGES
 */
 
 
#ifndef OPTIX_OPTIX_TYPES_H
#define OPTIX_OPTIX_TYPES_H
 
#if !defined(__CUDACC_RTC__)
#include <stddef.h> /* for size_t */
#endif
 
#ifdef NV_MODULE_OPTIX
// This is a mechanism to include <g_nvconfig.h> in driver builds only and translate any nvconfig macro to a custom OPTIX-specific macro, that can also be used in SDK builds/installs
#include <exp/misc/optix_nvconfig_translate.h>  // includes <g_nvconfig.h>
#endif  // NV_MODULE_OPTIX
 
 
 
// This typedef should match the one in cuda.h in order to avoid compilation errors.
#if defined(_WIN64) || defined(__LP64__)
typedef unsigned long long CUdeviceptr;
#else
typedef unsigned int CUdeviceptr;
#endif
 
typedef struct OptixDeviceContext_t* OptixDeviceContext;
 
typedef struct OptixModule_t* OptixModule;
 
typedef struct OptixProgramGroup_t* OptixProgramGroup;
 
typedef struct OptixPipeline_t* OptixPipeline;
 
typedef struct OptixDenoiser_t* OptixDenoiser;
 
typedef struct OptixTask_t* OptixTask;
 
typedef unsigned long long OptixTraversableHandle;
 
typedef unsigned int OptixVisibilityMask;
 
#define OPTIX_SBT_RECORD_HEADER_SIZE ( (size_t)32 )
 
#define OPTIX_SBT_RECORD_ALIGNMENT 16ull
 
#define OPTIX_ACCEL_BUFFER_BYTE_ALIGNMENT 128ull
 
#define OPTIX_INSTANCE_BYTE_ALIGNMENT 16ull
 
#define OPTIX_AABB_BUFFER_BYTE_ALIGNMENT 8ull
 
#define OPTIX_GEOMETRY_TRANSFORM_BYTE_ALIGNMENT 16ull
 
#define OPTIX_TRANSFORM_BYTE_ALIGNMENT 64ull
 
#define OPTIX_OPACITY_MICROMAP_DESC_BUFFER_BYTE_ALIGNMENT 8ull
 
#define OPTIX_COMPILE_DEFAULT_MAX_REGISTER_COUNT 0
 
#define OPTIX_COMPILE_DEFAULT_MAX_PAYLOAD_TYPE_COUNT 8
 
#define OPTIX_COMPILE_DEFAULT_MAX_PAYLOAD_VALUE_COUNT 32
 
#define OPTIX_OPACITY_MICROMAP_STATE_TRANSPARENT          ( 0 )
#define OPTIX_OPACITY_MICROMAP_STATE_OPAQUE               ( 1 )
#define OPTIX_OPACITY_MICROMAP_STATE_UNKNOWN_TRANSPARENT  ( 2 )
#define OPTIX_OPACITY_MICROMAP_STATE_UNKNOWN_OPAQUE       ( 3 )
 
#define OPTIX_OPACITY_MICROMAP_PREDEFINED_INDEX_FULLY_TRANSPARENT          ( -1 )
#define OPTIX_OPACITY_MICROMAP_PREDEFINED_INDEX_FULLY_OPAQUE               ( -2 )
#define OPTIX_OPACITY_MICROMAP_PREDEFINED_INDEX_FULLY_UNKNOWN_TRANSPARENT  ( -3 )
#define OPTIX_OPACITY_MICROMAP_PREDEFINED_INDEX_FULLY_UNKNOWN_OPAQUE       ( -4 )
 
#define OPTIX_OPACITY_MICROMAP_ARRAY_BUFFER_BYTE_ALIGNMENT 128ull
 
#define OPTIX_OPACITY_MICROMAP_MAX_SUBDIVISION_LEVEL 12
 
#define OPTIX_DISPLACEMENT_MICROMAP_MAX_SUBDIVISION_LEVEL 5
 
#define OPTIX_DISPLACEMENT_MICROMAP_DESC_BUFFER_BYTE_ALIGNMENT 8ull
 
#define OPTIX_DISPLACEMENT_MICROMAP_ARRAY_BUFFER_BYTE_ALIGNMENT 128ull
 
typedef enum OptixResult
{
    OPTIX_SUCCESS                               = 0,
    OPTIX_ERROR_INVALID_VALUE                   = 7001,
    OPTIX_ERROR_HOST_OUT_OF_MEMORY              = 7002,
    OPTIX_ERROR_INVALID_OPERATION               = 7003,
    OPTIX_ERROR_FILE_IO_ERROR                   = 7004,
    OPTIX_ERROR_INVALID_FILE_FORMAT             = 7005,
    OPTIX_ERROR_DISK_CACHE_INVALID_PATH         = 7010,
    OPTIX_ERROR_DISK_CACHE_PERMISSION_ERROR     = 7011,
    OPTIX_ERROR_DISK_CACHE_DATABASE_ERROR       = 7012,
    OPTIX_ERROR_DISK_CACHE_INVALID_DATA         = 7013,
    OPTIX_ERROR_LAUNCH_FAILURE                  = 7050,
    OPTIX_ERROR_INVALID_DEVICE_CONTEXT          = 7051,
    OPTIX_ERROR_CUDA_NOT_INITIALIZED            = 7052,
    OPTIX_ERROR_VALIDATION_FAILURE              = 7053,
    OPTIX_ERROR_INVALID_INPUT                   = 7200,
    OPTIX_ERROR_INVALID_LAUNCH_PARAMETER        = 7201,
    OPTIX_ERROR_INVALID_PAYLOAD_ACCESS          = 7202,
    OPTIX_ERROR_INVALID_ATTRIBUTE_ACCESS        = 7203,
    OPTIX_ERROR_INVALID_FUNCTION_USE            = 7204,
    OPTIX_ERROR_INVALID_FUNCTION_ARGUMENTS      = 7205,
    OPTIX_ERROR_PIPELINE_OUT_OF_CONSTANT_MEMORY = 7250,
    OPTIX_ERROR_PIPELINE_LINK_ERROR             = 7251,
    OPTIX_ERROR_ILLEGAL_DURING_TASK_EXECUTE     = 7270,
    OPTIX_ERROR_INTERNAL_COMPILER_ERROR         = 7299,
    OPTIX_ERROR_DENOISER_MODEL_NOT_SET          = 7300,
    OPTIX_ERROR_DENOISER_NOT_INITIALIZED        = 7301,
    OPTIX_ERROR_NOT_COMPATIBLE                  = 7400,
    OPTIX_ERROR_PAYLOAD_TYPE_MISMATCH           = 7500,
    OPTIX_ERROR_PAYLOAD_TYPE_RESOLUTION_FAILED  = 7501,
    OPTIX_ERROR_PAYLOAD_TYPE_ID_INVALID         = 7502,
    OPTIX_ERROR_NOT_SUPPORTED                   = 7800,
    OPTIX_ERROR_UNSUPPORTED_ABI_VERSION         = 7801,
    OPTIX_ERROR_FUNCTION_TABLE_SIZE_MISMATCH    = 7802,
    OPTIX_ERROR_INVALID_ENTRY_FUNCTION_OPTIONS  = 7803,
    OPTIX_ERROR_LIBRARY_NOT_FOUND               = 7804,
    OPTIX_ERROR_ENTRY_SYMBOL_NOT_FOUND          = 7805,
    OPTIX_ERROR_LIBRARY_UNLOAD_FAILURE          = 7806,
    OPTIX_ERROR_DEVICE_OUT_OF_MEMORY            = 7807,
    OPTIX_ERROR_CUDA_ERROR                      = 7900,
    OPTIX_ERROR_INTERNAL_ERROR                  = 7990,
    OPTIX_ERROR_UNKNOWN                         = 7999,
} OptixResult;
 
typedef enum OptixDeviceProperty
{
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_TRACE_DEPTH = 0x2001,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_TRAVERSABLE_GRAPH_DEPTH = 0x2002,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_PRIMITIVES_PER_GAS = 0x2003,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_INSTANCES_PER_IAS = 0x2004,
 
    OPTIX_DEVICE_PROPERTY_RTCORE_VERSION = 0x2005,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_INSTANCE_ID = 0x2006,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_NUM_BITS_INSTANCE_VISIBILITY_MASK = 0x2007,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_SBT_RECORDS_PER_GAS = 0x2008,
 
    OPTIX_DEVICE_PROPERTY_LIMIT_MAX_SBT_OFFSET = 0x2009,
} OptixDeviceProperty;
 
typedef void ( *OptixLogCallback )( unsigned int level, const char* tag, const char* message, void* cbdata );
 
typedef enum OptixDeviceContextValidationMode
{
    OPTIX_DEVICE_CONTEXT_VALIDATION_MODE_OFF = 0,
    OPTIX_DEVICE_CONTEXT_VALIDATION_MODE_ALL = 0xFFFFFFFF
} OptixDeviceContextValidationMode;
 
typedef struct OptixDeviceContextOptions
{
    OptixLogCallback logCallbackFunction;
    void* logCallbackData;
    int logCallbackLevel;
    OptixDeviceContextValidationMode validationMode;
} OptixDeviceContextOptions;
 
typedef enum OptixGeometryFlags
{
    OPTIX_GEOMETRY_FLAG_NONE = 0,
 
    OPTIX_GEOMETRY_FLAG_DISABLE_ANYHIT = 1u << 0,
 
    OPTIX_GEOMETRY_FLAG_REQUIRE_SINGLE_ANYHIT_CALL = 1u << 1,
 
    OPTIX_GEOMETRY_FLAG_DISABLE_TRIANGLE_FACE_CULLING = 1u << 2,
} OptixGeometryFlags;
 
typedef enum OptixHitKind
{
    OPTIX_HIT_KIND_TRIANGLE_FRONT_FACE = 0xFE,
    OPTIX_HIT_KIND_TRIANGLE_BACK_FACE = 0xFF
} OptixHitKind;
 
typedef enum OptixIndicesFormat
{
    OPTIX_INDICES_FORMAT_NONE = 0,
    OPTIX_INDICES_FORMAT_UNSIGNED_SHORT3 = 0x2102,
    OPTIX_INDICES_FORMAT_UNSIGNED_INT3 = 0x2103
} OptixIndicesFormat;
 
typedef enum OptixVertexFormat
{
    OPTIX_VERTEX_FORMAT_NONE      = 0,       
    OPTIX_VERTEX_FORMAT_FLOAT3    = 0x2121,  
    OPTIX_VERTEX_FORMAT_FLOAT2    = 0x2122,  
    OPTIX_VERTEX_FORMAT_HALF3     = 0x2123,  
    OPTIX_VERTEX_FORMAT_HALF2     = 0x2124,  
    OPTIX_VERTEX_FORMAT_SNORM16_3 = 0x2125,
    OPTIX_VERTEX_FORMAT_SNORM16_2 = 0x2126
} OptixVertexFormat;
 
typedef enum OptixTransformFormat
{
    OPTIX_TRANSFORM_FORMAT_NONE           = 0,       
    OPTIX_TRANSFORM_FORMAT_MATRIX_FLOAT12 = 0x21E1,  
} OptixTransformFormat;
 
typedef enum OptixDisplacementMicromapBiasAndScaleFormat
{
    OPTIX_DISPLACEMENT_MICROMAP_BIAS_AND_SCALE_FORMAT_NONE   = 0,
    OPTIX_DISPLACEMENT_MICROMAP_BIAS_AND_SCALE_FORMAT_FLOAT2 = 0x2241,
    OPTIX_DISPLACEMENT_MICROMAP_BIAS_AND_SCALE_FORMAT_HALF2  = 0x2242,
} OptixDisplacementMicromapBiasAndScaleFormat;
 
typedef enum OptixDisplacementMicromapDirectionFormat
{
    OPTIX_DISPLACEMENT_MICROMAP_DIRECTION_FORMAT_NONE   = 0,
    OPTIX_DISPLACEMENT_MICROMAP_DIRECTION_FORMAT_FLOAT3 = 0x2261,
    OPTIX_DISPLACEMENT_MICROMAP_DIRECTION_FORMAT_HALF3  = 0x2262,
} OptixDisplacementMicromapDirectionFormat;
 
typedef enum OptixOpacityMicromapFormat
{
    OPTIX_OPACITY_MICROMAP_FORMAT_NONE = 0,
    OPTIX_OPACITY_MICROMAP_FORMAT_2_STATE = 1,
    OPTIX_OPACITY_MICROMAP_FORMAT_4_STATE = 2,
} OptixOpacityMicromapFormat;
 
typedef enum OptixOpacityMicromapArrayIndexingMode
{
    OPTIX_OPACITY_MICROMAP_ARRAY_INDEXING_MODE_NONE = 0,
    OPTIX_OPACITY_MICROMAP_ARRAY_INDEXING_MODE_LINEAR = 1,
    OPTIX_OPACITY_MICROMAP_ARRAY_INDEXING_MODE_INDEXED = 2,
} OptixOpacityMicromapArrayIndexingMode;
 
typedef struct OptixOpacityMicromapUsageCount
{
    unsigned int count;
    unsigned int subdivisionLevel;
    OptixOpacityMicromapFormat format;
} OptixOpacityMicromapUsageCount;
 
typedef struct OptixBuildInputOpacityMicromap
{
    OptixOpacityMicromapArrayIndexingMode indexingMode;
 
    CUdeviceptr  opacityMicromapArray;
 
    CUdeviceptr  indexBuffer;
 
    unsigned int indexSizeInBytes;
 
    unsigned int indexStrideInBytes;
 
    unsigned int indexOffset;
 
    unsigned int numMicromapUsageCounts;
    const OptixOpacityMicromapUsageCount* micromapUsageCounts;
} OptixBuildInputOpacityMicromap;
 
typedef struct OptixRelocateInputOpacityMicromap
{
    CUdeviceptr  opacityMicromapArray;
} OptixRelocateInputOpacityMicromap;
 
 
typedef enum OptixDisplacementMicromapFormat
{
    OPTIX_DISPLACEMENT_MICROMAP_FORMAT_NONE                      = 0,
    OPTIX_DISPLACEMENT_MICROMAP_FORMAT_64_MICRO_TRIS_64_BYTES    = 1,
    OPTIX_DISPLACEMENT_MICROMAP_FORMAT_256_MICRO_TRIS_128_BYTES  = 2,
    OPTIX_DISPLACEMENT_MICROMAP_FORMAT_1024_MICRO_TRIS_128_BYTES = 3,
} OptixDisplacementMicromapFormat;
 
typedef enum OptixDisplacementMicromapFlags
{
    OPTIX_DISPLACEMENT_MICROMAP_FLAG_NONE = 0,
 
    OPTIX_DISPLACEMENT_MICROMAP_FLAG_PREFER_FAST_TRACE = 1 << 0,
 
    OPTIX_DISPLACEMENT_MICROMAP_FLAG_PREFER_FAST_BUILD = 1 << 1,
 
} OptixDisplacementMicromapFlags;
 
typedef enum OptixDisplacementMicromapTriangleFlags
{
    OPTIX_DISPLACEMENT_MICROMAP_TRIANGLE_FLAG_NONE             = 0,
    OPTIX_DISPLACEMENT_MICROMAP_TRIANGLE_FLAG_DECIMATE_EDGE_01 = 1 << 0,
    OPTIX_DISPLACEMENT_MICROMAP_TRIANGLE_FLAG_DECIMATE_EDGE_12 = 1 << 1,
    OPTIX_DISPLACEMENT_MICROMAP_TRIANGLE_FLAG_DECIMATE_EDGE_20 = 1 << 2,
} OptixDisplacementMicromapTriangleFlags;
 
typedef struct OptixDisplacementMicromapDesc
{
    unsigned int   byteOffset;
    unsigned short subdivisionLevel;
    unsigned short format;
} OptixDisplacementMicromapDesc;
 
typedef struct OptixDisplacementMicromapHistogramEntry
{
    unsigned int                    count;
    unsigned int                    subdivisionLevel;
    OptixDisplacementMicromapFormat format;
} OptixDisplacementMicromapHistogramEntry;
 
typedef struct OptixDisplacementMicromapArrayBuildInput
{
    OptixDisplacementMicromapFlags                 flags;
    CUdeviceptr                                    displacementValuesBuffer;
    CUdeviceptr                                    perDisplacementMicromapDescBuffer;
    unsigned int                                   perDisplacementMicromapDescStrideInBytes;
    unsigned int                                   numDisplacementMicromapHistogramEntries;
    const OptixDisplacementMicromapHistogramEntry* displacementMicromapHistogramEntries;
} OptixDisplacementMicromapArrayBuildInput;
 
typedef struct OptixDisplacementMicromapUsageCount
{
    unsigned int                    count;
    unsigned int                    subdivisionLevel;
    OptixDisplacementMicromapFormat format;
} OptixDisplacementMicromapUsageCount;
 
typedef enum OptixDisplacementMicromapArrayIndexingMode
{
    OPTIX_DISPLACEMENT_MICROMAP_ARRAY_INDEXING_MODE_NONE = 0,
    OPTIX_DISPLACEMENT_MICROMAP_ARRAY_INDEXING_MODE_LINEAR = 1,
    OPTIX_DISPLACEMENT_MICROMAP_ARRAY_INDEXING_MODE_INDEXED = 2,
} OptixDisplacementMicromapArrayIndexingMode;
 
typedef struct OptixBuildInputDisplacementMicromap
{
    OptixDisplacementMicromapArrayIndexingMode indexingMode;
 
    CUdeviceptr displacementMicromapArray;
    CUdeviceptr displacementMicromapIndexBuffer;
    CUdeviceptr vertexDirectionsBuffer;
    CUdeviceptr vertexBiasAndScaleBuffer;
    CUdeviceptr triangleFlagsBuffer;
 
    unsigned int displacementMicromapIndexOffset;
    unsigned int displacementMicromapIndexStrideInBytes;
    unsigned int displacementMicromapIndexSizeInBytes;
 
    OptixDisplacementMicromapDirectionFormat vertexDirectionFormat;
    unsigned int                             vertexDirectionStrideInBytes;
 
    OptixDisplacementMicromapBiasAndScaleFormat vertexBiasAndScaleFormat;
    unsigned int                                vertexBiasAndScaleStrideInBytes;
 
    unsigned int triangleFlagsStrideInBytes;
 
    unsigned int                               numDisplacementMicromapUsageCounts;
    const OptixDisplacementMicromapUsageCount* displacementMicromapUsageCounts;
 
} OptixBuildInputDisplacementMicromap;
 
 
typedef struct OptixBuildInputTriangleArray
{
    const CUdeviceptr* vertexBuffers;
 
    unsigned int numVertices;
 
    OptixVertexFormat vertexFormat;
 
    unsigned int vertexStrideInBytes;
 
    CUdeviceptr indexBuffer;
 
    unsigned int numIndexTriplets;
 
    OptixIndicesFormat indexFormat;
 
    unsigned int indexStrideInBytes;
 
    CUdeviceptr preTransform;
 
    const unsigned int* flags;
 
    unsigned int numSbtRecords;
 
    CUdeviceptr sbtIndexOffsetBuffer;
 
    unsigned int sbtIndexOffsetSizeInBytes;
 
    unsigned int sbtIndexOffsetStrideInBytes;
 
    unsigned int primitiveIndexOffset;
 
    OptixTransformFormat transformFormat;
 
    OptixBuildInputOpacityMicromap opacityMicromap;
    OptixBuildInputDisplacementMicromap displacementMicromap;
 
} OptixBuildInputTriangleArray;
 
typedef struct OptixRelocateInputTriangleArray
{
    unsigned int numSbtRecords;
 
    OptixRelocateInputOpacityMicromap opacityMicromap;
} OptixRelocateInputTriangleArray;
 
typedef enum OptixPrimitiveType
{
    OPTIX_PRIMITIVE_TYPE_CUSTOM                        = 0x2500,
    OPTIX_PRIMITIVE_TYPE_ROUND_QUADRATIC_BSPLINE       = 0x2501,
    OPTIX_PRIMITIVE_TYPE_ROUND_CUBIC_BSPLINE           = 0x2502,
    OPTIX_PRIMITIVE_TYPE_ROUND_LINEAR                  = 0x2503,
    OPTIX_PRIMITIVE_TYPE_ROUND_CATMULLROM              = 0x2504,
    OPTIX_PRIMITIVE_TYPE_FLAT_QUADRATIC_BSPLINE        = 0x2505,
    OPTIX_PRIMITIVE_TYPE_SPHERE                        = 0x2506,
    OPTIX_PRIMITIVE_TYPE_ROUND_CUBIC_BEZIER            = 0x2507,
    OPTIX_PRIMITIVE_TYPE_TRIANGLE                      = 0x2531,
    OPTIX_PRIMITIVE_TYPE_DISPLACED_MICROMESH_TRIANGLE  = 0x2532,
} OptixPrimitiveType;
 
typedef enum OptixPrimitiveTypeFlags
{
    OPTIX_PRIMITIVE_TYPE_FLAGS_CUSTOM                       = 1 << 0,
    OPTIX_PRIMITIVE_TYPE_FLAGS_ROUND_QUADRATIC_BSPLINE      = 1 << 1,
    OPTIX_PRIMITIVE_TYPE_FLAGS_ROUND_CUBIC_BSPLINE          = 1 << 2,
    OPTIX_PRIMITIVE_TYPE_FLAGS_ROUND_LINEAR                 = 1 << 3,
    OPTIX_PRIMITIVE_TYPE_FLAGS_ROUND_CATMULLROM             = 1 << 4,
    OPTIX_PRIMITIVE_TYPE_FLAGS_FLAT_QUADRATIC_BSPLINE       = 1 << 5,
    OPTIX_PRIMITIVE_TYPE_FLAGS_SPHERE                       = 1 << 6,
    OPTIX_PRIMITIVE_TYPE_FLAGS_ROUND_CUBIC_BEZIER           = 1 << 7,
    OPTIX_PRIMITIVE_TYPE_FLAGS_TRIANGLE                     = 1 << 31,
    OPTIX_PRIMITIVE_TYPE_FLAGS_DISPLACED_MICROMESH_TRIANGLE = 1 << 30,
} OptixPrimitiveTypeFlags;
 
typedef enum OptixCurveEndcapFlags
{
    OPTIX_CURVE_ENDCAP_DEFAULT                        = 0,
    OPTIX_CURVE_ENDCAP_ON                             = 1 << 0,
} OptixCurveEndcapFlags;
 
typedef struct OptixBuildInputCurveArray
{
    OptixPrimitiveType curveType;
    unsigned int numPrimitives;
 
    const CUdeviceptr* vertexBuffers;
    unsigned int numVertices;
    unsigned int vertexStrideInBytes;
 
    const CUdeviceptr* widthBuffers;
    unsigned int widthStrideInBytes;
 
    const CUdeviceptr* normalBuffers;
    unsigned int normalStrideInBytes;
 
    CUdeviceptr indexBuffer;
    unsigned int indexStrideInBytes;
 
    unsigned int flag;
 
    unsigned int primitiveIndexOffset;
 
    unsigned int endcapFlags;
} OptixBuildInputCurveArray;
 
typedef struct OptixBuildInputSphereArray
{
  const CUdeviceptr* vertexBuffers;
 
  unsigned int vertexStrideInBytes;
  unsigned int numVertices;
 
  const CUdeviceptr* radiusBuffers;
  unsigned int radiusStrideInBytes;
  int singleRadius;
 
  const unsigned int* flags;
 
  unsigned int numSbtRecords;
  CUdeviceptr sbtIndexOffsetBuffer;
  unsigned int sbtIndexOffsetSizeInBytes;
  unsigned int sbtIndexOffsetStrideInBytes;
 
  unsigned int primitiveIndexOffset;
} OptixBuildInputSphereArray;
 
typedef struct OptixAabb
{
    float minX;  
    float minY;  
    float minZ;  
    float maxX;  
    float maxY;  
    float maxZ;  
} OptixAabb;
 
typedef struct OptixBuildInputCustomPrimitiveArray
{
    const CUdeviceptr* aabbBuffers;
 
    unsigned int numPrimitives;
 
    unsigned int strideInBytes;
 
    const unsigned int* flags;
 
    unsigned int numSbtRecords;
 
    CUdeviceptr sbtIndexOffsetBuffer;
 
    unsigned int sbtIndexOffsetSizeInBytes;
 
    unsigned int sbtIndexOffsetStrideInBytes;
 
    unsigned int primitiveIndexOffset;
} OptixBuildInputCustomPrimitiveArray;
 
typedef struct OptixBuildInputInstanceArray
{
    CUdeviceptr instances;
 
    unsigned int numInstances;
 
    unsigned int instanceStride;
} OptixBuildInputInstanceArray;
 
typedef struct OptixRelocateInputInstanceArray
{
    unsigned int numInstances;
    
    CUdeviceptr traversableHandles;
 
} OptixRelocateInputInstanceArray;
 
typedef enum OptixBuildInputType
{
    OPTIX_BUILD_INPUT_TYPE_TRIANGLES = 0x2141,
    OPTIX_BUILD_INPUT_TYPE_CUSTOM_PRIMITIVES = 0x2142,
    OPTIX_BUILD_INPUT_TYPE_INSTANCES = 0x2143,
    OPTIX_BUILD_INPUT_TYPE_INSTANCE_POINTERS = 0x2144,
    OPTIX_BUILD_INPUT_TYPE_CURVES = 0x2145,
    OPTIX_BUILD_INPUT_TYPE_SPHERES = 0x2146
} OptixBuildInputType;
 
typedef struct OptixBuildInput
{
    OptixBuildInputType type;
 
    union
    {
        OptixBuildInputTriangleArray triangleArray;
        OptixBuildInputCurveArray curveArray;
        OptixBuildInputSphereArray sphereArray;
        OptixBuildInputCustomPrimitiveArray customPrimitiveArray;
        OptixBuildInputInstanceArray instanceArray;
        char pad[1024];
    };
} OptixBuildInput;
 
typedef struct OptixRelocateInput
{
    OptixBuildInputType type;
 
    union
    {
        OptixRelocateInputInstanceArray instanceArray;
 
        OptixRelocateInputTriangleArray triangleArray;
 
    };
} OptixRelocateInput;
 
// Some 32-bit tools use this header. This static_assert fails for them because
// the default enum size is 4 bytes, rather than 8, under 32-bit compilers.
// This #ifndef allows them to disable the static assert.
 
// TODO Define a static assert for C/pre-C++-11
#if defined( __cplusplus ) && __cplusplus >= 201103L
static_assert( sizeof( OptixBuildInput ) == 8 + 1024, "OptixBuildInput has wrong size" );
#endif
 
typedef enum OptixInstanceFlags
{
    OPTIX_INSTANCE_FLAG_NONE = 0,
 
    OPTIX_INSTANCE_FLAG_DISABLE_TRIANGLE_FACE_CULLING = 1u << 0,
 
    OPTIX_INSTANCE_FLAG_FLIP_TRIANGLE_FACING = 1u << 1,
 
    OPTIX_INSTANCE_FLAG_DISABLE_ANYHIT = 1u << 2,
 
    OPTIX_INSTANCE_FLAG_ENFORCE_ANYHIT = 1u << 3,
 
 
    OPTIX_INSTANCE_FLAG_FORCE_OPACITY_MICROMAP_2_STATE = 1u << 4,
    OPTIX_INSTANCE_FLAG_DISABLE_OPACITY_MICROMAPS = 1u << 5,
 
} OptixInstanceFlags;
 
typedef struct OptixInstance
{
    float transform[12];
 
    unsigned int instanceId;
 
    unsigned int sbtOffset;
 
    unsigned int visibilityMask;
 
    unsigned int flags;
 
    OptixTraversableHandle traversableHandle;
 
    unsigned int pad[2];
} OptixInstance;
 
typedef enum OptixBuildFlags
{
    OPTIX_BUILD_FLAG_NONE = 0,
 
    OPTIX_BUILD_FLAG_ALLOW_UPDATE = 1u << 0,
 
    OPTIX_BUILD_FLAG_ALLOW_COMPACTION = 1u << 1,
 
    OPTIX_BUILD_FLAG_PREFER_FAST_TRACE = 1u << 2,
 
    OPTIX_BUILD_FLAG_PREFER_FAST_BUILD = 1u << 3,
 
    OPTIX_BUILD_FLAG_ALLOW_RANDOM_VERTEX_ACCESS = 1u << 4,
 
    OPTIX_BUILD_FLAG_ALLOW_RANDOM_INSTANCE_ACCESS = 1u << 5,
 
    OPTIX_BUILD_FLAG_ALLOW_OPACITY_MICROMAP_UPDATE = 1u << 6,
 
    OPTIX_BUILD_FLAG_ALLOW_DISABLE_OPACITY_MICROMAPS = 1u << 7,
} OptixBuildFlags;
 
 
typedef enum OptixOpacityMicromapFlags
{
    OPTIX_OPACITY_MICROMAP_FLAG_NONE = 0,
 
    OPTIX_OPACITY_MICROMAP_FLAG_PREFER_FAST_TRACE = 1 << 0,
 
    OPTIX_OPACITY_MICROMAP_FLAG_PREFER_FAST_BUILD = 1 << 1,
} OptixOpacityMicromapFlags;
 
typedef struct OptixOpacityMicromapDesc
{
    unsigned int  byteOffset;
    unsigned short subdivisionLevel;
    unsigned short format;
} OptixOpacityMicromapDesc;
 
typedef struct OptixOpacityMicromapHistogramEntry
{
    unsigned int               count;
    unsigned int               subdivisionLevel;
    OptixOpacityMicromapFormat format;
} OptixOpacityMicromapHistogramEntry;
 
typedef struct OptixOpacityMicromapArrayBuildInput
{
    unsigned int flags;
 
    CUdeviceptr inputBuffer;
 
    CUdeviceptr perMicromapDescBuffer;
 
    unsigned int perMicromapDescStrideInBytes;
 
    unsigned int numMicromapHistogramEntries;
    const OptixOpacityMicromapHistogramEntry* micromapHistogramEntries;
} OptixOpacityMicromapArrayBuildInput;
 
typedef struct OptixMicromapBufferSizes
{
    size_t outputSizeInBytes;
    size_t tempSizeInBytes;
} OptixMicromapBufferSizes;
 
typedef struct OptixMicromapBuffers
{
    CUdeviceptr output;
    size_t outputSizeInBytes;
    CUdeviceptr temp;
    size_t tempSizeInBytes;
} OptixMicromapBuffers;
 
 
typedef enum OptixBuildOperation
{
    OPTIX_BUILD_OPERATION_BUILD = 0x2161,
    OPTIX_BUILD_OPERATION_UPDATE = 0x2162,
} OptixBuildOperation;
 
typedef enum OptixMotionFlags
{
    OPTIX_MOTION_FLAG_NONE         = 0,
    OPTIX_MOTION_FLAG_START_VANISH = 1u << 0,
    OPTIX_MOTION_FLAG_END_VANISH   = 1u << 1
} OptixMotionFlags;
 
typedef struct OptixMotionOptions
{
    unsigned short numKeys;
 
    unsigned short flags;
 
    float timeBegin;
 
    float timeEnd;
} OptixMotionOptions;
 
typedef struct OptixAccelBuildOptions
{
    unsigned int buildFlags;
 
    OptixBuildOperation operation;
 
    OptixMotionOptions motionOptions;
} OptixAccelBuildOptions;
 
typedef struct OptixAccelBufferSizes
{
    size_t outputSizeInBytes;
 
    size_t tempSizeInBytes;
 
    size_t tempUpdateSizeInBytes;
} OptixAccelBufferSizes;
 
typedef enum OptixAccelPropertyType
{
    OPTIX_PROPERTY_TYPE_COMPACTED_SIZE = 0x2181,
 
    OPTIX_PROPERTY_TYPE_AABBS = 0x2182,
} OptixAccelPropertyType;
 
typedef struct OptixAccelEmitDesc
{
    CUdeviceptr result;
 
    OptixAccelPropertyType type;
} OptixAccelEmitDesc;
 
typedef struct OptixRelocationInfo
{
    unsigned long long info[4];
} OptixRelocationInfo;
 
typedef struct OptixStaticTransform
{
    OptixTraversableHandle child;
 
    unsigned int pad[2];
 
    float transform[12];
 
    float invTransform[12];
} OptixStaticTransform;
 
typedef struct OptixMatrixMotionTransform
{
    OptixTraversableHandle child;
 
    OptixMotionOptions motionOptions;
 
    unsigned int pad[3];
 
    float transform[2][12];
} OptixMatrixMotionTransform;
 
//      [ sx   a   b  pvx ]
//  S = [  0  sy   c  pvy ]
//      [  0   0  sz  pvz ]
//      [  1  0  0 tx ]
//  T = [  0  1  0 ty ]
//      [  0  0  1 tz ]
typedef struct OptixSRTData
{
    float sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz;
} OptixSRTData;
 
// TODO Define a static assert for C/pre-C++-11
#if defined( __cplusplus ) && __cplusplus >= 201103L
static_assert( sizeof( OptixSRTData ) == 16 * 4, "OptixSRTData has wrong size" );
#endif
 
typedef struct OptixSRTMotionTransform
{
    OptixTraversableHandle child;
 
    OptixMotionOptions motionOptions;
 
    unsigned int pad[3];
 
    OptixSRTData srtData[2];
} OptixSRTMotionTransform;
 
// TODO Define a static assert for C/pre-C++-11
#if defined( __cplusplus ) && __cplusplus >= 201103L
static_assert( sizeof( OptixSRTMotionTransform ) == 8 + 12 + 12 + 2 * 16 * 4, "OptixSRTMotionTransform has wrong size" );
#endif
 
typedef enum OptixTraversableType
{
    OPTIX_TRAVERSABLE_TYPE_STATIC_TRANSFORM = 0x21C1,
    OPTIX_TRAVERSABLE_TYPE_MATRIX_MOTION_TRANSFORM = 0x21C2,
    OPTIX_TRAVERSABLE_TYPE_SRT_MOTION_TRANSFORM = 0x21C3,
} OptixTraversableType;
 
typedef enum OptixPixelFormat
{
    OPTIX_PIXEL_FORMAT_HALF1  = 0x220a,               
    OPTIX_PIXEL_FORMAT_HALF2  = 0x2207,               
    OPTIX_PIXEL_FORMAT_HALF3  = 0x2201,               
    OPTIX_PIXEL_FORMAT_HALF4  = 0x2202,               
    OPTIX_PIXEL_FORMAT_FLOAT1 = 0x220b,               
    OPTIX_PIXEL_FORMAT_FLOAT2 = 0x2208,               
    OPTIX_PIXEL_FORMAT_FLOAT3 = 0x2203,               
    OPTIX_PIXEL_FORMAT_FLOAT4 = 0x2204,               
    OPTIX_PIXEL_FORMAT_UCHAR3 = 0x2205,               
    OPTIX_PIXEL_FORMAT_UCHAR4 = 0x2206,               
    OPTIX_PIXEL_FORMAT_INTERNAL_GUIDE_LAYER = 0x2209  
} OptixPixelFormat;
 
typedef struct OptixImage2D
{
    CUdeviceptr data;
    unsigned int width;
    unsigned int height;
    unsigned int rowStrideInBytes;
    unsigned int pixelStrideInBytes;
    OptixPixelFormat format;
} OptixImage2D;
 
typedef enum OptixDenoiserModelKind
{
    OPTIX_DENOISER_MODEL_KIND_LDR = 0x2322,
 
    OPTIX_DENOISER_MODEL_KIND_HDR = 0x2323,
 
    OPTIX_DENOISER_MODEL_KIND_AOV = 0x2324,
 
    OPTIX_DENOISER_MODEL_KIND_TEMPORAL = 0x2325,
 
    OPTIX_DENOISER_MODEL_KIND_TEMPORAL_AOV = 0x2326,
 
    OPTIX_DENOISER_MODEL_KIND_UPSCALE2X = 0x2327,
 
    OPTIX_DENOISER_MODEL_KIND_TEMPORAL_UPSCALE2X = 0x2328
} OptixDenoiserModelKind;
 
typedef struct OptixDenoiserOptions
{
    // if nonzero, albedo image must be given in OptixDenoiserGuideLayer
    unsigned int guideAlbedo;
 
    // if nonzero, normal image must be given in OptixDenoiserGuideLayer
    unsigned int guideNormal;
} OptixDenoiserOptions;
 
typedef struct OptixDenoiserGuideLayer
{
    // albedo/bsdf image
    OptixImage2D  albedo;
 
    // normal vector image (2d or 3d pixel format)
    OptixImage2D  normal;
 
    // 2d flow image, pixel flow from previous to current frame for each pixel
    OptixImage2D  flow;
 
    // Internal images used in temporal AOV denoising modes,
    // pixel format OPTIX_PIXEL_FORMAT_INTERNAL_GUIDE_LAYER
    OptixImage2D  previousOutputInternalGuideLayer;
    OptixImage2D  outputInternalGuideLayer;
 
    // 1d image specifying how trustworthy the flow vector at x,y position in
    // OptixDenoiserGuideLayer::flow is. Range 0..1 (low->high trustworthiness).
    // Ignored if data pointer in the image is zero.
    OptixImage2D flowTrustworthiness;
 
} OptixDenoiserGuideLayer;
 
typedef enum OptixDenoiserAOVType
{
    OPTIX_DENOISER_AOV_TYPE_NONE       = 0,
 
    OPTIX_DENOISER_AOV_TYPE_BEAUTY     = 0x7000,
    OPTIX_DENOISER_AOV_TYPE_SPECULAR   = 0x7001,
    OPTIX_DENOISER_AOV_TYPE_REFLECTION = 0x7002,
    OPTIX_DENOISER_AOV_TYPE_REFRACTION = 0x7003,
    OPTIX_DENOISER_AOV_TYPE_DIFFUSE    = 0x7004
 
} OptixDenoiserAOVType;
 
typedef struct OptixDenoiserLayer
{
    // input image (beauty or AOV)
    OptixImage2D  input;
 
    // denoised output image from previous frame if temporal model kind selected
    OptixImage2D  previousOutput;
 
    // denoised output for given input
    OptixImage2D  output;
 
    // Type of AOV, used in temporal AOV modes as a hint to improve image quality.
    OptixDenoiserAOVType type;
} OptixDenoiserLayer;
 
typedef enum OptixDenoiserAlphaMode
{
    OPTIX_DENOISER_ALPHA_MODE_COPY = 0,
 
    OPTIX_DENOISER_ALPHA_MODE_ALPHA_AS_AOV = 1,
 
    OPTIX_DENOISER_ALPHA_MODE_FULL_DENOISE_PASS = 2
} OptixDenoiserAlphaMode;
typedef struct OptixDenoiserParams
{
    OptixDenoiserAlphaMode denoiseAlpha;
 
    CUdeviceptr  hdrIntensity;
 
    float        blendFactor;
 
    CUdeviceptr  hdrAverageColor;
 
    unsigned int temporalModeUsePreviousLayers;
} OptixDenoiserParams;
 
typedef struct OptixDenoiserSizes
{
    size_t stateSizeInBytes;
 
    size_t withOverlapScratchSizeInBytes;
 
    size_t withoutOverlapScratchSizeInBytes;
 
    unsigned int overlapWindowSizeInPixels;
 
    size_t computeAverageColorSizeInBytes;
 
    size_t computeIntensitySizeInBytes;
 
    size_t internalGuideLayerPixelSizeInBytes;
} OptixDenoiserSizes;
 
typedef enum OptixRayFlags
{
    OPTIX_RAY_FLAG_NONE = 0u,
 
    OPTIX_RAY_FLAG_DISABLE_ANYHIT = 1u << 0,
 
    OPTIX_RAY_FLAG_ENFORCE_ANYHIT = 1u << 1,
 
    OPTIX_RAY_FLAG_TERMINATE_ON_FIRST_HIT = 1u << 2,
 
    OPTIX_RAY_FLAG_DISABLE_CLOSESTHIT = 1u << 3,
 
    OPTIX_RAY_FLAG_CULL_BACK_FACING_TRIANGLES = 1u << 4,
 
    OPTIX_RAY_FLAG_CULL_FRONT_FACING_TRIANGLES = 1u << 5,
 
    OPTIX_RAY_FLAG_CULL_DISABLED_ANYHIT = 1u << 6,
 
    OPTIX_RAY_FLAG_CULL_ENFORCED_ANYHIT = 1u << 7,
 
    OPTIX_RAY_FLAG_FORCE_OPACITY_MICROMAP_2_STATE = 1u << 10,
} OptixRayFlags;
 
typedef enum OptixTransformType
{
    OPTIX_TRANSFORM_TYPE_NONE                    = 0, 
    OPTIX_TRANSFORM_TYPE_STATIC_TRANSFORM        = 1, 
    OPTIX_TRANSFORM_TYPE_MATRIX_MOTION_TRANSFORM = 2, 
    OPTIX_TRANSFORM_TYPE_SRT_MOTION_TRANSFORM    = 3, 
    OPTIX_TRANSFORM_TYPE_INSTANCE                = 4, 
} OptixTransformType;
 
typedef enum OptixTraversableGraphFlags
{
    OPTIX_TRAVERSABLE_GRAPH_FLAG_ALLOW_ANY = 0,
 
    OPTIX_TRAVERSABLE_GRAPH_FLAG_ALLOW_SINGLE_GAS = 1u << 0,
 
    OPTIX_TRAVERSABLE_GRAPH_FLAG_ALLOW_SINGLE_LEVEL_INSTANCING = 1u << 1,
} OptixTraversableGraphFlags;
 
typedef enum OptixCompileOptimizationLevel
{
    OPTIX_COMPILE_OPTIMIZATION_DEFAULT = 0,
    OPTIX_COMPILE_OPTIMIZATION_LEVEL_0 = 0x2340,
    OPTIX_COMPILE_OPTIMIZATION_LEVEL_1 = 0x2341,
    OPTIX_COMPILE_OPTIMIZATION_LEVEL_2 = 0x2342,
    OPTIX_COMPILE_OPTIMIZATION_LEVEL_3 = 0x2343,
} OptixCompileOptimizationLevel;
 
typedef enum OptixCompileDebugLevel
{
    OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT  = 0,
    OPTIX_COMPILE_DEBUG_LEVEL_NONE     = 0x2350,
    OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL  = 0x2351,
    OPTIX_COMPILE_DEBUG_LEVEL_MODERATE = 0x2353,
    OPTIX_COMPILE_DEBUG_LEVEL_FULL     = 0x2352,
} OptixCompileDebugLevel;
 
typedef enum OptixModuleCompileState
{
    OPTIX_MODULE_COMPILE_STATE_NOT_STARTED       = 0x2360,
 
    OPTIX_MODULE_COMPILE_STATE_STARTED           = 0x2361,
 
    OPTIX_MODULE_COMPILE_STATE_IMPENDING_FAILURE = 0x2362,
 
    OPTIX_MODULE_COMPILE_STATE_FAILED            = 0x2363,
 
    OPTIX_MODULE_COMPILE_STATE_COMPLETED         = 0x2364,
} OptixModuleCompileState;
 
 
 
typedef struct OptixModuleCompileBoundValueEntry {
    size_t pipelineParamOffsetInBytes;
    size_t sizeInBytes;
    const void* boundValuePtr;
    const char* annotation; // optional string to display, set to 0 if unused.  If unused,
                            // OptiX will report the annotation as "No annotation"
} OptixModuleCompileBoundValueEntry;
 
typedef enum OptixPayloadTypeID {
    OPTIX_PAYLOAD_TYPE_DEFAULT = 0,
    OPTIX_PAYLOAD_TYPE_ID_0 = (1 << 0u),
    OPTIX_PAYLOAD_TYPE_ID_1 = (1 << 1u),
    OPTIX_PAYLOAD_TYPE_ID_2 = (1 << 2u),
    OPTIX_PAYLOAD_TYPE_ID_3 = (1 << 3u),
    OPTIX_PAYLOAD_TYPE_ID_4 = (1 << 4u),
    OPTIX_PAYLOAD_TYPE_ID_5 = (1 << 5u),
    OPTIX_PAYLOAD_TYPE_ID_6 = (1 << 6u),
    OPTIX_PAYLOAD_TYPE_ID_7 = (1 << 7u)
} OptixPayloadTypeID;
 
typedef enum OptixPayloadSemantics
{
    OPTIX_PAYLOAD_SEMANTICS_TRACE_CALLER_NONE       = 0,
    OPTIX_PAYLOAD_SEMANTICS_TRACE_CALLER_READ       = 1u << 0,
    OPTIX_PAYLOAD_SEMANTICS_TRACE_CALLER_WRITE      = 2u << 0,
    OPTIX_PAYLOAD_SEMANTICS_TRACE_CALLER_READ_WRITE = 3u << 0,
 
    OPTIX_PAYLOAD_SEMANTICS_CH_NONE                 = 0,
    OPTIX_PAYLOAD_SEMANTICS_CH_READ                 = 1u << 2,
    OPTIX_PAYLOAD_SEMANTICS_CH_WRITE                = 2u << 2,
    OPTIX_PAYLOAD_SEMANTICS_CH_READ_WRITE           = 3u << 2,
 
    OPTIX_PAYLOAD_SEMANTICS_MS_NONE                 = 0,
    OPTIX_PAYLOAD_SEMANTICS_MS_READ                 = 1u << 4,
    OPTIX_PAYLOAD_SEMANTICS_MS_WRITE                = 2u << 4,
    OPTIX_PAYLOAD_SEMANTICS_MS_READ_WRITE           = 3u << 4,
 
    OPTIX_PAYLOAD_SEMANTICS_AH_NONE                 = 0,
    OPTIX_PAYLOAD_SEMANTICS_AH_READ                 = 1u << 6,
    OPTIX_PAYLOAD_SEMANTICS_AH_WRITE                = 2u << 6,
    OPTIX_PAYLOAD_SEMANTICS_AH_READ_WRITE           = 3u << 6,
 
    OPTIX_PAYLOAD_SEMANTICS_IS_NONE                 = 0,
    OPTIX_PAYLOAD_SEMANTICS_IS_READ                 = 1u << 8,
    OPTIX_PAYLOAD_SEMANTICS_IS_WRITE                = 2u << 8,
    OPTIX_PAYLOAD_SEMANTICS_IS_READ_WRITE           = 3u << 8,
} OptixPayloadSemantics;
 
typedef struct OptixPayloadType
{
    unsigned int numPayloadValues;
 
    const unsigned int *payloadSemantics;
} OptixPayloadType;
 
typedef struct OptixModuleCompileOptions
{
    int maxRegisterCount;
 
    OptixCompileOptimizationLevel optLevel;
 
    OptixCompileDebugLevel debugLevel;
 
    const OptixModuleCompileBoundValueEntry* boundValues;
 
    unsigned int numBoundValues;
 
    unsigned int numPayloadTypes;
 
    OptixPayloadType *payloadTypes;
 
} OptixModuleCompileOptions;
 
typedef enum OptixProgramGroupKind
{
    OPTIX_PROGRAM_GROUP_KIND_RAYGEN = 0x2421,
 
    OPTIX_PROGRAM_GROUP_KIND_MISS = 0x2422,
 
    OPTIX_PROGRAM_GROUP_KIND_EXCEPTION = 0x2423,
 
    OPTIX_PROGRAM_GROUP_KIND_HITGROUP = 0x2424,
 
    OPTIX_PROGRAM_GROUP_KIND_CALLABLES = 0x2425
} OptixProgramGroupKind;
 
typedef enum OptixProgramGroupFlags
{
    OPTIX_PROGRAM_GROUP_FLAGS_NONE = 0
} OptixProgramGroupFlags;
 
typedef struct OptixProgramGroupSingleModule
{
    OptixModule module;
    const char* entryFunctionName;
} OptixProgramGroupSingleModule;
 
typedef struct OptixProgramGroupHitgroup
{
    OptixModule moduleCH;
    const char* entryFunctionNameCH;
    OptixModule moduleAH;
    const char* entryFunctionNameAH;
    OptixModule moduleIS;
    const char* entryFunctionNameIS;
} OptixProgramGroupHitgroup;
 
typedef struct OptixProgramGroupCallables
{
    OptixModule moduleDC;
    const char* entryFunctionNameDC;
    OptixModule moduleCC;
    const char* entryFunctionNameCC;
} OptixProgramGroupCallables;
 
typedef struct OptixProgramGroupDesc
{
    OptixProgramGroupKind kind;
 
    unsigned int flags;
 
    union
    {
        OptixProgramGroupSingleModule raygen;
        OptixProgramGroupSingleModule miss;
        OptixProgramGroupSingleModule exception;
        OptixProgramGroupCallables callables;
        OptixProgramGroupHitgroup hitgroup;
    };
} OptixProgramGroupDesc;
 
typedef struct OptixProgramGroupOptions
{
    OptixPayloadType* payloadType;
} OptixProgramGroupOptions;
 
typedef enum OptixExceptionCodes
{
    OPTIX_EXCEPTION_CODE_STACK_OVERFLOW = -1,
 
    OPTIX_EXCEPTION_CODE_TRACE_DEPTH_EXCEEDED = -2,
 
    OPTIX_EXCEPTION_CODE_TRAVERSAL_DEPTH_EXCEEDED = -3,
 
    OPTIX_EXCEPTION_CODE_TRAVERSAL_INVALID_TRAVERSABLE = -5,
 
    OPTIX_EXCEPTION_CODE_TRAVERSAL_INVALID_MISS_SBT = -6,
 
    //      sbt-index (See optixGetExceptionInvalidSbtOffset),
    //      sbt-instance-offset (See OptixInstance::sbtOffset),
    OPTIX_EXCEPTION_CODE_TRAVERSAL_INVALID_HIT_SBT = -7,
 
    OPTIX_EXCEPTION_CODE_UNSUPPORTED_PRIMITIVE_TYPE = -8,
 
    OPTIX_EXCEPTION_CODE_INVALID_RAY = -9,
 
    OPTIX_EXCEPTION_CODE_CALLABLE_PARAMETER_MISMATCH = -10,
 
    OPTIX_EXCEPTION_CODE_BUILTIN_IS_MISMATCH = -11,
 
    OPTIX_EXCEPTION_CODE_CALLABLE_INVALID_SBT = -12,
 
    OPTIX_EXCEPTION_CODE_CALLABLE_NO_DC_SBT_RECORD = -13,
 
    OPTIX_EXCEPTION_CODE_CALLABLE_NO_CC_SBT_RECORD = -14,
 
    OPTIX_EXCEPTION_CODE_UNSUPPORTED_SINGLE_LEVEL_GAS = -15,
 
    OPTIX_EXCEPTION_CODE_INVALID_VALUE_ARGUMENT_0 = -16,
    OPTIX_EXCEPTION_CODE_INVALID_VALUE_ARGUMENT_1 = -17,
    OPTIX_EXCEPTION_CODE_INVALID_VALUE_ARGUMENT_2 = -18,
 
    OPTIX_EXCEPTION_CODE_UNSUPPORTED_DATA_ACCESS = -32,
 
    OPTIX_EXCEPTION_CODE_PAYLOAD_TYPE_MISMATCH = -33,
} OptixExceptionCodes;
 
typedef enum OptixExceptionFlags
{
    OPTIX_EXCEPTION_FLAG_NONE = 0,
 
    OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW = 1u << 0,
 
    OPTIX_EXCEPTION_FLAG_TRACE_DEPTH = 1u << 1,
 
    OPTIX_EXCEPTION_FLAG_USER = 1u << 2,
 
    OPTIX_EXCEPTION_FLAG_DEBUG = 1u << 3
} OptixExceptionFlags;
 
typedef struct OptixPipelineCompileOptions
{
    int usesMotionBlur;
 
    unsigned int traversableGraphFlags;
 
    int numPayloadValues;
 
    int numAttributeValues;
 
    unsigned int exceptionFlags;
 
    const char* pipelineLaunchParamsVariableName;
 
    unsigned int usesPrimitiveTypeFlags;
 
    int allowOpacityMicromaps;
} OptixPipelineCompileOptions;
 
typedef struct OptixPipelineLinkOptions
{
    unsigned int maxTraceDepth;
 
} OptixPipelineLinkOptions;
 
typedef struct OptixShaderBindingTable
{
    CUdeviceptr raygenRecord;
 
    CUdeviceptr exceptionRecord;
 
    CUdeviceptr  missRecordBase;
    unsigned int missRecordStrideInBytes;
    unsigned int missRecordCount;
 
    CUdeviceptr  hitgroupRecordBase;
    unsigned int hitgroupRecordStrideInBytes;
    unsigned int hitgroupRecordCount;
 
    CUdeviceptr  callablesRecordBase;
    unsigned int callablesRecordStrideInBytes;
    unsigned int callablesRecordCount;
 
} OptixShaderBindingTable;
 
typedef struct OptixStackSizes
{
    unsigned int cssRG;
    unsigned int cssMS;
    unsigned int cssCH;
    unsigned int cssAH;
    unsigned int cssIS;
    unsigned int cssCC;
    unsigned int dssDC;
 
} OptixStackSizes;
 
typedef enum OptixQueryFunctionTableOptions
{
    OPTIX_QUERY_FUNCTION_TABLE_OPTION_DUMMY = 0
 
} OptixQueryFunctionTableOptions;
 
typedef OptixResult( OptixQueryFunctionTable_t )( int          abiId,
                                                  unsigned int numOptions,
                                                  OptixQueryFunctionTableOptions* /*optionKeys*/,
                                                  const void** /*optionValues*/,
                                                  void*  functionTable,
                                                  size_t sizeOfTable );
 
typedef struct OptixBuiltinISOptions
{
    OptixPrimitiveType        builtinISModuleType;
    int                       usesMotionBlur;
    unsigned int              buildFlags;
    unsigned int              curveEndcapFlags;
} OptixBuiltinISOptions;
 
#if defined( __CUDACC__ )
typedef struct OptixInvalidRayExceptionDetails
{
    float3 origin;
    float3 direction;
    float  tmin;
    float  tmax;
    float  time;
} OptixInvalidRayExceptionDetails;
 
typedef struct OptixParameterMismatchExceptionDetails
{
    unsigned int expectedParameterCount;
    unsigned int passedArgumentCount;
    unsigned int sbtIndex;
    char*        callableName;
} OptixParameterMismatchExceptionDetails;
#endif
 
  // end group optix_types
 
#endif  // OPTIX_OPTIX_TYPES_H