owl_host.h

Go to the documentation of this file.

// ======================================================================== //
// Copyright 2019-2020 Ingo Wald                                            //
//                                                                          //
// Licensed under the Apache License, Version 2.0 (the "License");          //
// you may not use this file except in compliance with the License.         //
// You may obtain a copy of the License at                                  //
//                                                                          //
//     http://www.apache.org/licenses/LICENSE-2.0                           //
//                                                                          //
// Unless required by applicable law or agreed to in writing, software      //
// distributed under the License is distributed on an "AS IS" BASIS,        //
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
// See the License for the specific language governing permissions and      //
// limitations under the License.                                           //
// ======================================================================== //
 
#pragma once
 
#include <cuda.h>
#include <driver_types.h>
#include <optix.h>
 
#include <sys/types.h>
#include <stdint.h>
 
#ifdef __cplusplus
# include <cstddef> 
#endif
 
 
#if defined(_MSC_VER)
#  define OWL_DLL_EXPORT __declspec(dllexport)
#  define OWL_DLL_IMPORT __declspec(dllimport)
#elif defined(__clang__) || defined(__GNUC__)
#  define OWL_DLL_EXPORT __attribute__((visibility("default")))
#  define OWL_DLL_IMPORT __attribute__((visibility("default")))
#else
#  define OWL_DLL_EXPORT
#  define OWL_DLL_IMPORT
#endif
 
#ifdef __cplusplus
# define OWL_IF_CPP(a) a
#else
# define OWL_IF_CPP(a) /* drop it */
#endif
 
#if defined(OWL_DLL_INTERFACE)
#  ifdef owl_EXPORTS
#    define OWL_API OWL_DLL_EXPORT
#  else
#    define OWL_API OWL_DLL_IMPORT
#  endif
#else
#  ifdef __cplusplus
#    define OWL_API extern "C" OWL_DLL_EXPORT
#  else
#    define OWL_API /* bla */
#  endif
//#  define OWL_API /*static lib*/
#endif
//#ifdef __cplusplus
//# define OWL_API extern "C" OWL_DLL_EXPORT
//#else
//# define OWL_API /* bla */
//#endif
 
 
 
#define OWL_OFFSETOF(type,member)               \
  ((char *)(&((struct type *)0)-> member )      \
   -                                            \
   (char *)(((struct type *)0)))
  
  
typedef enum
  {
   OWL_MATRIX_FORMAT_COLUMN_MAJOR=0,
   
   OWL_MATRIX_FORMAT_OWL=OWL_MATRIX_FORMAT_COLUMN_MAJOR,
   
   OWL_MATRIX_FORMAT_ROW_MAJOR
  } OWLMatrixFormat;
 
typedef enum
  {
   OWL_SBT_HITGROUPS = 0x1,
   OWL_SBT_GEOMS     = OWL_SBT_HITGROUPS,
   OWL_SBT_RAYGENS   = 0x2,
   OWL_SBT_MISSPROGS = 0x4,
   OWL_SBT_ALL   = 0x7
  } OWLBuildSBTFlags;
  
typedef enum
  {
   OWL_INVALID_TYPE = 0,
 
   OWL_BUFFER=10,
   OWL_BUFFER_SIZE,
   OWL_BUFFER_ID,
   OWL_BUFFER_POINTER,
   OWL_BUFPTR=OWL_BUFFER_POINTER,
 
   OWL_GROUP=20,
 
   OWL_DEVICE=30,
 
   OWL_TEXTURE=40,
   OWL_TEXTURE_2D=OWL_TEXTURE,
 
 
   /* all types that are naively copyable should be below this value,
      all that aren't should be above */
   _OWL_BEGIN_COPYABLE_TYPES = 1000,
   
   
   OWL_FLOAT=1000,
   OWL_FLOAT2,
   OWL_FLOAT3,
   OWL_FLOAT4,
 
   OWL_INT=1100,
   OWL_INT2,
   OWL_INT3,
   OWL_INT4,
   
   OWL_UINT=1200,
   OWL_UINT2,
   OWL_UINT3,
   OWL_UINT4,
   
   OWL_LONG=1300,
   OWL_LONG2,
   OWL_LONG3,
   OWL_LONG4,
 
   OWL_ULONG=1400,
   OWL_ULONG2,
   OWL_ULONG3,
   OWL_ULONG4,
 
   OWL_DOUBLE=1500,
   OWL_DOUBLE2,
   OWL_DOUBLE3,
   OWL_DOUBLE4,
    
   OWL_CHAR=1600,
   OWL_CHAR2,
   OWL_CHAR3,
   OWL_CHAR4,
 
   OWL_UCHAR=1700,
   OWL_UCHAR2,
   OWL_UCHAR3,
   OWL_UCHAR4,
 
   OWL_RAW_POINTER=OWL_ULONG,
 
 
   /* matrix formats */
   OWL_AFFINE3F=1800,
 
   OWL_USER_TYPE_BEGIN=10000
  }
  OWLDataType;
 
#define OWL_USER_TYPE(userType) ((OWLDataType)(OWL_USER_TYPE_BEGIN+sizeof(userType)))
 
typedef enum
  {
   // soon to be deprecated old naming
   OWL_GEOMETRY_USER,
   // new naming, to be consistent with type OLWGeom (not OWLGeometry):
   OWL_GEOM_USER=OWL_GEOMETRY_USER,
   // soon to be deprecated old naming
   OWL_GEOMETRY_TRIANGLES,
   // new naming, to be consistent with type OLWGeom (not OWLGeometry):
   OWL_GEOM_TRIANGLES=OWL_GEOMETRY_TRIANGLES,
   OWL_TRIANGLES=OWL_GEOMETRY_TRIANGLES,
   OWL_GEOMETRY_HAIR
  }
  OWLGeomKind;
 
#define OWL_ALL_RAY_TYPES -1
 
 
typedef float    OWL_float;
typedef double   OWL_double;
typedef int32_t  OWL_int;
typedef uint32_t OWL_uint;
typedef int64_t  OWL_long;
typedef uint64_t OWL_ulong;
 
typedef struct _OWL_int2    { int32_t  x,y; } owl2i;
typedef struct _OWL_uint2   { int32_t  x,y; } owl2ui;
typedef struct _OWL_long2   { int64_t  x,y; } owl2l;
typedef struct _OWL_ulong2  { uint64_t x,y; } owl2ul;
typedef struct _OWL_float2  { float    x,y; } owl2f;
typedef struct _OWL_double2 { double   x,y; } owl2d;
 
typedef struct _OWL_int3    { int32_t  x,y,z; } owl3i;
typedef struct _OWL_uint3   { uint32_t x,y,z; } owl3ui;
typedef struct _OWL_long3   { int64_t  x,y,z; } owl3l;
typedef struct _OWL_ulong3  { uint64_t x,y,z; } owl3ul;
typedef struct _OWL_float3  { float    x,y,z; } owl3f;
typedef struct _OWL_double3 { double   x,y,z; } owl3d;
 
typedef struct _OWL_int4    { int32_t  x,y,z,w; } owl4i;
typedef struct _OWL_uint4   { uint32_t x,y,z,w; } owl4ui;
typedef struct _OWL_long4   { int64_t  x,y,z,w; } owl4l;
typedef struct _OWL_ulong4  { uint64_t x,y,z,w; } owl4ul;
typedef struct _OWL_float4  { float    x,y,z,w; } owl4f;
typedef struct _OWL_double4 { double   x,y,z,w; } owl4d;
 
typedef struct _OWL_affine3f { owl3f vx,vy,vz,t; } owl4x3f;
 
typedef struct _OWLVarDecl {
  const char *name;
  OWLDataType type;
  uint32_t    offset;
} OWLVarDecl;
 
 
typedef enum {
  OWL_TEXEL_FORMAT_RGBA8,
  OWL_TEXEL_FORMAT_RGBA32F,
  OWL_TEXEL_FORMAT_R8,
  OWL_TEXEL_FORMAT_R32F
}
OWLTexelFormat;
 
typedef enum {
  OWL_TEXTURE_NEAREST,
  OWL_TEXTURE_LINEAR
}
OWLTextureFilterMode;
 
typedef enum {
  OWL_TEXTURE_WRAP,
  OWL_TEXTURE_CLAMP,
  OWL_TEXTURE_BORDER,
  OWL_TEXTURE_MIRROR
}
OWLTextureAddressMode;
 
 
// ------------------------------------------------------------------
// device-objects - size of those _HAS_ to match the device-side
// definition of these types
// ------------------------------------------------------------------
typedef OptixTraversableHandle OWLDeviceTraversable;
typedef struct _OWLDeviceBuffer2D { void *d_pointer; owl2i dims; } OWLDeviceBuffer2D;
 
 
typedef struct _OWLContext       *OWLContext;
typedef struct _OWLBuffer        *OWLBuffer;
typedef struct _OWLTexture       *OWLTexture;
typedef struct _OWLGeom          *OWLGeom;
typedef struct _OWLGeomType      *OWLGeomType;
typedef struct _OWLVariable      *OWLVariable;
typedef struct _OWLModule        *OWLModule;
typedef struct _OWLGroup         *OWLGroup;
typedef struct _OWLRayGen        *OWLRayGen;
typedef struct _OWLMissProg      *OWLMissProg;
typedef struct _OWLLaunchParams  *OWLLaunchParams, *OWLParams, *OWLGlobals;
 
OWL_API void owlBuildPrograms(OWLContext context);
OWL_API void owlBuildPipeline(OWLContext context);
OWL_API void owlBuildSBT(OWLContext context,
                         OWLBuildSBTFlags flags OWL_IF_CPP(=OWL_SBT_ALL));
 
OWL_API int32_t
owlGetDeviceCount(OWLContext context);
 
OWL_API OWLContext
owlContextCreate(int32_t *requestedDeviceIDs OWL_IF_CPP(=nullptr),
                 int numDevices OWL_IF_CPP(=0));
 
OWL_API void
owlEnableMotionBlur(OWLContext _context);
 
OWL_API void
owlContextSetRayTypeCount(OWLContext context,
                          size_t numRayTypes);
 
OWL_API void
owlSetMaxInstancingDepth(OWLContext context,
                         int32_t maxInstanceDepth);
  
 
OWL_API void
owlContextDestroy(OWLContext context);
 
/* return the cuda stream associated with the given device. */
OWL_API CUstream
owlContextGetStream(OWLContext context, int deviceID);
 
/* return the optix context associated with the given device. */
OWL_API OptixDeviceContext
owlContextGetOptixContext(OWLContext context, int deviceID);
 
OWL_API OWLModule
owlModuleCreate(OWLContext  context,
                const char *ptxCode);
 
OWL_API OWLGeom
owlGeomCreate(OWLContext  context,
              OWLGeomType type);
 
OWL_API OWLParams
owlParamsCreate(OWLContext  context,
                size_t      sizeOfVarStruct,
                OWLVarDecl *vars,
                int         numVars);
 
OWL_API OWLRayGen
owlRayGenCreate(OWLContext  context,
                OWLModule   module,
                const char *programName,
                size_t      sizeOfVarStruct,
                OWLVarDecl *vars,
                int         numVars);
 
OWL_API OWLMissProg
owlMissProgCreate(OWLContext  context,
                  OWLModule   module,
                  const char *programName,
                  size_t      sizeOfVarStruct,
                  OWLVarDecl *vars,
                  int         numVars);
 
OWL_API void
owlMissProgSet(OWLContext  context,
               int rayType,
               OWLMissProg missProgToUse);
 
// ------------------------------------------------------------------
OWL_API OWLGroup
owlUserGeomGroupCreate(OWLContext context,
                       size_t     numGeometries,
                       OWLGeom   *arrayOfChildGeoms);
 
 
// ------------------------------------------------------------------
OWL_API OWLGroup
owlTrianglesGeomGroupCreate(OWLContext context,
                            size_t     numGeometries,
                            OWLGeom   *initValues);
 
// ------------------------------------------------------------------
OWL_API OWLGroup
owlInstanceGroupCreate(OWLContext context,
                       
                       size_t     numInstances,
                       
                       const OWLGroup *initGroups      OWL_IF_CPP(= nullptr),
 
                       const uint32_t *initInstanceIDs OWL_IF_CPP(= nullptr),
                       
                       const float    *initTransforms  OWL_IF_CPP(= nullptr),
                       OWLMatrixFormat matrixFormat    OWL_IF_CPP(=OWL_MATRIX_FORMAT_OWL)
                       );
 
 
 
OWL_API void owlGroupBuildAccel(OWLGroup group);
OWL_API void owlGroupRefitAccel(OWLGroup group);
 
OWL_API OWLGeomType
owlGeomTypeCreate(OWLContext context,
                  OWLGeomKind kind,
                  size_t sizeOfVarStruct,
                  OWLVarDecl *vars,
                  int         numVars);
 
 
OWL_API OWLTexture
owlTexture2DCreate(OWLContext context,
                   OWLTexelFormat texelFormat,
                   uint32_t size_x,
                   uint32_t size_y,
                   const void *texels,
                   OWLTextureFilterMode filterMode OWL_IF_CPP(=OWL_TEXTURE_LINEAR),
                   OWLTextureAddressMode addressMode OWL_IF_CPP(=OWL_TEXTURE_CLAMP),
                   uint32_t linePitchInBytes       OWL_IF_CPP(=0)
                   );
 
OWL_API CUtexObject
owlTextureGetObject(OWLTexture texture, int deviceID);
 
OWL_API void
owlTexture2DDestroy(OWLTexture texture);
 
OWL_API OWLBuffer
owlDeviceBufferCreate(OWLContext  context,
                      OWLDataType type,
                      size_t      count,
                      const void *init);
 
OWL_API OWLBuffer
owlHostPinnedBufferCreate(OWLContext context,
                          OWLDataType type,
                          size_t      count);
 
OWL_API OWLBuffer
owlManagedMemoryBufferCreate(OWLContext context,
                             OWLDataType type,
                             size_t      count,
                             const void *init);
 
OWL_API OWLBuffer
owlGraphicsBufferCreate(OWLContext             context,
                        OWLDataType            type,
                        size_t                 count,
                        cudaGraphicsResource_t resource);
 
OWL_API void
owlGraphicsBufferMap(OWLBuffer buffer);
 
OWL_API void
owlGraphicsBufferUnmap(OWLBuffer buffer);
 
OWL_API const void *
owlBufferGetPointer(OWLBuffer buffer, int deviceID);
 
OWL_API OptixTraversableHandle 
owlGroupGetTraversable(OWLGroup group, int deviceID);
 
OWL_API void 
owlBufferResize(OWLBuffer buffer, size_t newItemCount);
 
OWL_API void 
owlBufferDestroy(OWLBuffer buffer);
 
OWL_API void 
owlBufferUpload(OWLBuffer buffer, const void *hostPtr);
 
OWL_API void
owlRayGenLaunch2D(OWLRayGen rayGen, int dims_x, int dims_y);
 
OWL_API void
owlLaunch2D(OWLRayGen rayGen, int dims_x, int dims_y,
            OWLParams params);
 
OWL_API void
owlAsyncLaunch2D(OWLRayGen rayGen, int dims_x, int dims_y,
                 OWLParams params);
 
 
OWL_API CUstream
owlParamsGetCudaStream(OWLParams params, int deviceID);
 
OWL_API void
owlLaunchSync(OWLParams params);
 
// ==================================================================
// "Triangles" functions
// ==================================================================
OWL_API void owlTrianglesSetVertices(OWLGeom triangles,
                                     OWLBuffer vertices,
                                     size_t count,
                                     size_t stride,
                                     size_t offset);
OWL_API void owlTrianglesSetMotionVertices(OWLGeom triangles,
                                           size_t    numKeys,
                                           OWLBuffer *vertexArrays,
                                           size_t count,
                                           size_t stride,
                                           size_t offset);
OWL_API void owlTrianglesSetIndices(OWLGeom triangles,
                                    OWLBuffer indices,
                                    size_t count,
                                    size_t stride,
                                    size_t offset);
 
// -------------------------------------------------------
// group/hierarchy creation and setting
// -------------------------------------------------------
OWL_API void
owlInstanceGroupSetChild(OWLGroup group,
                         int whichChild,
                         OWLGroup child);
 
OWL_API void
owlInstanceGroupSetTransform(OWLGroup group,
                             int whichChild,
                             const float *floats,
                             OWLMatrixFormat matrixFormat    OWL_IF_CPP(=OWL_MATRIX_FORMAT_OWL));
 
OWL_API void
owlInstanceGroupSetTransforms(OWLGroup group,
                              uint32_t timeStep,
                              const float *floatsForThisStimeStep,
                              OWLMatrixFormat matrixFormat    OWL_IF_CPP(=OWL_MATRIX_FORMAT_OWL));
 
OWL_API void
owlInstanceGroupSetInstanceIDs(OWLGroup group,
                               const uint32_t *instanceIDs);
 
OWL_API void
owlGeomTypeSetClosestHit(OWLGeomType type,
                         int rayType,
                         OWLModule module,
                         const char *progName);
 
OWL_API void
owlGeomTypeSetAnyHit(OWLGeomType type,
                     int rayType,
                     OWLModule module,
                     const char *progName);
 
OWL_API void
owlGeomTypeSetIntersectProg(OWLGeomType type,
                            int rayType,
                            OWLModule module,
                            const char *progName);
 
OWL_API void
owlGeomTypeSetBoundsProg(OWLGeomType type,
                         OWLModule module,
                         const char *progName);
 
OWL_API void
owlGeomSetPrimCount(OWLGeom geom,
                    size_t  primCount);
 
 
// -------------------------------------------------------
// Release for the various types
// -------------------------------------------------------
OWL_API void owlGeomRelease(OWLGeom geometry);
OWL_API void owlVariableRelease(OWLVariable variable);
OWL_API void owlModuleRelease(OWLModule module);
OWL_API void owlBufferRelease(OWLBuffer buffer);
OWL_API void owlRayGenRelease(OWLRayGen rayGen);
OWL_API void owlGroupRelease(OWLGroup group);
 
// -------------------------------------------------------
// VariableGet for the various types
// -------------------------------------------------------
OWL_API OWLVariable
owlGeomGetVariable(OWLGeom geom,
                   const char *varName);
 
OWL_API OWLVariable
owlRayGenGetVariable(OWLRayGen geom,
                     const char *varName);
 
OWL_API OWLVariable
owlMissProgGetVariable(OWLMissProg geom,
                       const char *varName);
 
OWL_API OWLVariable
owlParamsGetVariable(OWLParams object,
                     const char *varName);
 
// -------------------------------------------------------
// VariableSet for different variable types
// -------------------------------------------------------
 
OWL_API void owlVariableSetGroup(OWLVariable variable, OWLGroup value);
OWL_API void owlVariableSetTexture(OWLVariable variable, OWLTexture value);
OWL_API void owlVariableSetBuffer(OWLVariable variable, OWLBuffer value);
OWL_API void owlVariableSetRaw(OWLVariable variable, const void *valuePtr);
OWL_API void owlVariableSetPointer(OWLVariable variable, const void *valuePtr);
#define _OWL_SET_HELPER(stype,abb)                      \
  OWL_API void owlVariableSet1##abb(OWLVariable var,    \
                                    stype v);           \
  OWL_API void owlVariableSet2##abb(OWLVariable var,    \
                                    stype x,            \
                                    stype y);           \
  OWL_API void owlVariableSet3##abb(OWLVariable var,    \
                                    stype x,            \
                                    stype y,            \
                                    stype z);           \
  /*end of macro */
_OWL_SET_HELPER(int32_t,i)
_OWL_SET_HELPER(uint32_t,ui)
_OWL_SET_HELPER(int64_t,l)
_OWL_SET_HELPER(uint64_t,ul)
_OWL_SET_HELPER(float,f)
_OWL_SET_HELPER(double,d)
#undef _OWL_SET_HELPER
 
 
 
 
 
// -------------------------------------------------------
// VariableSet for different *object* types
// -------------------------------------------------------
 
#define _OWL_SET_HELPERS_C(OType,stype,abb)                     \
  /* set1 */                                                    \
  inline void owl##OType##Set1##abb(OWL##OType object,          \
                                    const char *varName,        \
                                    stype v)                    \
  {                                                             \
    OWLVariable var                                             \
      = owl##OType##GetVariable(object,varName);                \
    owlVariableSet1##abb(var,v);                                \
    owlVariableRelease(var);                                    \
  }                                                             \
  /* set2 */                                                    \
  inline void owl##OType##Set2##abb(OWL##OType object,          \
                                    const char *varName,        \
                                    stype x,                    \
                                    stype y)                    \
  {                                                             \
    OWLVariable var                                             \
      = owl##OType##GetVariable(object,varName);                \
    owlVariableSet2##abb(var,x,y);                              \
    owlVariableRelease(var);                                    \
  }                                                             \
  /* set3 */                                                    \
  inline void owl##OType##Set3##abb(OWL##OType object,          \
                                    const char *varName,        \
                                    stype x,                    \
                                    stype y,                    \
                                    stype z)                    \
  {                                                             \
    OWLVariable var                                             \
      = owl##OType##GetVariable(object,varName);                \
    owlVariableSet3##abb(var,x,y,z);                            \
    owlVariableRelease(var);                                    \
  }                                                             \
  /* end of macro */
 
 
#ifdef __cplusplus
#define _OWL_SET_HELPERS_CPP(OType,stype,abb)                   \
  inline void owl##OType##Set2##abb(OWL##OType object,          \
                                    const char *varName,        \
                                    const owl2##abb &v)         \
  {                                                             \
    OWLVariable var                                             \
      = owl##OType##GetVariable(object,varName);                \
    owlVariableSet2##abb(var,v.x,v.y);                          \
    owlVariableRelease(var);                                    \
  }                                                             \
  inline void owl##OType##Set3##abb(OWL##OType object,          \
                                    const char *varName,        \
                                    const owl3##abb &v)         \
  {                                                             \
    OWLVariable var                                             \
      = owl##OType##GetVariable(object,varName);                \
    owlVariableSet3##abb(var,v.x,v.y,v.z);                      \
    owlVariableRelease(var);                                    \
  }                                                             \
  /* end of macro */
#else
#define _OWL_SET_HELPERS_CPP(OType,stype,abb)  /* ignore in C99 mode */
#endif
 
#define _OWL_SET_HELPERS(Type)                                  \
  /* texture, buffer, other */                                  \
  inline void owl##Type##SetTexture(OWL##Type object,           \
                                    const char *varName,        \
                                    OWLTexture v)               \
  {                                                             \
    OWLVariable var                                             \
      = owl##Type##GetVariable(object,varName);                 \
    owlVariableSetTexture(var,v);                               \
    owlVariableRelease(var);                                    \
  }                                                             \
  /* group, buffer, other */                                    \
  inline void owl##Type##SetGroup(OWL##Type object,             \
                                  const char *varName,          \
                                  OWLGroup v)                   \
  {                                                             \
    OWLVariable var                                             \
      = owl##Type##GetVariable(object,varName);                 \
    owlVariableSetGroup(var,v);                                 \
    owlVariableRelease(var);                                    \
  }                                                             \
  inline void owl##Type##SetRaw(OWL##Type object,               \
                                const char *varName,            \
                                const void *v)                  \
  {                                                             \
    OWLVariable var                                             \
      = owl##Type##GetVariable(object,varName);                 \
    owlVariableSetRaw(var,v);                                   \
    owlVariableRelease(var);                                    \
  }                                                             \
  inline void owl##Type##SetPointer(OWL##Type object,           \
                                    const char *varName,        \
                                    const void *v)              \
  {                                                             \
    OWLVariable var                                             \
      = owl##Type##GetVariable(object,varName);                 \
    owlVariableSetPointer(var,v);                               \
    owlVariableRelease(var);                                    \
  }                                                             \
  inline void owl##Type##SetBuffer(OWL##Type object,            \
                                   const char *varName,         \
                                   OWLBuffer v)                 \
  {                                                             \
    OWLVariable var                                             \
      = owl##Type##GetVariable(object,varName);                 \
    owlVariableSetBuffer(var,v);                                \
    owlVariableRelease(var);                                    \
  }                                                             \
                                                                \
  _OWL_SET_HELPERS_C(Type,int32_t,i)                            \
  _OWL_SET_HELPERS_C(Type,uint32_t,ui)                          \
  _OWL_SET_HELPERS_C(Type,int64_t,l)                            \
  _OWL_SET_HELPERS_C(Type,uint64_t,ul)                          \
  _OWL_SET_HELPERS_C(Type,float,f)                              \
  _OWL_SET_HELPERS_C(Type,double,d)                             \
  _OWL_SET_HELPERS_CPP(Type,int32_t,i)                          \
  _OWL_SET_HELPERS_CPP(Type,uint32_t,ui)                        \
  _OWL_SET_HELPERS_CPP(Type,int64_t,l)                          \
  _OWL_SET_HELPERS_CPP(Type,uint64_t,ul)                        \
  _OWL_SET_HELPERS_CPP(Type,float,f)                            \
  _OWL_SET_HELPERS_CPP(Type,double,d)                           \
  /* end of macro */
 
  _OWL_SET_HELPERS(RayGen)
  _OWL_SET_HELPERS(Geom)
  _OWL_SET_HELPERS(Params)
  _OWL_SET_HELPERS(MissProg)
 
#undef _OWL_SET_HELPERS_CPP
#undef _OWL_SET_HELPERS_C
#undef _OWL_SET_HELPERS
 
 
#ifdef __cplusplus
 
  inline void
  owlInstanceGroupSetTransform(OWLGroup group,
                               int childID,
                               const owl4x3f &xfm)
  {
    owlInstanceGroupSetTransform(group,childID,(const float *)&xfm,
                                 OWL_MATRIX_FORMAT_OWL);
  }
inline void
owlInstanceGroupSetTransform(OWLGroup group,
                             int childID,
                             const owl4x3f *xfm)
{
  owlInstanceGroupSetTransform(group,childID,(const float *)xfm,
                               OWL_MATRIX_FORMAT_OWL);
}
 
#endif