optix_host.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_HOST_H
#define OPTIX_OPTIX_HOST_H
 
#include "optix_types.h"
#if !defined( OPTIX_DONT_INCLUDE_CUDA )
// If OPTIX_DONT_INCLUDE_CUDA is defined, cuda driver types must be defined through other
// means before including optix headers.
#include <cuda.h>
#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
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
 
 
const char* optixGetErrorName( OptixResult result );
 
const char* optixGetErrorString( OptixResult result );
 
 
 
 
OptixResult optixDeviceContextCreate( CUcontext fromContext, const OptixDeviceContextOptions* options, OptixDeviceContext* context );
 
OptixResult optixDeviceContextDestroy( OptixDeviceContext context );
 
OptixResult optixDeviceContextGetProperty( OptixDeviceContext context, OptixDeviceProperty property, void* value, size_t sizeInBytes );
 
OptixResult optixDeviceContextSetLogCallback( OptixDeviceContext context,
                                              OptixLogCallback   callbackFunction,
                                              void*              callbackData,
                                              unsigned int       callbackLevel );
 
OptixResult optixDeviceContextSetCacheEnabled( OptixDeviceContext context,
                                               int                enabled );
 
OptixResult optixDeviceContextSetCacheLocation( OptixDeviceContext context, const char* location );
 
OptixResult optixDeviceContextSetCacheDatabaseSizes( OptixDeviceContext context, size_t lowWaterMark, size_t highWaterMark );
 
OptixResult optixDeviceContextGetCacheEnabled( OptixDeviceContext context, int* enabled );
OptixResult optixDeviceContextGetCacheLocation( OptixDeviceContext context, char* location, size_t locationSize );
 
OptixResult optixDeviceContextGetCacheDatabaseSizes( OptixDeviceContext context, size_t* lowWaterMark, size_t* highWaterMark );
 
 
 
 
OptixResult optixPipelineCreate( OptixDeviceContext                 context,
                                 const OptixPipelineCompileOptions* pipelineCompileOptions,
                                 const OptixPipelineLinkOptions*    pipelineLinkOptions,
                                 const OptixProgramGroup*           programGroups,
                                 unsigned int                       numProgramGroups,
                                 char*                              logString,
                                 size_t*                            logStringSize,
                                 OptixPipeline*                     pipeline );
 
OptixResult optixPipelineDestroy( OptixPipeline pipeline );
 
OptixResult optixPipelineSetStackSize( OptixPipeline pipeline,
                                       unsigned int  directCallableStackSizeFromTraversal,
                                       unsigned int  directCallableStackSizeFromState,
                                       unsigned int  continuationStackSize,
                                       unsigned int  maxTraversableGraphDepth );
 
 
 
 
OptixResult optixModuleCreate( OptixDeviceContext                 context,
                               const OptixModuleCompileOptions*   moduleCompileOptions,
                               const OptixPipelineCompileOptions* pipelineCompileOptions,
                               const char*                        input,
                               size_t                             inputSize,
                               char*                              logString,
                               size_t*                            logStringSize,
                               OptixModule*                       module );
 
 
 
OptixResult optixModuleCreateWithTasks( OptixDeviceContext                 context,
                                        const OptixModuleCompileOptions*   moduleCompileOptions,
                                        const OptixPipelineCompileOptions* pipelineCompileOptions,
                                        const char*                        input,
                                        size_t                             inputSize,
                                        char*                              logString,
                                        size_t*                            logStringSize,
                                        OptixModule*                       module,
                                        OptixTask*                         firstTask );
 
OptixResult optixModuleGetCompilationState( OptixModule module, OptixModuleCompileState* state );
 
OptixResult optixModuleDestroy( OptixModule module );
 
OptixResult optixBuiltinISModuleGet( OptixDeviceContext                 context,
                                     const OptixModuleCompileOptions*   moduleCompileOptions,
                                     const OptixPipelineCompileOptions* pipelineCompileOptions,
                                     const OptixBuiltinISOptions*       builtinISOptions,
                                     OptixModule*                       builtinModule );
 
 
 
 
OptixResult optixTaskExecute( OptixTask task, OptixTask* additionalTasks, unsigned int maxNumAdditionalTasks, unsigned int* numAdditionalTasksCreated );
 
 
 
 
OptixResult optixProgramGroupGetStackSize( OptixProgramGroup programGroup, OptixStackSizes* stackSizes, OptixPipeline pipeline );
 
OptixResult optixProgramGroupCreate( OptixDeviceContext              context,
                                     const OptixProgramGroupDesc*    programDescriptions,
                                     unsigned int                    numProgramGroups,
                                     const OptixProgramGroupOptions* options,
                                     char*                           logString,
                                     size_t*                         logStringSize,
                                     OptixProgramGroup*              programGroups );
 
OptixResult optixProgramGroupDestroy( OptixProgramGroup programGroup );
 
 
 
 
OptixResult optixLaunch( OptixPipeline                  pipeline,
                         CUstream                       stream,
                         CUdeviceptr                    pipelineParams,
                         size_t                         pipelineParamsSize,
                         const OptixShaderBindingTable* sbt,
                         unsigned int                   width,
                         unsigned int                   height,
                         unsigned int                   depth );
 
OptixResult optixSbtRecordPackHeader( OptixProgramGroup programGroup, void* sbtRecordHeaderHostPointer );
 
 
 
 
OptixResult optixAccelComputeMemoryUsage( OptixDeviceContext            context,
                                          const OptixAccelBuildOptions* accelOptions,
                                          const OptixBuildInput*        buildInputs,
                                          unsigned int                  numBuildInputs,
                                          OptixAccelBufferSizes*        bufferSizes );
 
OptixResult optixAccelBuild( OptixDeviceContext            context,
                             CUstream                      stream,
                             const OptixAccelBuildOptions* accelOptions,
                             const OptixBuildInput*        buildInputs,
                             unsigned int                  numBuildInputs,
                             CUdeviceptr                   tempBuffer,
                             size_t                        tempBufferSizeInBytes,
                             CUdeviceptr                   outputBuffer,
                             size_t                        outputBufferSizeInBytes,
                             OptixTraversableHandle*       outputHandle,
                             const OptixAccelEmitDesc*     emittedProperties,
                             unsigned int                  numEmittedProperties );
 
OptixResult optixAccelGetRelocationInfo( OptixDeviceContext context, OptixTraversableHandle handle, OptixRelocationInfo* info );
 
OptixResult optixCheckRelocationCompatibility( OptixDeviceContext context, const OptixRelocationInfo* info, int* compatible );
 
OptixResult optixAccelRelocate( OptixDeviceContext         context,
                                CUstream                   stream,
                                const OptixRelocationInfo* info,
                                const OptixRelocateInput*  relocateInputs,
                                size_t                     numRelocateInputs,
                                CUdeviceptr                targetAccel,
                                size_t                     targetAccelSizeInBytes,
                                OptixTraversableHandle*    targetHandle );
 
OptixResult optixAccelCompact( OptixDeviceContext      context,
                               CUstream                stream,
                               OptixTraversableHandle  inputHandle,
                               CUdeviceptr             outputBuffer,
                               size_t                  outputBufferSizeInBytes,
                               OptixTraversableHandle* outputHandle );
 
OptixResult optixAccelEmitProperty( OptixDeviceContext        context,
                                    CUstream                  stream,
                                    OptixTraversableHandle    handle,
                                    const OptixAccelEmitDesc* emittedProperty );
 
OptixResult optixConvertPointerToTraversableHandle( OptixDeviceContext      onDevice,
                                                    CUdeviceptr             pointer,
                                                    OptixTraversableType    traversableType,
                                                    OptixTraversableHandle* traversableHandle );
 
 
OptixResult optixOpacityMicromapArrayComputeMemoryUsage( OptixDeviceContext                         context,
                                                         const OptixOpacityMicromapArrayBuildInput* buildInput,
                                                         OptixMicromapBufferSizes*                  bufferSizes );
 
OptixResult optixOpacityMicromapArrayBuild( OptixDeviceContext                         context,
                                            CUstream                                   stream,
                                            const OptixOpacityMicromapArrayBuildInput* buildInput,
                                            const OptixMicromapBuffers*                buffers );
 
OptixResult optixOpacityMicromapArrayGetRelocationInfo( OptixDeviceContext context, CUdeviceptr opacityMicromapArray, OptixRelocationInfo* info );
 
OptixResult optixOpacityMicromapArrayRelocate( OptixDeviceContext         context,
                                               CUstream                   stream,
                                               const OptixRelocationInfo* info,
                                               CUdeviceptr                targetOpacityMicromapArray,
                                               size_t                     targetOpacityMicromapArraySizeInBytes );
 
OptixResult optixDisplacementMicromapArrayComputeMemoryUsage( OptixDeviceContext                              context,
                                                              const OptixDisplacementMicromapArrayBuildInput* buildInput,
                                                              OptixMicromapBufferSizes* bufferSizes );
 
OptixResult optixDisplacementMicromapArrayBuild( OptixDeviceContext                              context,
                                                 CUstream                                        stream,
                                                 const OptixDisplacementMicromapArrayBuildInput* buildInput,
                                                 const OptixMicromapBuffers*                     buffers );
 
 
 
 
 
OptixResult optixDenoiserCreate( OptixDeviceContext context,
                                 OptixDenoiserModelKind modelKind,
                                 const OptixDenoiserOptions* options,
                                 OptixDenoiser* denoiser );
 
OptixResult optixDenoiserCreateWithUserModel( OptixDeviceContext context,
                                              const void* userData, size_t userDataSizeInBytes, OptixDenoiser* denoiser );
 
OptixResult optixDenoiserDestroy( OptixDenoiser denoiser );
 
OptixResult optixDenoiserComputeMemoryResources( const OptixDenoiser denoiser,
                                                 unsigned int        outputWidth,
                                                 unsigned int        outputHeight,
                                                 OptixDenoiserSizes* returnSizes );
 
OptixResult optixDenoiserSetup( OptixDenoiser denoiser,
                                CUstream      stream,
                                unsigned int  inputWidth,
                                unsigned int  inputHeight,
                                CUdeviceptr   denoiserState,
                                size_t        denoiserStateSizeInBytes,
                                CUdeviceptr   scratch,
                                size_t        scratchSizeInBytes );
 
OptixResult optixDenoiserInvoke( OptixDenoiser                   denoiser,
                                 CUstream                        stream,
                                 const OptixDenoiserParams*      params,
                                 CUdeviceptr                     denoiserState,
                                 size_t                          denoiserStateSizeInBytes,
                                 const OptixDenoiserGuideLayer*  guideLayer,
                                 const OptixDenoiserLayer*       layers,
                                 unsigned int                    numLayers,
                                 unsigned int                    inputOffsetX,
                                 unsigned int                    inputOffsetY,
                                 CUdeviceptr                     scratch,
                                 size_t                          scratchSizeInBytes );
 
OptixResult optixDenoiserComputeIntensity( OptixDenoiser       denoiser,
                                           CUstream            stream,
                                           const OptixImage2D* inputImage,
                                           CUdeviceptr         outputIntensity,
                                           CUdeviceptr         scratch,
                                           size_t              scratchSizeInBytes );
 
OptixResult optixDenoiserComputeAverageColor( OptixDenoiser       denoiser,
                                              CUstream            stream,
                                              const OptixImage2D* inputImage,
                                              CUdeviceptr         outputAverageColor,
                                              CUdeviceptr         scratch,
                                              size_t              scratchSizeInBytes );
 
 
#ifdef __cplusplus
}
#endif
 
#include "optix_function_table.h"
 
#endif  // OPTIX_OPTIX_HOST_H