optixu.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008 - 2009 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_optixu_h__
#define __optix_optixu_h__

#include <stddef.h>
#include "../optix.h"

#ifdef __cplusplus
#  define RTU_INLINE inline
#else
#  ifdef _MSC_VER
#    define RTU_INLINE __inline
#  else
#    define RTU_INLINE static inline
#  endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

  RTresult RTAPI rtuNameForType( RTobjecttype type, char* buffer, RTsize bufferSize );

  RTresult RTAPI rtuGetSizeForRTformat( RTformat format, size_t* size);

  RTresult RTAPI rtuCUDACompileString( const char* source, const char** preprocessorArguments, unsigned int numPreprocessorArguments, RTsize* resultSize, RTsize* errorSize );

  RTresult RTAPI rtuCUDACompileFile( const char* filename, const char** preprocessorArguments, unsigned int numPreprocessorArguments, RTsize* resultSize, RTsize* errorSize );

  RTresult RTAPI rtuCUDAGetCompileResult( char* result, char* error );

#ifdef __cplusplus
} /* extern "C" */
#endif

#ifndef __cplusplus
 RTU_INLINE RTresult rtuGroupAddChild        ( RTgroup group, RTobject child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorAddChild     ( RTselector selector, RTobject child, unsigned int* index );
#else
 RTU_INLINE RTresult rtuGroupAddChild        ( RTgroup group, RTgroup         child, unsigned int* index );
 RTU_INLINE RTresult rtuGroupAddChild        ( RTgroup group, RTselector      child, unsigned int* index );
 RTU_INLINE RTresult rtuGroupAddChild        ( RTgroup group, RTtransform     child, unsigned int* index );
 RTU_INLINE RTresult rtuGroupAddChild        ( RTgroup group, RTgeometrygroup child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorAddChild     ( RTselector selector, RTgroup         child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorAddChild     ( RTselector selector, RTselector      child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorAddChild     ( RTselector selector, RTtransform     child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorAddChild     ( RTselector selector, RTgeometrygroup child, unsigned int* index );
#endif
 RTU_INLINE RTresult rtuGeometryGroupAddChild( RTgeometrygroup geometrygroup, RTgeometryinstance child, unsigned int* index );
#ifndef __cplusplus
 RTU_INLINE RTresult rtuTransformSetChild    ( RTtransform transform, RTobject        child );
#else
 RTU_INLINE RTresult rtuTransformSetChild    ( RTtransform transform, RTgroup         child );
 RTU_INLINE RTresult rtuTransformSetChild    ( RTtransform transform, RTselector      child );
 RTU_INLINE RTresult rtuTransformSetChild    ( RTtransform transform, RTtransform     child );
 RTU_INLINE RTresult rtuTransformSetChild    ( RTtransform transform, RTgeometrygroup child );
#endif

 RTU_INLINE RTresult rtuTransformGetChild       ( RTtransform transform, RTobject* type );
 RTU_INLINE RTresult rtuTransformGetChildType   ( RTtransform transform, RTobjecttype* type );
 RTU_INLINE RTresult rtuGroupRemoveChild        ( RTgroup group, RTobject child );
 RTU_INLINE RTresult rtuSelectorRemoveChild     ( RTselector selector, RTobject child );
 RTU_INLINE RTresult rtuGeometryGroupRemoveChild( RTgeometrygroup geometrygroup, RTgeometryinstance child );
 RTU_INLINE RTresult rtuGroupRemoveChildByIndex        ( RTgroup group, unsigned int index );
 RTU_INLINE RTresult rtuSelectorRemoveChildByIndex     ( RTselector selector, unsigned int index );
 RTU_INLINE RTresult rtuGeometryGroupRemoveChildByIndex( RTgeometrygroup geometrygroup, unsigned int index );
 RTU_INLINE RTresult rtuGroupGetChildIndex        ( RTgroup group, RTobject child, unsigned int* index );
 RTU_INLINE RTresult rtuSelectorGetChildIndex     ( RTselector selector, RTobject child, unsigned int* index );
 RTU_INLINE RTresult rtuGeometryGroupGetChildIndex( RTgeometrygroup geometrygroup, RTgeometryinstance child, unsigned int* index );
 /*
  * The following implements the child management helpers declared above.
  */

#define RTU_CHECK_ERROR( func )                 \
  do {                                          \
    RTresult code = func;                       \
    if( code != RT_SUCCESS )                    \
      return code;                              \
  } while(0)

#define RTU_GROUP_ADD_CHILD( _parent, _child, _index )                  \
  unsigned int _count;                                                  \
  RTU_CHECK_ERROR( rtGroupGetChildCount( (_parent), &_count ) );        \
  RTU_CHECK_ERROR( rtGroupSetChildCount( (_parent), _count+1 ) );       \
  RTU_CHECK_ERROR( rtGroupSetChild( (_parent), _count, (_child) ) );    \
  if( _index ) *(_index) = _count;                                      \
  return RT_SUCCESS

#define RTU_SELECTOR_ADD_CHILD( _parent, _child, _index )               \
  unsigned int _count;                                                  \
  RTU_CHECK_ERROR( rtSelectorGetChildCount( (_parent), &_count ) );     \
  RTU_CHECK_ERROR( rtSelectorSetChildCount( (_parent), _count+1 ) );    \
  RTU_CHECK_ERROR( rtSelectorSetChild( (_parent), _count, (_child) ) ); \
  if( _index ) *(_index) = _count;                                      \
  return RT_SUCCESS


#ifndef __cplusplus

 RTU_INLINE RTresult rtuGroupAddChild( RTgroup group, RTobject child, unsigned int* index )
 {
   RTU_GROUP_ADD_CHILD( group, child, index );
 }

 RTU_INLINE RTresult rtuSelectorAddChild( RTselector selector, RTobject child, unsigned int* index )
 {
   RTU_SELECTOR_ADD_CHILD( selector, child, index );
 }

#else /* __cplusplus */

 RTU_INLINE RTresult rtuGroupAddChild( RTgroup group, RTgroup child, unsigned int* index )
 {
   RTU_GROUP_ADD_CHILD( group, child, index );
 }

 RTU_INLINE RTresult rtuGroupAddChild( RTgroup group, RTselector child, unsigned int* index )
 {
   RTU_GROUP_ADD_CHILD( group, child, index );
 }

 RTU_INLINE RTresult rtuGroupAddChild( RTgroup group, RTtransform child, unsigned int* index )
 {
   RTU_GROUP_ADD_CHILD( group, child, index );
 }

 RTU_INLINE RTresult rtuGroupAddChild( RTgroup group, RTgeometrygroup child, unsigned int* index )
 {
   RTU_GROUP_ADD_CHILD( group, child, index );
 }

 RTU_INLINE RTresult rtuSelectorAddChild( RTselector selector, RTgroup child, unsigned int* index )
 {
   RTU_SELECTOR_ADD_CHILD( selector, child, index );
 }

 RTU_INLINE RTresult rtuSelectorAddChild( RTselector selector, RTselector child, unsigned int* index )
 {
   RTU_SELECTOR_ADD_CHILD( selector, child, index );
 }

 RTU_INLINE RTresult rtuSelectorAddChild( RTselector selector, RTtransform child, unsigned int* index )
 {
   RTU_SELECTOR_ADD_CHILD( selector, child, index );
 }

 RTU_INLINE RTresult rtuSelectorAddChild( RTselector selector, RTgeometrygroup child, unsigned int* index )
 {
   RTU_SELECTOR_ADD_CHILD( selector, child, index );
 }

#endif /* __cplusplus */

#undef RTU_GROUP_ADD_CHILD
#undef RTU_SELECTOR_ADD_CHILD

#ifndef __cplusplus

 RTU_INLINE RTresult rtuTransformSetChild( RTtransform transform, RTobject child )
 {
   RTU_CHECK_ERROR( rtTransformSetChild( transform, child ) );
   return RT_SUCCESS;
 }

#else /* __cplusplus */

 RTU_INLINE RTresult rtuTransformSetChild( RTtransform transform, RTgroup child )
 {
   RTU_CHECK_ERROR( rtTransformSetChild( transform, child ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuTransformSetChild( RTtransform transform, RTselector child )
 {
   RTU_CHECK_ERROR( rtTransformSetChild( transform, child ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuTransformSetChild( RTtransform transform, RTtransform child )
 {
   RTU_CHECK_ERROR( rtTransformSetChild( transform, child ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuTransformSetChild( RTtransform transform, RTgeometrygroup child )
 {
   RTU_CHECK_ERROR( rtTransformSetChild( transform, child ) );
   return RT_SUCCESS;
 }

#endif /* __cplusplus */

 RTU_INLINE RTresult rtuTransformGetChild ( RTtransform transform, RTobject* type )
 {
   RTU_CHECK_ERROR( rtTransformGetChild( transform, type ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuTransformGetChildType ( RTtransform transform, RTobjecttype* type )
 {
   RTU_CHECK_ERROR( rtTransformGetChildType( transform, type ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGeometryGroupAddChild( RTgeometrygroup geometrygroup, RTgeometryinstance child, unsigned int* index )
 {
   unsigned int count;
   RTU_CHECK_ERROR( rtGeometryGroupGetChildCount( geometrygroup, &count ) );
   RTU_CHECK_ERROR( rtGeometryGroupSetChildCount( geometrygroup, count+1 ) );
   RTU_CHECK_ERROR( rtGeometryGroupSetChild( geometrygroup, count, child ) );
   if( index ) *index = count;
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGroupRemoveChild( RTgroup group, RTobject child )
 {
   unsigned int index;
   RTU_CHECK_ERROR( rtuGroupGetChildIndex( group, child, &index ) );
   RTU_CHECK_ERROR( rtuGroupRemoveChildByIndex( group, index ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuSelectorRemoveChild( RTselector selector, RTobject child )
 {
   unsigned int index;
   RTU_CHECK_ERROR( rtuSelectorGetChildIndex( selector, child, &index ) );
   RTU_CHECK_ERROR( rtuSelectorRemoveChildByIndex( selector, index ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGeometryGroupRemoveChild( RTgeometrygroup geometrygroup, RTgeometryinstance child )
 {
   unsigned int index;
   RTU_CHECK_ERROR( rtuGeometryGroupGetChildIndex( geometrygroup, child, &index ) );
   RTU_CHECK_ERROR( rtuGeometryGroupRemoveChildByIndex( geometrygroup, index ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGroupRemoveChildByIndex( RTgroup group, unsigned int index )
 {
   unsigned int count;
   RTobject temp;
   RTU_CHECK_ERROR( rtGroupGetChildCount( group, &count ) );
   RTU_CHECK_ERROR( rtGroupGetChild( group, count-1, &temp ) );
   RTU_CHECK_ERROR( rtGroupSetChild( group, index, temp ) );
   RTU_CHECK_ERROR( rtGroupSetChildCount( group, count-1 ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuSelectorRemoveChildByIndex( RTselector selector, unsigned int index )
 {
   unsigned int count;
   RTobject temp;
   RTU_CHECK_ERROR( rtSelectorGetChildCount( selector, &count ) );
   RTU_CHECK_ERROR( rtSelectorGetChild( selector, count-1, &temp ) );
   RTU_CHECK_ERROR( rtSelectorSetChild( selector, index, temp ) );
   RTU_CHECK_ERROR( rtSelectorSetChildCount( selector, count-1 ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGeometryGroupRemoveChildByIndex( RTgeometrygroup geometrygroup, unsigned int index )
 {
   unsigned int count;
   RTgeometryinstance temp;
   RTU_CHECK_ERROR( rtGeometryGroupGetChildCount( geometrygroup, &count ) );
   RTU_CHECK_ERROR( rtGeometryGroupGetChild( geometrygroup, count-1, &temp ) );
   RTU_CHECK_ERROR( rtGeometryGroupSetChild( geometrygroup, index, temp ) );
   RTU_CHECK_ERROR( rtGeometryGroupSetChildCount( geometrygroup, count-1 ) );
   return RT_SUCCESS;
 }

 RTU_INLINE RTresult rtuGroupGetChildIndex(RTgroup group, RTobject child, unsigned int* index)
 {
   unsigned int count;
   RTobject temp;
   RTU_CHECK_ERROR( rtGroupGetChildCount( group, &count ) );
   for( *index=0; *index<count; (*index)++ ) {
     RTU_CHECK_ERROR( rtGroupGetChild( group, *index, &temp ) );
     if( child==temp ) return RT_SUCCESS;
   }
   *index = ~0u;
   return RT_ERROR_INVALID_VALUE;
 }

 RTU_INLINE RTresult rtuSelectorGetChildIndex( RTselector selector, RTobject child, unsigned int* index )
 {
   unsigned int count;
   RTobject temp;
   RTU_CHECK_ERROR( rtSelectorGetChildCount( selector, &count ) );
   for( *index=0; *index<count; (*index)++ ) {
     RTU_CHECK_ERROR( rtSelectorGetChild( selector, *index, &temp ) );
     if( child==temp ) return RT_SUCCESS;
   }
   *index = ~0u;
   return RT_ERROR_INVALID_VALUE;
 }

 RTU_INLINE RTresult rtuGeometryGroupGetChildIndex( RTgeometrygroup geometrygroup, RTgeometryinstance child, unsigned int* index )
 {
   unsigned int count;
   RTgeometryinstance temp;
   RTU_CHECK_ERROR( rtGeometryGroupGetChildCount( geometrygroup, &count ) );
   for( *index=0; *index<count; (*index)++ ) {
     RTU_CHECK_ERROR( rtGeometryGroupGetChild( geometrygroup, *index, &temp ) );
     if( child==temp ) return RT_SUCCESS;
   }
   *index = ~0u;
   return RT_ERROR_INVALID_VALUE;
 }


#ifdef __cplusplus
extern "C" {
#endif

  RTresult RTAPI rtuCreateClusteredMesh( RTcontext       context,
                                         unsigned int    usePTX32InHost64,
                                         RTgeometry*     mesh,
                                         unsigned int    num_verts,
                                         const float*    verts,
                                         unsigned int    num_tris,
                                         const unsigned* indices,
                                         const unsigned* mat_indices);



  RTresult RTAPI rtuCreateClusteredMeshExt( RTcontext       context,
                                            unsigned int    usePTX32InHost64,
                                            RTgeometry*     mesh,
                                            unsigned int    num_verts,
                                            const float*    verts,
                                            unsigned int    num_tris,
                                            const unsigned* indices,
                                            const unsigned* mat_indices,
                                            RTbuffer        norms,
                                            const unsigned* norm_indices,
                                            RTbuffer        tex_coords,
                                            const unsigned* tex_indices );

#ifdef __cplusplus
} /* extern "C" */
#endif


#undef RTU_CHECK_ERROR
#undef RTU_INLINE

#endif /* __optix_optixu_h__ */