optixpp_namespace.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 __optixu_optixpp_namespace_h__
#define __optixu_optixpp_namespace_h__

#include "../optix.h"

#ifdef _WIN32
#  ifndef WIN32_LEAN_AND_MEAN
#    define WIN32_LEAN_AND_MEAN
#  endif
#  include <windows.h>
#  include "../optix_d3d9_interop.h"
#  include "../optix_d3d10_interop.h"
#  include "../optix_d3d11_interop.h"
#endif
#include "../optix_gl_interop.h"
#include "../optix_cuda_interop.h"

#include <string>
#include <vector>
#include <iterator>
#include "optixu_vector_types.h"

//-----------------------------------------------------------------------------
//
// Doxygen group specifications
//
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// 
// C++ API
//
//-----------------------------------------------------------------------------

namespace optix {
  
  class AccelerationObj;
  class BufferObj;
  class ContextObj;
  class GeometryObj;
  class GeometryGroupObj;
  class GeometryInstanceObj;
  class GroupObj;
  class MaterialObj;
  class ProgramObj;
  class RemoteDeviceObj;
  class SelectorObj;
  class TextureSamplerObj;
  class TransformObj;
  class VariableObj;

  class APIObj;
  class ScopedObj;
  

  template<class T>
  class Handle {
  public:
    Handle() : ptr(0) {}

    Handle(T* ptr) : ptr(ptr) { ref(); }

    template<class U>
    Handle(U* ptr) : ptr(ptr) { ref(); }

    Handle(const Handle<T>& copy) : ptr(copy.ptr) { ref(); }
    
    template<class U>
    Handle(const Handle<U>& copy) : ptr(copy.ptr) { ref(); }

    Handle<T>& operator=(const Handle<T>& copy)
    { if(ptr != copy.ptr) { unref(); ptr = copy.ptr; ref(); } return *this; }
    
    template<class U>
    Handle<T>& operator=( const Handle<U>& copy)
    { if(ptr != copy.ptr) { unref(); ptr = copy.ptr; ref(); } return *this; }

    ~Handle() { unref(); }

    static Handle<T> take( typename T::api_t p ) { return p? new T(p) : 0; }
    static Handle<T> take( RTobject p ) { return p? new T(static_cast<typename T::api_t>(p)) : 0; }

          T* operator->()           { return ptr; }
    const T* operator->() const     { return ptr; }

          T* get()                  { return ptr; }
    const T* get() const            { return ptr; }

    operator bool() const  { return ptr != 0; }

    Handle<VariableObj> operator[](const std::string& varname);

    Handle<VariableObj> operator[](const char* varname);

    static Handle<T> create() { return T::create(); }

    static Handle<T> create(const std::string& a, const std::string& b, const std::string& c) { return T::create(a,b,c); }

    static unsigned int getDeviceCount() { return T::getDeviceCount(); }

  private:
    inline void ref() { if(ptr) ptr->addReference(); }
    inline void unref() { if(ptr && ptr->removeReference() == 0) delete ptr; }
    T* ptr;
  };


  //----------------------------------------------------------------------------

  typedef Handle<AccelerationObj>     Acceleration;     
  typedef Handle<BufferObj>           Buffer;           
  typedef Handle<ContextObj>          Context;          
  typedef Handle<GeometryObj>         Geometry;         
  typedef Handle<GeometryGroupObj>    GeometryGroup;    
  typedef Handle<GeometryInstanceObj> GeometryInstance; 
  typedef Handle<GroupObj>            Group;            
  typedef Handle<MaterialObj>         Material;         
  typedef Handle<ProgramObj>          Program;          
  typedef Handle<RemoteDeviceObj>     RemoteDevice;     
  typedef Handle<SelectorObj>         Selector;         
  typedef Handle<TextureSamplerObj>   TextureSampler;   
  typedef Handle<TransformObj>        Transform;        
  typedef Handle<VariableObj>         Variable;         


  //----------------------------------------------------------------------------


  class Exception: public std::exception {
  public:
    Exception( const std::string& message, RTresult error_code = RT_ERROR_UNKNOWN )
      : m_message(message), m_error_code( error_code ) {}

    virtual ~Exception() throw() {}

    const std::string& getErrorString() const { return m_message; }
  
    RTresult getErrorCode() const { return m_error_code; }

    static Exception makeException( RTresult code, RTcontext context );

    virtual const char* what() const throw() { return getErrorString().c_str(); }
  private:
    std::string m_message;
    RTresult    m_error_code;
  };

  inline Exception Exception::makeException( RTresult code, RTcontext context )
  {
    const char* str;
    rtContextGetErrorString( context, code, &str);
    return Exception( std::string(str), code );
  }


  //----------------------------------------------------------------------------


  class APIObj {
  public:
    APIObj() : ref_count(0) {}
    virtual ~APIObj() {}

    void addReference()    { ++ref_count; }
    int  removeReference() { return --ref_count; }

    virtual Context getContext()const=0;

    virtual void checkError(RTresult code)const;
    virtual void checkError(RTresult code, Context context )const;
    
    void checkErrorNoGetContext(RTresult code)const;

    static Exception makeException( RTresult code, RTcontext context );
  private:
    int ref_count;
  };

  inline Exception APIObj::makeException( RTresult code, RTcontext context )
  {
    return Exception::makeException( code, context );
  }


  //----------------------------------------------------------------------------


  class DestroyableObj : public APIObj {
  public:
    virtual ~DestroyableObj() {}

    virtual void destroy() = 0;

    virtual void validate() = 0;
  };


  
  //----------------------------------------------------------------------------


  class ScopedObj : public DestroyableObj {
  public:
    virtual ~ScopedObj() {}

    virtual Variable declareVariable(const std::string& name) = 0;
    virtual Variable queryVariable(const std::string& name) const = 0;
    virtual void removeVariable(Variable v) = 0;
    virtual unsigned int getVariableCount() const = 0;
    virtual Variable getVariable(unsigned int index) const = 0;
  };

  
  
  //----------------------------------------------------------------------------


  class VariableObj : public APIObj {
  public:

    Context getContext() const;


    void setFloat(float f1);
    void setFloat(optix::float2 f);
    void setFloat(float f1, float f2);
    void setFloat(optix::float3 f);
    void setFloat(float f1, float f2, float f3);
    void setFloat(optix::float4 f);
    void setFloat(float f1, float f2, float f3, float f4);
    void set1fv(const float* f);
    void set2fv(const float* f);
    void set3fv(const float* f);
    void set4fv(const float* f);


    void setInt(int i1);
    void setInt(int i1, int i2);
    void setInt(optix::int2 i);
    void setInt(int i1, int i2, int i3);
    void setInt(optix::int3 i);
    void setInt(int i1, int i2, int i3, int i4);
    void setInt(optix::int4 i);
    void set1iv(const int* i);
    void set2iv(const int* i);
    void set3iv(const int* i);
    void set4iv(const int* i);


    void setUint(unsigned int u1);
    void setUint(unsigned int u1, unsigned int u2);
    void setUint(unsigned int u1, unsigned int u2, unsigned int u3);
    void setUint(unsigned int u1, unsigned int u2, unsigned int u3, unsigned int u4);
    void setUint(optix::uint2 u);
    void setUint(optix::uint3 u);
    void setUint(optix::uint4 u);
    void set1uiv(const unsigned int* u);
    void set2uiv(const unsigned int* u);
    void set3uiv(const unsigned int* u);
    void set4uiv(const unsigned int* u);


    void setMatrix2x2fv(bool transpose, const float* m);
    void setMatrix2x3fv(bool transpose, const float* m);
    void setMatrix2x4fv(bool transpose, const float* m);
    void setMatrix3x2fv(bool transpose, const float* m);
    void setMatrix3x3fv(bool transpose, const float* m);
    void setMatrix3x4fv(bool transpose, const float* m);
    void setMatrix4x2fv(bool transpose, const float* m);
    void setMatrix4x3fv(bool transpose, const float* m);
    void setMatrix4x4fv(bool transpose, const float* m);


    
    float         getFloat()  const;
    optix::float2 getFloat2() const;
    optix::float3 getFloat3() const;
    optix::float4 getFloat4() const;
    void          getFloat(float& f1) const;
    void          getFloat(float& f1, float& f2) const;
    void          getFloat(float& f1, float& f2, float& f3) const;
    void          getFloat(float& f1, float& f2, float& f3, float& f4) const;

    unsigned      getUint()  const;
    optix::uint2  getUint2() const;
    optix::uint3  getUint3() const;
    optix::uint4  getUint4() const;
    void          getUint(unsigned& u1) const;
    void          getUint(unsigned& u1, unsigned& u2) const;
    void          getUint(unsigned& u1, unsigned& u2, unsigned& u3) const;
    void          getUint(unsigned& u1, unsigned& u2, unsigned& u3,
                          unsigned& u4) const;

    int           getInt()  const;
    optix::int2   getInt2() const;
    optix::int3   getInt3() const;
    optix::int4   getInt4() const;
    void          getInt(int& i1) const;
    void          getInt(int& i1, int& i2) const;
    void          getInt(int& i1, int& i2, int& i3) const;
    void          getInt(int& i1, int& i2, int& i3, int& i4) const;

    void getMatrix2x2(bool transpose, float* m) const;
    void getMatrix2x3(bool transpose, float* m) const;
    void getMatrix2x4(bool transpose, float* m) const;
    void getMatrix3x2(bool transpose, float* m) const;
    void getMatrix3x3(bool transpose, float* m) const;
    void getMatrix3x4(bool transpose, float* m) const;
    void getMatrix4x2(bool transpose, float* m) const;
    void getMatrix4x3(bool transpose, float* m) const;
    void getMatrix4x4(bool transpose, float* m) const;




    void setBuffer(Buffer buffer);
    void set(Buffer buffer);
    void setTextureSampler(TextureSampler texturesample);
    void set(TextureSampler texturesample);
    void set(GeometryGroup group);
    void set(Group group);
    void set(Program program);
    void setProgramId(Program program);
    void set(Selector selector);
    void set(Transform transform);


    Buffer           getBuffer() const;
    GeometryGroup    getGeometryGroup() const;
    GeometryInstance getGeometryInstance() const;
    Group            getGroup() const;
    Program          getProgram() const;
    Selector         getSelector() const;
    TextureSampler   getTextureSampler() const;
    Transform        getTransform() const;


    void setUserData(RTsize size, const void* ptr);
    void getUserData(RTsize size,       void* ptr) const;

    std::string getName() const;
    
    std::string getAnnotation() const;

    RTobjecttype getType() const;

    RTvariable get();

    RTsize getSize() const;

  private:
    typedef RTvariable api_t;

    RTvariable m_variable;
    VariableObj(RTvariable variable) : m_variable(variable) {}
    friend class Handle<VariableObj>;

  };

  template<class T>
  Handle<VariableObj> Handle<T>::operator[](const std::string& varname)
  {
    Variable v = ptr->queryVariable( varname );
    if( v.operator->() == 0)
      v = ptr->declareVariable( varname );
    return v;
  }

  template<class T>
  Handle<VariableObj> Handle<T>::operator[](const char* varname) 
  {
    return (*this)[ std::string( varname ) ]; 
  }

  
  //----------------------------------------------------------------------------


  class ContextObj : public ScopedObj {
  public:

    static unsigned int getDeviceCount();

    static std::string getDeviceName(int ordinal);
    
    static void getDeviceAttribute(int ordinal, RTdeviceattribute attrib, RTsize size, void* p);

    static Context create();

    void destroy();

    void validate();

    Context getContext() const;

    void checkError(RTresult code)const;

    std::string getErrorString( RTresult code ) const;

    Acceleration createAcceleration(const char* builder, const char* traverser);

    Buffer createBuffer(unsigned int type);
    Buffer createBuffer(unsigned int type, RTformat format);
    Buffer createBuffer(unsigned int type, RTformat format, RTsize width);
    Buffer createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, unsigned int levels);
    Buffer createBuffer(unsigned int type, RTformat format, RTsize width, RTsize height);
    Buffer createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, unsigned int levels);
    Buffer createBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth);
    Buffer createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth, unsigned int levels);  
    
    Buffer create1DLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize layers, unsigned int levels);
    Buffer create2DLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize layers, unsigned int levels);
    Buffer createCubeBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, unsigned int levels);
    Buffer createCubeLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize faces, unsigned int levels);

    Buffer createBufferForCUDA(unsigned int type);
    Buffer createBufferForCUDA(unsigned int type, RTformat format);
    Buffer createBufferForCUDA(unsigned int type, RTformat format, RTsize width);
    Buffer createBufferForCUDA(unsigned int type, RTformat format, RTsize width, RTsize height);
    Buffer createBufferForCUDA(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth);

    Buffer createBufferFromGLBO(unsigned int type, unsigned int vbo);

    TextureSampler createTextureSamplerFromGLImage(unsigned int id, RTgltarget target);

#ifdef _WIN32
    Buffer createBufferFromD3D9Resource(unsigned int type, IDirect3DResource9 *pResource);
    Buffer createBufferFromD3D10Resource(unsigned int type, ID3D10Resource *pResource);
    Buffer createBufferFromD3D11Resource(unsigned int type, ID3D11Resource *pResource);

    TextureSampler createTextureSamplerFromD3D9Resource(IDirect3DResource9 *pResource);
    TextureSampler createTextureSamplerFromD3D10Resource(ID3D10Resource *pResource);
    TextureSampler createTextureSamplerFromD3D11Resource(ID3D11Resource *pResource);
#endif

    Buffer getBufferFromId(int buffer_id);
       
    Program getProgramFromId(int program_id);
       
    TextureSampler getTextureSamplerFromId(int sampler_id);

    Geometry createGeometry();
    GeometryInstance createGeometryInstance();
    template<class Iterator>
    GeometryInstance createGeometryInstance( Geometry geometry, Iterator matlbegin, Iterator matlend );

    Group createGroup();
    template<class Iterator>
    Group createGroup( Iterator childbegin, Iterator childend );

    GeometryGroup createGeometryGroup();
    template<class Iterator>
    GeometryGroup createGeometryGroup( Iterator childbegin, Iterator childend );

    Transform createTransform();

    Material createMaterial();

    Program createProgramFromPTXFile  ( const std::string& ptx, const std::string& program_name );
    Program createProgramFromPTXString( const std::string& ptx, const std::string& program_name );

    Selector createSelector();

    TextureSampler createTextureSampler();

    template<class Iterator>
    void setDevices(Iterator begin, Iterator end);

#ifdef _WIN32
    void setD3D9Device(IDirect3DDevice9* device);
    void setD3D10Device(ID3D10Device* device);
    void setD3D11Device(ID3D11Device* device);
#endif

    std::vector<int> getEnabledDevices() const;

    unsigned int getEnabledDeviceCount() const;

    int getMaxTextureCount() const;

    int getCPUNumThreads() const;

    RTsize getUsedHostMemory() const;

    int getGPUPagingActive() const;

    int getGPUPagingForcedOff() const;

    RTsize getAvailableDeviceMemory(int ordinal) const;

    void setCPUNumThreads(int cpu_num_threads);

    void setGPUPagingForcedOff(int gpu_paging_forced_off);

    template<class T>
    void setAttribute(RTcontextattribute attribute, const T& val);

    void setStackSize(RTsize  stack_size_bytes);
    RTsize getStackSize() const;

    void setTimeoutCallback(RTtimeoutcallback callback, double min_polling_seconds);

    void setEntryPointCount(unsigned int  num_entry_points);
    unsigned int getEntryPointCount() const;

    void setRayTypeCount(unsigned int  num_ray_types);
    unsigned int getRayTypeCount() const;

    void setRayGenerationProgram(unsigned int entry_point_index, Program  program);
    Program getRayGenerationProgram(unsigned int entry_point_index) const;

    void setExceptionProgram(unsigned int entry_point_index, Program  program);
    Program getExceptionProgram(unsigned int entry_point_index) const;

    void setExceptionEnabled( RTexception exception, bool enabled );
    bool getExceptionEnabled( RTexception exception ) const;

    void setMissProgram(unsigned int ray_type_index, Program  program);
    Program getMissProgram(unsigned int ray_type_index) const;

    void compile();

    void launch(unsigned int entry_point_index, RTsize image_width);
    void launch(unsigned int entry_point_index, RTsize image_width, RTsize image_height);
    void launch(unsigned int entry_point_index, RTsize image_width, RTsize image_height, RTsize image_depth);

    void launchProgressive(unsigned int entry_point_index, RTsize image_width, RTsize image_height, unsigned int max_subframes); 

    void stopProgressive();

    void setRemoteDevice( RemoteDevice remote_device );

    int getRunningState() const;

    void setPrintEnabled(bool enabled);
    bool getPrintEnabled() const;
    void setPrintBufferSize(RTsize buffer_size_bytes);
    RTsize getPrintBufferSize() const;
    void setPrintLaunchIndex(int x, int y=-1, int z=-1);
    optix::int3 getPrintLaunchIndex() const;

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;

    RTcontext get();
  private:
    typedef RTcontext api_t;

    virtual ~ContextObj() {}
    RTcontext m_context;
    ContextObj(RTcontext context) : m_context(context) {}
    friend class Handle<ContextObj>;
  };


  //----------------------------------------------------------------------------
  

  class ProgramObj : public ScopedObj {
  public:
    void destroy();
    void validate();

    Context getContext() const;

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;
    int getId() const;

    RTprogram get();
  private:
    typedef RTprogram api_t;
    virtual ~ProgramObj() {}
    RTprogram m_program;
    ProgramObj(RTprogram program) : m_program(program) {}
    friend class Handle<ProgramObj>;
  };


  //----------------------------------------------------------------------------


  class GroupObj : public DestroyableObj {
  public:
    void destroy();
    void validate();

    Context getContext() const;

    void setAcceleration(Acceleration acceleration);
    Acceleration getAcceleration() const;

    void setChildCount(unsigned int  count);
    unsigned int getChildCount() const;

    template< typename T > void setChild(unsigned int index, T child);
    template< typename T > T getChild(unsigned int index) const;
    RTobjecttype getChildType(unsigned int index) const;

    template< typename T > unsigned int addChild(T child);
    template< typename T > unsigned int removeChild(T child);
    void removeChild(int index);
    void removeChild(unsigned int index);
    template< typename T > unsigned int getChildIndex(T child) const;

    RTgroup get();

  private:
    typedef RTgroup api_t;
    virtual ~GroupObj() {}
    RTgroup m_group;
    GroupObj(RTgroup group) : m_group(group) {}
    friend class Handle<GroupObj>;
  };


  //----------------------------------------------------------------------------


  class GeometryGroupObj : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setAcceleration(Acceleration acceleration);
    Acceleration getAcceleration() const;

    void setChildCount(unsigned int  count);
    unsigned int getChildCount() const;

    void setChild(unsigned int index, GeometryInstance geometryinstance);
    GeometryInstance getChild(unsigned int index) const;

    unsigned int addChild(GeometryInstance child);
    unsigned int removeChild(GeometryInstance child);
    void removeChild(int index);
    void removeChild(unsigned int index);
    unsigned int getChildIndex(GeometryInstance child) const;

    RTgeometrygroup get();

  private:
    typedef RTgeometrygroup api_t;
    virtual ~GeometryGroupObj() {}
    RTgeometrygroup m_geometrygroup;
    GeometryGroupObj(RTgeometrygroup geometrygroup) : m_geometrygroup(geometrygroup) {}
    friend class Handle<GeometryGroupObj>;
  };


  //----------------------------------------------------------------------------


  class TransformObj  : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    template< typename T > void setChild(T child);
    template< typename T > T getChild() const;
    RTobjecttype getChildType() const;

    void setMatrix(bool transpose, const float* matrix, const float* inverse_matrix);
    void getMatrix(bool transpose, float* matrix, float* inverse_matrix) const;

    RTtransform get();

  private:
    typedef RTtransform api_t;
    virtual ~TransformObj() {}
    RTtransform m_transform;
    TransformObj(RTtransform transform) : m_transform(transform) {}
    friend class Handle<TransformObj>;
  };


  //----------------------------------------------------------------------------


  class SelectorObj : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setVisitProgram(Program  program);
    Program getVisitProgram() const;

    void setChildCount(unsigned int  count);
    unsigned int getChildCount() const;

    template< typename T > void setChild(unsigned int index, T child);
    template< typename T > T getChild(unsigned int index) const;
    RTobjecttype getChildType(unsigned int index) const;
    
    template< typename T > unsigned int addChild(T child);
    template< typename T > unsigned int removeChild(T child);
    void removeChild(int index);
    void removeChild(unsigned int index);
    template< typename T > unsigned int getChildIndex(T child) const;

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;

    RTselector get();

  private:
    typedef RTselector api_t;
    virtual ~SelectorObj() {}
    RTselector m_selector;
    SelectorObj(RTselector selector) : m_selector(selector) {}
    friend class Handle<SelectorObj>;
  };

  
  //----------------------------------------------------------------------------


  class AccelerationObj : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void markDirty();
    bool isDirty() const;

    void        setProperty( const std::string& name, const std::string& value );
    std::string getProperty( const std::string& name ) const;

    void        setBuilder(const std::string& builder);
    std::string getBuilder() const;
    void        setTraverser(const std::string& traverser);
    std::string getTraverser() const;

    RTsize getDataSize() const;
    void   getData( void* data ) const;
    void   setData( const void* data, RTsize size );

    RTacceleration get();

  private:
    typedef RTacceleration api_t;
    virtual ~AccelerationObj() {}
    RTacceleration m_acceleration;
    AccelerationObj(RTacceleration acceleration) : m_acceleration(acceleration) {}
    friend class Handle<AccelerationObj>;
  };


  //----------------------------------------------------------------------------


  class GeometryInstanceObj : public ScopedObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setGeometry(Geometry  geometry);
    Geometry getGeometry() const;

    void setMaterialCount(unsigned int  count);
    unsigned int getMaterialCount() const;

    void setMaterial(unsigned int idx, Material  material);
    Material getMaterial(unsigned int idx) const;

    unsigned int addMaterial(Material material);

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;

    RTgeometryinstance get();

  private:
    typedef RTgeometryinstance api_t;
    virtual ~GeometryInstanceObj() {}
    RTgeometryinstance m_geometryinstance;
    GeometryInstanceObj(RTgeometryinstance geometryinstance) : m_geometryinstance(geometryinstance) {}
    friend class Handle<GeometryInstanceObj>;
  };


  //----------------------------------------------------------------------------


  class GeometryObj : public ScopedObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void markDirty();
    bool isDirty() const;

    void setPrimitiveCount(unsigned int  num_primitives);
    unsigned int getPrimitiveCount() const;

    void setPrimitiveIndexOffset(unsigned int  index_offset);
    unsigned int getPrimitiveIndexOffset() const;

    void setBoundingBoxProgram(Program  program);
    Program getBoundingBoxProgram() const;

    void setIntersectionProgram(Program  program);
    Program getIntersectionProgram() const;

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;

    RTgeometry get();

  private:
    typedef RTgeometry api_t;
    virtual ~GeometryObj() {}
    RTgeometry m_geometry;
    GeometryObj(RTgeometry geometry) : m_geometry(geometry) {}
    friend class Handle<GeometryObj>;
  };


  //----------------------------------------------------------------------------


  class MaterialObj : public ScopedObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setClosestHitProgram(unsigned int ray_type_index, Program  program);
    Program getClosestHitProgram(unsigned int ray_type_index) const;

    void setAnyHitProgram(unsigned int ray_type_index, Program  program);
    Program getAnyHitProgram(unsigned int ray_type_index) const;

    Variable declareVariable (const std::string& name);
    Variable queryVariable   (const std::string& name) const;
    void     removeVariable  (Variable v);
    unsigned int getVariableCount() const;
    Variable getVariable     (unsigned int index) const;

    RTmaterial get();
  private:
    typedef RTmaterial api_t;
    virtual ~MaterialObj() {}
    RTmaterial m_material;
    MaterialObj(RTmaterial material) : m_material(material) {}
    friend class Handle<MaterialObj>;
  };


  //----------------------------------------------------------------------------


  class TextureSamplerObj : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setMipLevelCount (unsigned int  num_mip_levels);
    unsigned int getMipLevelCount () const;

    void setArraySize(unsigned int  num_textures_in_array);
    unsigned int getArraySize() const;

    void setWrapMode(unsigned int dim, RTwrapmode wrapmode);
    RTwrapmode getWrapMode(unsigned int dim) const;

    void setFilteringModes(RTfiltermode  minification, RTfiltermode  magnification, RTfiltermode  mipmapping);
    void getFilteringModes(RTfiltermode& minification, RTfiltermode& magnification, RTfiltermode& mipmapping) const;

    void setMaxAnisotropy(float value);
    float getMaxAnisotropy() const;

    void setMipLevelClamp(float minLevel, float maxLevel);
    void getMipLevelClamp(float &minLevel, float &maxLevel) const;
        
    void setMipLevelBias(float value);
    float getMipLevelBias() const;

    void setReadMode(RTtexturereadmode  readmode);
    RTtexturereadmode getReadMode() const;

    void setIndexingMode(RTtextureindexmode  indexmode);
    RTtextureindexmode getIndexingMode() const;

    int getId() const;

    void setBuffer(unsigned int texture_array_idx, unsigned int mip_level, Buffer buffer);
    Buffer getBuffer(unsigned int texture_array_idx, unsigned int mip_level) const;
    void setBuffer(Buffer buffer);
    Buffer getBuffer() const;

    RTtexturesampler get();

    void registerGLTexture();
    void unregisterGLTexture();

#ifdef _WIN32

    void registerD3D9Texture();
    void registerD3D10Texture();
    void registerD3D11Texture();

    void unregisterD3D9Texture();
    void unregisterD3D10Texture();
    void unregisterD3D11Texture();

#endif

  private:
    typedef RTtexturesampler api_t;
    virtual ~TextureSamplerObj() {}
    RTtexturesampler m_texturesampler;
    TextureSamplerObj(RTtexturesampler texturesampler) : m_texturesampler(texturesampler) {}
    friend class Handle<TextureSamplerObj>;
  };


  //----------------------------------------------------------------------------


  class BufferObj : public DestroyableObj {
  public:
    void destroy();
    void validate();
    Context getContext() const;

    void setFormat    (RTformat format);
    RTformat getFormat() const;

    void setElementSize  (RTsize size_of_element);
    RTsize getElementSize() const;

    void getDevicePointer( unsigned int optix_device_number, CUdeviceptr *device_pointer );
    CUdeviceptr getDevicePointer( unsigned int optix_device_number );

    void setDevicePointer( unsigned int optix_device_number, CUdeviceptr device_pointer );

    void markDirty();

    void setSize(RTsize  width);
    void getSize(RTsize& width) const;
    void getMipLevelSize(unsigned int level, RTsize& width) const;
    void setSize(RTsize  width, RTsize  height);
    void getSize(RTsize& width, RTsize& height) const;
    void getMipLevelSize(unsigned int level, RTsize& width, RTsize& height) const;
    void setSize(RTsize  width, RTsize  height, RTsize  depth);
    void getSize(RTsize& width, RTsize& height, RTsize& depth) const;
    void getMipLevelSize(unsigned int level, RTsize& width, RTsize& height, RTsize& depth) const;

    void setSize(unsigned int dimensionality, const RTsize* dims);
    void getSize(unsigned int dimensionality,       RTsize* dims) const;

    unsigned int getDimensionality() const;
   
    void setMipLevelCount(unsigned int levels);
    unsigned int getMipLevelCount() const;

    int getId() const;

    unsigned int getGLBOId() const;

    void registerGLBuffer();
    void unregisterGLBuffer();

    void setAttribute( RTbufferattribute attrib, RTsize size, void *p );
    void getAttribute( RTbufferattribute attrib, RTsize size, void *p );

#ifdef _WIN32

    void registerD3D9Buffer();
    void registerD3D10Buffer();
    void registerD3D11Buffer();

    void unregisterD3D9Buffer();
    void unregisterD3D10Buffer();
    void unregisterD3D11Buffer();

    IDirect3DResource9* getD3D9Resource();
    ID3D10Resource* getD3D10Resource();
    ID3D11Resource* getD3D11Resource();

#endif

    void* map();
    void unmap();

    void* map(unsigned int level);
    void unmap(unsigned int level);


    void bindProgressiveStream( Buffer source );
    void getProgressiveUpdateReady( int* ready, unsigned int* subframe_count, unsigned int* max_subframes );

    RTbuffer get();

  private:
    typedef RTbuffer api_t;
    virtual ~BufferObj() {}
    RTbuffer m_buffer;
    BufferObj(RTbuffer buffer) : m_buffer(buffer) {}
    friend class Handle<BufferObj>;
  };

#if !defined(__CUDACC__)
  template<typename T, int Dim=1>
  struct bufferId {
    bufferId() {}
    bufferId(int id) : m_id(id) {}
    int getId() const { return m_id; }
  private:
    int m_id;
  };
#define rtBufferId optix::bufferId


#define RT_INTERNAL_CALLABLE_PROGRAM_DEFS()   \
  {                                           \
  public:                                     \
    callableProgramId() {}                    \
    callableProgramId(int id) : m_id(id) {}   \
    int getId() const { return m_id; }        \
  private:                                    \
    int m_id;                                 \
  }
  
  // 
  template<typename T>
  class callableProgramId;
  template<typename ReturnT>
  class callableProgramId<ReturnT()> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T>
  class callableProgramId<ReturnT(Arg0T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T>
  class callableProgramId<ReturnT(Arg0T,Arg1T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T, typename Arg5T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T,Arg5T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T, typename Arg5T, typename Arg6T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T,Arg5T,Arg6T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T, typename Arg5T, typename Arg6T, typename Arg7T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T,Arg5T,Arg6T,Arg7T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T, typename Arg5T, typename Arg6T, typename Arg7T, typename Arg8T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T,Arg5T,Arg6T,Arg7T,Arg8T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();
  template<typename ReturnT, typename Arg0T, typename Arg1T, typename Arg2T, typename Arg3T,
           typename Arg4T, typename Arg5T, typename Arg6T, typename Arg7T, typename Arg8T, typename Arg9T>
  class callableProgramId<ReturnT(Arg0T,Arg1T,Arg2T,Arg3T,Arg4T,Arg5T,Arg6T,Arg7T,Arg8T,Arg9T)> RT_INTERNAL_CALLABLE_PROGRAM_DEFS();

  // template <typename ReturnT
  //           ,typename Arg0T=optix::CPArgVoid
  //           ,typename Arg1T=optix::CPArgVoid
  //           ,typename Arg2T=optix::CPArgVoid
  //           ,typename Arg3T=optix::CPArgVoid
  //           ,typename Arg4T=optix::CPArgVoid
  //           ,typename Arg5T=optix::CPArgVoid
  //           ,typename Arg6T=optix::CPArgVoid
  //           ,typename Arg7T=optix::CPArgVoid
  //           ,typename Arg8T=optix::CPArgVoid
  //           ,typename Arg9T=optix::CPArgVoid
  //           >
  // struct callableProgramId {
  //   callableProgramId() {}
  //   callableProgramId(int id) : m_id(id) {}
  //   int getId() const { return m_id; }
  // private:
  //   int m_id;
  // };
#define rtCallableProgramId    optix::callableProgramId
#endif


  //----------------------------------------------------------------------------

  class RemoteDeviceObj : public APIObj {
  public:
    static RemoteDevice create( const std::string& url, const std::string& username, const std::string& password );

    void destroy();

    void reserve( unsigned int num_nodes, unsigned int configuration_idx );

    void release();

    void getAttribute( RTremotedeviceattribute attrib, RTsize size, void *p );

    std::string getConfiguration(unsigned int index);  

    RTremotedevice get();
  private:
    typedef RTremotedevice api_t;

    Context getContext() const;

    RemoteDeviceObj(RTremotedevice rdev) : m_rdev(rdev) {}
    virtual ~RemoteDeviceObj() {}
    friend class Handle<RemoteDeviceObj>;

    RTremotedevice  m_rdev;
  };

  //----------------------------------------------------------------------------

  inline void APIObj::checkError( RTresult code ) const
  {
    if( code != RT_SUCCESS) {
      RTcontext c = this->getContext()->get();
      throw Exception::makeException( code, c );
    }
  }

  inline void APIObj::checkError( RTresult code, Context context ) const
  {
    if( code != RT_SUCCESS) {
      RTcontext c = context->get();
      throw Exception::makeException( code, c );
    }
  }

  inline void APIObj::checkErrorNoGetContext( RTresult code ) const
  {
    if( code != RT_SUCCESS) {
      throw Exception::makeException( code, 0u );
    }
  }

  inline Context ContextObj::getContext() const
  {
    return Context::take( m_context );
  }

  inline void ContextObj::checkError(RTresult code) const
  {
    if( code != RT_SUCCESS && code != RT_TIMEOUT_CALLBACK )
      throw Exception::makeException( code, m_context );
  }

  inline unsigned int ContextObj::getDeviceCount()
  {
    unsigned int count;
    if( RTresult code = rtDeviceGetDeviceCount(&count) )
      throw Exception::makeException( code, 0 );

    return count;
  }

  inline std::string ContextObj::getDeviceName(int ordinal)
  {
    const RTsize max_string_size = 256;
    char name[max_string_size];
    if( RTresult code = rtDeviceGetAttribute(ordinal, RT_DEVICE_ATTRIBUTE_NAME,
                                             max_string_size, name) )
      throw Exception::makeException( code, 0 );
    return std::string(name);
  }

  inline void ContextObj::getDeviceAttribute(int ordinal, RTdeviceattribute attrib, RTsize size, void* p)
  {
    if( RTresult code = rtDeviceGetAttribute(ordinal, attrib, size, p) )
      throw Exception::makeException( code, 0 );
  }

  inline Context ContextObj::create()
  {
    RTcontext c;
    if( RTresult code = rtContextCreate(&c) )
      throw Exception::makeException( code, 0 );

    return Context::take(c);
  }

  inline void ContextObj::destroy()
  {
    checkErrorNoGetContext( rtContextDestroy( m_context ) );
    m_context = 0;
  }

  inline void ContextObj::validate()
  {
    checkError( rtContextValidate( m_context ) );
  }

  inline Acceleration ContextObj::createAcceleration(const char* builder, const char* traverser)
  {
    RTacceleration acceleration;
    checkError( rtAccelerationCreate( m_context, &acceleration ) );
    checkError( rtAccelerationSetBuilder( acceleration, builder ) );
    checkError( rtAccelerationSetTraverser( acceleration, traverser ) );
    return Acceleration::take(acceleration);
  }


  inline Buffer ContextObj::createBuffer(unsigned int type)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBuffer(unsigned int type, RTformat format)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBuffer(unsigned int type, RTformat format, RTsize width)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize1D( buffer, width ) );
    return Buffer::take(buffer);
  }
    
  inline Buffer ContextObj::createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize1D( buffer, width ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBuffer(unsigned int type, RTformat format, RTsize width, RTsize height)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize2D( buffer, width, height ) );
    return Buffer::take(buffer);
  }
    
  inline Buffer ContextObj::createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize2D( buffer, width, height ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize3D( buffer, width, height, depth ) );
    return Buffer::take(buffer);
  }
    
  inline Buffer ContextObj::createMipmappedBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize3D( buffer, width, height, depth ) );
    return Buffer::take(buffer);
  }
   
  inline Buffer ContextObj::create1DLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize layers, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type | RT_BUFFER_LAYERED, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize3D( buffer, width, 1, layers ) );
    return Buffer::take(buffer);
  }
    
  inline Buffer ContextObj::create2DLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize layers, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type | RT_BUFFER_LAYERED, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize3D( buffer, width, height, layers ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createCubeBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type | RT_BUFFER_CUBEMAP, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize3D( buffer, width, height, 6 ) );
    return Buffer::take(buffer);
  }
    
  inline Buffer ContextObj::createCubeLayeredBuffer(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize faces, unsigned int levels)
  {
    RTbuffer buffer;
    checkError( rtBufferCreate( m_context, type | RT_BUFFER_CUBEMAP | RT_BUFFER_LAYERED, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetMipLevelCount( buffer, levels ) );
    checkError( rtBufferSetSize3D( buffer, width, height, faces ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferForCUDA(unsigned int type)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateForCUDA( m_context, type, &buffer ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferForCUDA(unsigned int type, RTformat format)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateForCUDA( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferForCUDA(unsigned int type, RTformat format, RTsize width)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateForCUDA( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize1D( buffer, width ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferForCUDA(unsigned int type, RTformat format, RTsize width, RTsize height)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateForCUDA( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize2D( buffer, width, height ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferForCUDA(unsigned int type, RTformat format, RTsize width, RTsize height, RTsize depth)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateForCUDA( m_context, type, &buffer ) );
    checkError( rtBufferSetFormat( buffer, format ) );
    checkError( rtBufferSetSize3D( buffer, width, height, depth ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferFromGLBO(unsigned int type, unsigned int vbo)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateFromGLBO( m_context, type, vbo, &buffer ) );
    return Buffer::take(buffer);
  }

#ifdef _WIN32

  inline Buffer ContextObj::createBufferFromD3D9Resource(unsigned int type, IDirect3DResource9 *pResource)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateFromD3D9Resource( m_context, type, pResource, &buffer ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferFromD3D10Resource(unsigned int type, ID3D10Resource *pResource)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateFromD3D10Resource( m_context, type, pResource, &buffer ) );
    return Buffer::take(buffer);
  }

  inline Buffer ContextObj::createBufferFromD3D11Resource(unsigned int type, ID3D11Resource *pResource)
  {
    RTbuffer buffer;
    checkError( rtBufferCreateFromD3D11Resource( m_context, type, pResource, &buffer ) );
    return Buffer::take(buffer);
  }

  inline TextureSampler ContextObj::createTextureSamplerFromD3D9Resource(IDirect3DResource9 *pResource)
  {
    RTtexturesampler textureSampler;
    checkError( rtTextureSamplerCreateFromD3D9Resource(m_context, pResource, &textureSampler));
    return TextureSampler::take(textureSampler);
  }

  inline TextureSampler ContextObj::createTextureSamplerFromD3D10Resource(ID3D10Resource *pResource)
  {
    RTtexturesampler textureSampler;
    checkError( rtTextureSamplerCreateFromD3D10Resource(m_context, pResource, &textureSampler));
    return TextureSampler::take(textureSampler);
  }

  inline TextureSampler ContextObj::createTextureSamplerFromD3D11Resource(ID3D11Resource *pResource)
  {
    RTtexturesampler textureSampler;
    checkError( rtTextureSamplerCreateFromD3D11Resource(m_context, pResource, &textureSampler));
    return TextureSampler::take(textureSampler);
  }

  inline void ContextObj::setD3D9Device(IDirect3DDevice9* device)
  {
    checkError( rtContextSetD3D9Device( m_context, device ) );
  }

  inline void ContextObj::setD3D10Device(ID3D10Device* device)
  {
    checkError( rtContextSetD3D10Device( m_context, device ) );
  }

  inline void ContextObj::setD3D11Device(ID3D11Device* device)
  {
    checkError( rtContextSetD3D11Device( m_context, device ) );
  }

#endif

  inline TextureSampler ContextObj::createTextureSamplerFromGLImage(unsigned int id, RTgltarget target)
  {
    RTtexturesampler textureSampler;
    checkError( rtTextureSamplerCreateFromGLImage(m_context, id, target, &textureSampler));
    return TextureSampler::take(textureSampler);
  }

  inline Buffer ContextObj::getBufferFromId(int buffer_id)
  {
    RTbuffer buffer;
    checkError( rtContextGetBufferFromId( m_context, buffer_id, &buffer ) );
    return Buffer::take(buffer);
  }

  inline Program ContextObj::getProgramFromId(int program_id)
  {
    RTprogram program;
    checkError( rtContextGetProgramFromId( m_context, program_id, &program ) );
    return Program::take(program);
  }

  inline TextureSampler ContextObj::getTextureSamplerFromId(int sampler_id)
  {
    RTtexturesampler sampler;
    checkError( rtContextGetTextureSamplerFromId( m_context, sampler_id, &sampler ) );
    return TextureSampler::take(sampler);
  }

  inline Geometry ContextObj::createGeometry()
  {
    RTgeometry geometry;
    checkError( rtGeometryCreate( m_context, &geometry ) );
    return Geometry::take(geometry);
  }

  inline GeometryInstance ContextObj::createGeometryInstance()
  {
    RTgeometryinstance geometryinstance;
    checkError( rtGeometryInstanceCreate( m_context, &geometryinstance ) );
    return GeometryInstance::take(geometryinstance);
  }

  template<class Iterator>
    GeometryInstance ContextObj::createGeometryInstance( Geometry geometry, Iterator matlbegin, Iterator matlend)
  {
    GeometryInstance result = createGeometryInstance();
    result->setGeometry( geometry );
    unsigned int count = 0;
    for( Iterator iter = matlbegin; iter != matlend; ++iter )
      ++count;
    result->setMaterialCount( count );
    unsigned int index = 0;
    for(Iterator iter = matlbegin; iter != matlend; ++iter, ++index )
      result->setMaterial( index, *iter );
    return result;
  }

  inline Group ContextObj::createGroup()
  {
    RTgroup group;
    checkError( rtGroupCreate( m_context, &group ) );
    return Group::take(group);
  }

  template<class Iterator>
    inline Group ContextObj::createGroup( Iterator childbegin, Iterator childend )
  {
    Group result = createGroup();
    unsigned int count = 0;
    for(Iterator iter = childbegin; iter != childend; ++iter )
      ++count;
    result->setChildCount( count );
    unsigned int index = 0;
    for(Iterator iter = childbegin; iter != childend; ++iter, ++index )
      result->setChild( index, *iter );
    return result;
  }

  inline GeometryGroup ContextObj::createGeometryGroup()
  {
    RTgeometrygroup gg;
    checkError( rtGeometryGroupCreate( m_context, &gg ) );
    return GeometryGroup::take( gg );
  }

  template<class Iterator>
  inline GeometryGroup ContextObj::createGeometryGroup( Iterator childbegin, Iterator childend )
  {
    GeometryGroup result = createGeometryGroup();
    unsigned int count = 0;
    for(Iterator iter = childbegin; iter != childend; ++iter )
      ++count;
    result->setChildCount( count );
    unsigned int index = 0;
    for(Iterator iter = childbegin; iter != childend; ++iter, ++index )
      result->setChild( index, *iter );
    return result;
  }

  inline Transform ContextObj::createTransform()
  {
    RTtransform t;
    checkError( rtTransformCreate( m_context, &t ) );
    return Transform::take( t );
  }

  inline Material ContextObj::createMaterial()
  {
    RTmaterial material;
    checkError( rtMaterialCreate( m_context, &material ) );
    return Material::take(material);
  }

  inline Program ContextObj::createProgramFromPTXFile( const std::string& filename, const std::string& program_name )
  {
    RTprogram program;
    checkError( rtProgramCreateFromPTXFile( m_context, filename.c_str(), program_name.c_str(), &program ) );
    return Program::take(program);
  }

  inline Program ContextObj::createProgramFromPTXString( const std::string& ptx, const std::string& program_name )
  {
    RTprogram program;
    checkError( rtProgramCreateFromPTXString( m_context, ptx.c_str(), program_name.c_str(), &program ) );
    return Program::take(program);
  }

  inline Selector ContextObj::createSelector()
  {
    RTselector selector;
    checkError( rtSelectorCreate( m_context, &selector ) );
    return Selector::take(selector);
  }

  inline TextureSampler ContextObj::createTextureSampler()
  {
    RTtexturesampler texturesampler;
    checkError( rtTextureSamplerCreate( m_context, &texturesampler ) );
    return TextureSampler::take(texturesampler);
  }

  inline std::string ContextObj::getErrorString( RTresult code ) const
  {
    const char* str;
    rtContextGetErrorString( m_context, code, &str);
    return std::string(str);
  }

  template<class Iterator> inline
    void ContextObj::setDevices(Iterator begin, Iterator end)
  {
    std::vector<int> devices;
    std::copy( begin, end, std::insert_iterator<std::vector<int> >( devices, devices.begin() ) );
    checkError( rtContextSetDevices( m_context, static_cast<unsigned int>(devices.size()), &devices[0]) );
  }

  inline std::vector<int> ContextObj::getEnabledDevices() const
  {
    // Initialize with the number of enabled devices
    std::vector<int> devices(getEnabledDeviceCount());
    checkError( rtContextGetDevices( m_context, &devices[0] ) );
    return devices;
  }

  inline unsigned int ContextObj::getEnabledDeviceCount() const
  {
    unsigned int num;
    checkError( rtContextGetDeviceCount( m_context, &num ) );
    return num;
  }
  
  inline int ContextObj::getMaxTextureCount() const
  {
    int tex_count;
    checkError( rtContextGetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_MAX_TEXTURE_COUNT, sizeof(tex_count), &tex_count) );
    return tex_count;
  }

  inline int ContextObj::getCPUNumThreads() const
  {
    int cpu_num_threads;
    checkError( rtContextGetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_CPU_NUM_THREADS, sizeof(cpu_num_threads), &cpu_num_threads) );
    return cpu_num_threads;
  }

  inline RTsize ContextObj::getUsedHostMemory() const
  {
    RTsize used_mem;
    checkError( rtContextGetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_USED_HOST_MEMORY, sizeof(used_mem), &used_mem) );
    return used_mem;
  }

  inline int ContextObj::getGPUPagingActive() const
  {
    int gpu_paging_active;
    checkError( rtContextGetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_GPU_PAGING_ACTIVE, sizeof(gpu_paging_active), &gpu_paging_active) );
    return gpu_paging_active;
  }

  inline int ContextObj::getGPUPagingForcedOff() const
  {
    int gpu_paging_forced_off;
    checkError( rtContextGetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_GPU_PAGING_FORCED_OFF, sizeof(gpu_paging_forced_off), &gpu_paging_forced_off) );
    return gpu_paging_forced_off;
  }

  inline RTsize ContextObj::getAvailableDeviceMemory(int ordinal) const
  {
    RTsize free_mem;
    checkError( rtContextGetAttribute( m_context,
                                       static_cast<RTcontextattribute>(RT_CONTEXT_ATTRIBUTE_AVAILABLE_DEVICE_MEMORY + ordinal),
                                       sizeof(free_mem), &free_mem) );
    return free_mem;
  }

  inline void ContextObj::setCPUNumThreads(int cpu_num_threads)
  {
    checkError( rtContextSetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_CPU_NUM_THREADS, sizeof(cpu_num_threads), &cpu_num_threads) );
  }

  inline void ContextObj::setGPUPagingForcedOff(int gpu_paging_forced_off)
  {
    checkError( rtContextSetAttribute( m_context, RT_CONTEXT_ATTRIBUTE_GPU_PAGING_FORCED_OFF, sizeof(gpu_paging_forced_off), &gpu_paging_forced_off) );
  }

  template<class T>
  inline void ContextObj::setAttribute(RTcontextattribute attribute, const T& val)
  {
    checkError( rtContextSetAttribute( m_context, attribute, sizeof(T), const_cast<T*>(&val)) );
  }

  inline void ContextObj::setStackSize(RTsize  stack_size_bytes)
  {
    checkError(rtContextSetStackSize(m_context, stack_size_bytes) );
  }

  inline RTsize ContextObj::getStackSize() const
  {
    RTsize result;
    checkError( rtContextGetStackSize( m_context, &result ) );
    return result;
  }

  inline void ContextObj::setTimeoutCallback(RTtimeoutcallback callback, double min_polling_seconds)
  {
    checkError( rtContextSetTimeoutCallback( m_context, callback, min_polling_seconds ) );
  }

  inline void ContextObj::setEntryPointCount(unsigned int  num_entry_points)
  {
    checkError( rtContextSetEntryPointCount( m_context, num_entry_points ) );
  }

  inline unsigned int ContextObj::getEntryPointCount() const
  {
    unsigned int result;
    checkError( rtContextGetEntryPointCount( m_context, &result ) );
    return result;
  }


  inline void ContextObj::setRayGenerationProgram(unsigned int entry_point_index, Program  program)
  {
    checkError( rtContextSetRayGenerationProgram( m_context, entry_point_index, program->get() ) );
  }

  inline Program ContextObj::getRayGenerationProgram(unsigned int entry_point_index) const
  {
    RTprogram result;
    checkError( rtContextGetRayGenerationProgram( m_context, entry_point_index, &result ) );
    return Program::take( result );
  }


  inline void ContextObj::setExceptionProgram(unsigned int entry_point_index, Program  program)
  {
    checkError( rtContextSetExceptionProgram( m_context, entry_point_index, program->get() ) );
  }

  inline Program ContextObj::getExceptionProgram(unsigned int entry_point_index) const
  {
    RTprogram result;
    checkError( rtContextGetExceptionProgram( m_context, entry_point_index, &result ) );
    return Program::take( result );
  }


  inline void ContextObj::setExceptionEnabled( RTexception exception, bool enabled )
  {
    checkError( rtContextSetExceptionEnabled( m_context, exception, enabled ) );
  }

  inline bool ContextObj::getExceptionEnabled( RTexception exception ) const
  {
    int enabled;
    checkError( rtContextGetExceptionEnabled( m_context, exception, &enabled ) );
    return enabled != 0;
  }


  inline void ContextObj::setRayTypeCount(unsigned int  num_ray_types)
  {
    checkError( rtContextSetRayTypeCount( m_context, num_ray_types ) );
  }

  inline unsigned int ContextObj::getRayTypeCount() const
  {
    unsigned int result;
    checkError( rtContextGetRayTypeCount( m_context, &result ) );
    return result;
  }

  inline void ContextObj::setMissProgram(unsigned int ray_type_index, Program  program)
  {
    checkError( rtContextSetMissProgram( m_context, ray_type_index, program->get() ) );
  }

  inline Program ContextObj::getMissProgram(unsigned int ray_type_index) const
  {
    RTprogram result;
    checkError( rtContextGetMissProgram( m_context, ray_type_index, &result ) );
    return Program::take( result );
  }

  inline void ContextObj::compile()
  {
    checkError( rtContextCompile( m_context ) );
  }

  inline void ContextObj::launch(unsigned int entry_point_index, RTsize image_width)
  {
    checkError( rtContextLaunch1D( m_context, entry_point_index, image_width ) );
  }

  inline void ContextObj::launch(unsigned int entry_point_index, RTsize image_width, RTsize image_height)
  {
    checkError( rtContextLaunch2D( m_context, entry_point_index, image_width, image_height ) );
  }

  inline void ContextObj::launch(unsigned int entry_point_index, RTsize image_width, RTsize image_height, RTsize image_depth)
  {
    checkError( rtContextLaunch3D( m_context, entry_point_index, image_width, image_height, image_depth ) );
  }


  // Progressive API
  inline void ContextObj::launchProgressive(unsigned int entry_point_index, RTsize image_width, RTsize image_height, unsigned int max_subframes)
  {
    checkError( rtContextLaunchProgressive2D( m_context, entry_point_index, image_width, image_height, max_subframes ) );
  }

  inline void ContextObj::stopProgressive()
  {
    checkError( rtContextStopProgressive( m_context ) );
  }

  inline void ContextObj::setRemoteDevice( RemoteDevice remote_device )
  {
    checkError( rtContextSetRemoteDevice( m_context, remote_device->get() ) );
  }

  inline int ContextObj::getRunningState() const
  {
    int result;
    checkError( rtContextGetRunningState( m_context, &result ) );
    return result;
  }

  inline void ContextObj::setPrintEnabled(bool enabled)
  {
    checkError( rtContextSetPrintEnabled( m_context, enabled ) );
  }

  inline bool ContextObj::getPrintEnabled() const
  {
    int enabled;
    checkError( rtContextGetPrintEnabled( m_context, &enabled ) );
    return enabled != 0;
  }

  inline void ContextObj::setPrintBufferSize(RTsize buffer_size_bytes)
  {
    checkError( rtContextSetPrintBufferSize( m_context, buffer_size_bytes ) );
  }

  inline RTsize ContextObj::getPrintBufferSize() const
  {
    RTsize result;
    checkError( rtContextGetPrintBufferSize( m_context, &result ) );
    return result;
  }

  inline void ContextObj::setPrintLaunchIndex(int x, int y, int z)
  {
    checkError( rtContextSetPrintLaunchIndex( m_context, x, y, z ) );
  }

  inline optix::int3 ContextObj::getPrintLaunchIndex() const
  {
    optix::int3 result;
    checkError( rtContextGetPrintLaunchIndex( m_context, &result.x, &result.y, &result.z ) );
    return result;
  }

  inline Variable ContextObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtContextDeclareVariable( m_context, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable ContextObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtContextQueryVariable( m_context, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline void ContextObj::removeVariable(Variable v)
  {
    checkError( rtContextRemoveVariable( m_context, v->get() ) );
  }

  inline unsigned int ContextObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtContextGetVariableCount( m_context, &result ) );
    return result;
  }

  inline Variable ContextObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtContextGetVariable( m_context, index, &v ) );
    return Variable::take( v );
  }


  inline RTcontext ContextObj::get()
  {
    return m_context;
  }

  inline void ProgramObj::destroy()
  {
    Context context = getContext();
    checkError( rtProgramDestroy( m_program ), context );
    m_program = 0;
  }

  inline void ProgramObj::validate()
  {
    checkError( rtProgramValidate( m_program ) );
  }

  inline Context ProgramObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtProgramGetContext( m_program, &c ) );
    return Context::take( c );
  }

  inline Variable ProgramObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtProgramDeclareVariable( m_program, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable ProgramObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtProgramQueryVariable( m_program, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline void ProgramObj::removeVariable(Variable v)
  {
    checkError( rtProgramRemoveVariable( m_program, v->get() ) );
  }

  inline unsigned int ProgramObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtProgramGetVariableCount( m_program, &result ) );
    return result;
  }

  inline Variable ProgramObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtProgramGetVariable( m_program, index, &v ) );
    return Variable::take(v);
  }

  inline int ProgramObj::getId() const
  {
    int result;
    checkError( rtProgramGetId( m_program, &result ) );
    return result;
  }

  inline RTprogram ProgramObj::get()
  {
    return m_program;
  }

  inline void GroupObj::destroy()
  {
    Context context = getContext();
    checkError( rtGroupDestroy( m_group ), context );
    m_group = 0;
  }

  inline void GroupObj::validate()
  {
    checkError( rtGroupValidate( m_group ) );
  }

  inline Context GroupObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtGroupGetContext( m_group, &c) );
    return Context::take(c);
  }

  inline void SelectorObj::destroy()
  {
    Context context = getContext();
    checkError( rtSelectorDestroy( m_selector ), context );
    m_selector = 0;
  }

  inline void SelectorObj::validate()
  {
    checkError( rtSelectorValidate( m_selector ) );
  }

  inline Context SelectorObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtSelectorGetContext( m_selector, &c ) );
    return Context::take( c );
  }

  inline void SelectorObj::setVisitProgram(Program program)
  {
    checkError( rtSelectorSetVisitProgram( m_selector, program->get() ) );
  }

  inline Program SelectorObj::getVisitProgram() const
  {
    RTprogram result;
    checkError( rtSelectorGetVisitProgram( m_selector, &result ) );
    return Program::take( result );
  }

  inline void SelectorObj::setChildCount(unsigned int count)
  {
    checkError( rtSelectorSetChildCount( m_selector, count) );
  }

  inline unsigned int SelectorObj::getChildCount() const
  {
    unsigned int result;
    checkError( rtSelectorGetChildCount( m_selector, &result ) );
    return result;
  }

  template< typename T >
  inline void SelectorObj::setChild(unsigned int index, T child)
  {
    checkError( rtSelectorSetChild( m_selector, index, child->get() ) );
  }

  template< typename T >
  inline T SelectorObj::getChild(unsigned int index) const
  {
    RTobject result;
    checkError( rtSelectorGetChild( m_selector, index, &result ) );
    return T::take( result );
  }
  
  inline RTobjecttype SelectorObj::getChildType(unsigned int index) const
  {
     RTobjecttype type;
     checkError( rtSelectorGetChildType( m_selector, index, &type) );
     return type;
  }

  template< typename T >
  inline unsigned int SelectorObj::addChild(T child)
  {
    unsigned int index;
    checkError( rtSelectorGetChildCount( m_selector, &index ) );
    checkError( rtSelectorSetChildCount( m_selector, index+1 ) );
    checkError( rtSelectorSetChild( m_selector, index, child->get() ) );
    return index;
  }

  template< typename T >
  inline unsigned int SelectorObj::removeChild(T child)
  {
    unsigned int index = getChildIndex( child );
    removeChild( index );
    return index;
  }

  inline void SelectorObj::removeChild(int index)
  {
    removeChild(static_cast<unsigned int>(index));
  }

  inline void SelectorObj::removeChild(unsigned int index)
  {
    // Shift down all elements in O(n)
    unsigned int count;
    RTobject temp;
    checkError( rtSelectorGetChildCount( m_selector, &count ) );
    if(index >= count) {
      RTcontext c = this->getContext()->get();
      throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
    }
    for(unsigned int i=index+1; i<count; i++) {
      checkError( rtSelectorGetChild( m_selector, i, &temp ) );
      checkError( rtSelectorSetChild( m_selector, i-1, temp ) );
    }
    checkError( rtSelectorSetChildCount( m_selector, count-1 ) );
  }

  template< typename T >
  inline unsigned int SelectorObj::getChildIndex(T child) const
  {
    unsigned int count;
    RTobject temp;
    checkError( rtSelectorGetChildCount( m_selector, &count ) );
    for( unsigned int index = 0; index < count; index++ ) {
      checkError( rtSelectorGetChild( m_selector, index, &temp ) );
      if( child->get() == temp ) return index; // Found
    }
    RTcontext c = this->getContext()->get();
    throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
  }

  inline Variable SelectorObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtSelectorDeclareVariable( m_selector, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable SelectorObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtSelectorQueryVariable( m_selector, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline void SelectorObj::removeVariable(Variable v)
  {
    checkError( rtSelectorRemoveVariable( m_selector, v->get() ) );
  }

  inline unsigned int SelectorObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtSelectorGetVariableCount( m_selector, &result ) );
    return result;
  }

  inline Variable SelectorObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtSelectorGetVariable( m_selector, index, &v ) );
    return Variable::take( v );
  }

  inline RTselector SelectorObj::get()
  {
    return m_selector;
  }

  inline void GroupObj::setAcceleration(Acceleration acceleration)
  {
    checkError( rtGroupSetAcceleration( m_group, acceleration->get() ) );
  }

  inline Acceleration GroupObj::getAcceleration() const
  {
    RTacceleration result;
    checkError( rtGroupGetAcceleration( m_group, &result ) );
    return Acceleration::take( result );
  }

  inline void GroupObj::setChildCount(unsigned int  count)
  {
    checkError( rtGroupSetChildCount( m_group, count ) );
  }

  inline unsigned int GroupObj::getChildCount() const
  {
    unsigned int result;
    checkError( rtGroupGetChildCount( m_group, &result ) );
    return result;
  }

  template< typename T >
  inline void GroupObj::setChild(unsigned int index, T child)
  {
    checkError( rtGroupSetChild( m_group, index, child->get() ) );
  }

  template< typename T >
  inline T GroupObj::getChild(unsigned int index) const
  {
    RTobject result;
    checkError( rtGroupGetChild( m_group, index, &result) );
    return T::take( result );
  }

  inline RTobjecttype GroupObj::getChildType(unsigned int index) const
  {
     RTobjecttype type;
     checkError( rtGroupGetChildType( m_group, index, &type) );
     return type;
  }

  template< typename T >
  inline unsigned int GroupObj::addChild(T child)
  {
    unsigned int index;
    checkError( rtGroupGetChildCount( m_group, &index ) );
    checkError( rtGroupSetChildCount( m_group, index+1 ) );
    checkError( rtGroupSetChild( m_group, index, child->get() ) );
    return index;
  }

  template< typename T >
  inline unsigned int GroupObj::removeChild(T child)
  {
    unsigned int index = getChildIndex( child );
    removeChild( index );
    return index;
  }

  inline void GroupObj::removeChild(int index)
  {
    removeChild(static_cast<unsigned int>(index));
  }
  
  inline void GroupObj::removeChild(unsigned int index)
  {
    unsigned int count;
    checkError( rtGroupGetChildCount( m_group, &count ) );
    if(index >= count) {
      RTcontext c = this->getContext()->get();
      throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
    }

    // Replace to-be-removed child with last child. 
    RTobject temp;
    checkError( rtGroupGetChild( m_group, count-1, &temp ) );
    checkError( rtGroupSetChild( m_group, index, temp ) );
    checkError( rtGroupSetChildCount( m_group, count-1 ) );
  }

  template< typename T >
  inline unsigned int GroupObj::getChildIndex(T child) const
  {
    unsigned int count;
    RTobject temp;
    checkError( rtGroupGetChildCount( m_group, &count ) );
    for( unsigned int index = 0; index < count; index++ ) {
      checkError( rtGroupGetChild( m_group, index, &temp ) );
      if( child->get() == temp ) return index; // Found
    }
    RTcontext c = this->getContext()->get();
    throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
  }

  inline RTgroup GroupObj::get()
  {
    return m_group;
  }

  inline void GeometryGroupObj::destroy()
  {
    Context context = getContext();
    checkError( rtGeometryGroupDestroy( m_geometrygroup ), context );
    m_geometrygroup = 0;
  }

  inline void GeometryGroupObj::validate()
  {
    checkError( rtGeometryGroupValidate( m_geometrygroup ) );
  }

  inline Context GeometryGroupObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtGeometryGroupGetContext( m_geometrygroup, &c) );
    return Context::take(c);
  }

  inline void GeometryGroupObj::setAcceleration(Acceleration acceleration)
  {
    checkError( rtGeometryGroupSetAcceleration( m_geometrygroup, acceleration->get() ) );
  }

  inline Acceleration GeometryGroupObj::getAcceleration() const
  {
    RTacceleration result;
    checkError( rtGeometryGroupGetAcceleration( m_geometrygroup, &result ) );
    return Acceleration::take( result );
  }

  inline void GeometryGroupObj::setChildCount(unsigned int  count)
  {
    checkError( rtGeometryGroupSetChildCount( m_geometrygroup, count ) );
  }

  inline unsigned int GeometryGroupObj::getChildCount() const
  {
    unsigned int result;
    checkError( rtGeometryGroupGetChildCount( m_geometrygroup, &result ) );
    return result;
  }

  inline void GeometryGroupObj::setChild(unsigned int index, GeometryInstance child)
  {
    checkError( rtGeometryGroupSetChild( m_geometrygroup, index, child->get() ) );
  }

  inline GeometryInstance GeometryGroupObj::getChild(unsigned int index) const
  {
    RTgeometryinstance result;
    checkError( rtGeometryGroupGetChild( m_geometrygroup, index, &result) );
    return GeometryInstance::take( result );
  }

  inline unsigned int GeometryGroupObj::addChild(GeometryInstance child)
  {
    unsigned int index;
    checkError( rtGeometryGroupGetChildCount( m_geometrygroup, &index ) );
    checkError( rtGeometryGroupSetChildCount( m_geometrygroup, index+1 ) );
    checkError( rtGeometryGroupSetChild( m_geometrygroup, index, child->get() ) );
    return index;
  }

  inline unsigned int GeometryGroupObj::removeChild(GeometryInstance child)
  {
    unsigned int index = getChildIndex( child );
    removeChild( index );
    return index;
  }

  inline void GeometryGroupObj::removeChild(int index)
  {
    removeChild(static_cast<unsigned int>(index));
  }
  
  inline void GeometryGroupObj::removeChild(unsigned int index)
  {
    unsigned int count;
    checkError( rtGeometryGroupGetChildCount( m_geometrygroup, &count ) );
    if(index >= count) {
      RTcontext c = this->getContext()->get();
      throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
    }
    
    // Replace to-be-removed child with last child. 
    RTgeometryinstance temp;
    checkError( rtGeometryGroupGetChild( m_geometrygroup, count-1, &temp ) );
    checkError( rtGeometryGroupSetChild( m_geometrygroup, index, temp ) );
    checkError( rtGeometryGroupSetChildCount( m_geometrygroup, count-1 ) );
  }

  inline unsigned int GeometryGroupObj::getChildIndex(GeometryInstance child) const
  {
    unsigned int count;
    RTgeometryinstance temp;
    checkError( rtGeometryGroupGetChildCount( m_geometrygroup, &count ) );
    for( unsigned int index = 0; index < count; index++ ) {
      checkError( rtGeometryGroupGetChild( m_geometrygroup, index, &temp ) );
      if( child->get() == temp ) return index; // Found
    }
    RTcontext c = this->getContext()->get();
    throw Exception::makeException( RT_ERROR_INVALID_VALUE, c );
  }

  inline RTgeometrygroup GeometryGroupObj::get()
  {
    return m_geometrygroup;
  }

  inline void TransformObj::destroy()
  {
    Context context = getContext();
    checkError( rtTransformDestroy( m_transform ), context );
    m_transform = 0;
  }

  inline void TransformObj::validate()
  {
    checkError( rtTransformValidate( m_transform ) );
  }

  inline Context TransformObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtTransformGetContext( m_transform, &c) );
    return Context::take(c);
  }

  template< typename T >
  inline void TransformObj::setChild(T child)
  {
    checkError( rtTransformSetChild( m_transform, child->get() ) );
  }

  template< typename T >
  inline T TransformObj::getChild() const
  {
    RTobject result;
    checkError( rtTransformGetChild( m_transform, &result) );
    return T::take( result );
  }
  
  inline RTobjecttype TransformObj::getChildType() const
  {

     RTobjecttype type;
     checkError( rtTransformGetChildType( m_transform, &type) );
     return type;
  }

  inline void TransformObj::setMatrix(bool transpose, const float* matrix, const float* inverse_matrix)
  {
    rtTransformSetMatrix( m_transform, transpose, matrix, inverse_matrix );
  }

  inline void TransformObj::getMatrix(bool transpose, float* matrix, float* inverse_matrix) const
  {
    rtTransformGetMatrix( m_transform, transpose, matrix, inverse_matrix );
  }

  inline RTtransform TransformObj::get()
  {
    return m_transform;
  }

  inline void AccelerationObj::destroy()
  {
    Context context = getContext();
    checkError( rtAccelerationDestroy(m_acceleration), context );
    m_acceleration = 0;
  }

  inline void AccelerationObj::validate()
  {
    checkError( rtAccelerationValidate(m_acceleration) );
  }

  inline Context AccelerationObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtAccelerationGetContext(m_acceleration, &c ) );
    return Context::take( c );
  }

  inline void AccelerationObj::markDirty()
  {
    checkError( rtAccelerationMarkDirty(m_acceleration) );
  }

  inline bool AccelerationObj::isDirty() const
  {
    int dirty;
    checkError( rtAccelerationIsDirty(m_acceleration,&dirty) );
    return dirty != 0;
  }

  inline void AccelerationObj::setProperty( const std::string& name, const std::string& value )
  {
    checkError( rtAccelerationSetProperty(m_acceleration, name.c_str(), value.c_str() ) );
  }

  inline std::string AccelerationObj::getProperty( const std::string& name ) const
  {
    const char* s;
    checkError( rtAccelerationGetProperty(m_acceleration, name.c_str(), &s ) );
    return std::string( s );
  }

  inline void AccelerationObj::setBuilder(const std::string& builder)
  {
    checkError( rtAccelerationSetBuilder(m_acceleration, builder.c_str() ) );
  }

  inline std::string AccelerationObj::getBuilder() const
  {
    const char* s;
    checkError( rtAccelerationGetBuilder(m_acceleration, &s ) );
    return std::string( s );
  }

  inline void AccelerationObj::setTraverser(const std::string& traverser)
  {
    checkError( rtAccelerationSetTraverser(m_acceleration, traverser.c_str() ) );
  }

  inline std::string AccelerationObj::getTraverser() const
  {
    const char* s;
    checkError( rtAccelerationGetTraverser(m_acceleration, &s ) );
    return std::string( s );
  }

  inline RTsize AccelerationObj::getDataSize() const
  {
    RTsize sz;
    checkError( rtAccelerationGetDataSize(m_acceleration, &sz) );
    return sz;
  }

  inline void AccelerationObj::getData( void* data ) const
  {
    checkError( rtAccelerationGetData(m_acceleration,data) );
  }

  inline void AccelerationObj::setData( const void* data, RTsize size )
  {
    checkError( rtAccelerationSetData(m_acceleration,data,size) );
  }

  inline RTacceleration AccelerationObj::get()
  {
    return m_acceleration;
  }

  inline void GeometryInstanceObj::destroy()
  {
    Context context = getContext();
    checkError( rtGeometryInstanceDestroy( m_geometryinstance ), context );
    m_geometryinstance = 0;
  }

  inline void GeometryInstanceObj::validate()
  {
    checkError( rtGeometryInstanceValidate( m_geometryinstance ) );
  }

  inline Context GeometryInstanceObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtGeometryInstanceGetContext( m_geometryinstance, &c ) );
    return Context::take( c );
  }

  inline void GeometryInstanceObj::setGeometry(Geometry geometry)
  {
    checkError( rtGeometryInstanceSetGeometry( m_geometryinstance, geometry->get() ) );
  }

  inline Geometry GeometryInstanceObj::getGeometry() const
  {
    RTgeometry result;
    checkError( rtGeometryInstanceGetGeometry( m_geometryinstance, &result ) );
    return Geometry::take( result );
  }

  inline void GeometryInstanceObj::setMaterialCount(unsigned int  count)
  {
    checkError( rtGeometryInstanceSetMaterialCount( m_geometryinstance, count ) );
  }

  inline unsigned int GeometryInstanceObj::getMaterialCount() const
  {
    unsigned int result;
    checkError( rtGeometryInstanceGetMaterialCount( m_geometryinstance, &result ) );
    return result;
  }

  inline void GeometryInstanceObj::setMaterial(unsigned int idx, Material  material)
  {
    checkError( rtGeometryInstanceSetMaterial( m_geometryinstance, idx, material->get()) );
  }

  inline Material GeometryInstanceObj::getMaterial(unsigned int idx) const
  {
    RTmaterial result;
    checkError( rtGeometryInstanceGetMaterial( m_geometryinstance, idx, &result ) );
    return Material::take( result );
  }

  // Adds the material and returns the index to the added material.
  inline unsigned int GeometryInstanceObj::addMaterial(Material material)
  {
    unsigned int old_count = getMaterialCount();
    setMaterialCount(old_count+1);
    setMaterial(old_count, material);
    return old_count;
  }

  inline Variable GeometryInstanceObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtGeometryInstanceDeclareVariable( m_geometryinstance, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable GeometryInstanceObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtGeometryInstanceQueryVariable( m_geometryinstance, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline void GeometryInstanceObj::removeVariable(Variable v)
  {
    checkError( rtGeometryInstanceRemoveVariable( m_geometryinstance, v->get() ) );
  }

  inline unsigned int GeometryInstanceObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtGeometryInstanceGetVariableCount( m_geometryinstance, &result ) );
    return result;
  }

  inline Variable GeometryInstanceObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtGeometryInstanceGetVariable( m_geometryinstance, index, &v ) );
    return Variable::take( v );
  }

  inline RTgeometryinstance GeometryInstanceObj::get()
  {
    return m_geometryinstance;
  }

  inline void GeometryObj::destroy()
  {
    Context context = getContext();
    checkError( rtGeometryDestroy( m_geometry ), context );
    m_geometry = 0;
  }

  inline void GeometryObj::validate()
  {
    checkError( rtGeometryValidate( m_geometry ) );
  }

  inline Context GeometryObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtGeometryGetContext( m_geometry, &c ) );
    return Context::take( c );
  }

  inline void GeometryObj::setPrimitiveCount(unsigned int num_primitives)
  {
    checkError( rtGeometrySetPrimitiveCount( m_geometry, num_primitives ) );
  }

  inline unsigned int GeometryObj::getPrimitiveCount() const
  {
    unsigned int result;
    checkError( rtGeometryGetPrimitiveCount( m_geometry, &result ) );
    return result;
  }

  inline void GeometryObj::setPrimitiveIndexOffset(unsigned int index_offset)
  {
    checkError( rtGeometrySetPrimitiveIndexOffset( m_geometry, index_offset) );
  }

  inline unsigned int GeometryObj::getPrimitiveIndexOffset() const
  {
    unsigned int result;
    checkError( rtGeometryGetPrimitiveIndexOffset( m_geometry, &result ) );
    return result;
  }

  inline void GeometryObj::setBoundingBoxProgram(Program  program)
  {
    checkError( rtGeometrySetBoundingBoxProgram( m_geometry, program->get() ) );
  }

  inline Program GeometryObj::getBoundingBoxProgram() const
  {
    RTprogram result;
    checkError( rtGeometryGetBoundingBoxProgram( m_geometry, &result ) );
    return Program::take( result );
  }

  inline void GeometryObj::setIntersectionProgram(Program  program)
  {
    checkError( rtGeometrySetIntersectionProgram( m_geometry, program->get() ) );
  }

  inline Program GeometryObj::getIntersectionProgram() const
  {
    RTprogram result;
    checkError( rtGeometryGetIntersectionProgram( m_geometry, &result ) );
    return Program::take( result );
  }

  inline Variable GeometryObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtGeometryDeclareVariable( m_geometry, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable GeometryObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtGeometryQueryVariable( m_geometry, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline void GeometryObj::removeVariable(Variable v)
  {
    checkError( rtGeometryRemoveVariable( m_geometry, v->get() ) );
  }

  inline unsigned int GeometryObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtGeometryGetVariableCount( m_geometry, &result ) );
    return result;
  }

  inline Variable GeometryObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtGeometryGetVariable( m_geometry, index, &v ) );
    return Variable::take( v );
  }

  inline void GeometryObj::markDirty()
  {
    checkError( rtGeometryMarkDirty(m_geometry) );
  }

  inline bool GeometryObj::isDirty() const
  {
    int dirty;
    checkError( rtGeometryIsDirty(m_geometry,&dirty) );
    return dirty != 0;
  }

  inline RTgeometry GeometryObj::get()
  {
    return m_geometry;
  }

  inline void MaterialObj::destroy()
  {
    Context context = getContext();
    checkError( rtMaterialDestroy( m_material ), context );
    m_material = 0;
  }

  inline void MaterialObj::validate()
  {
    checkError( rtMaterialValidate( m_material ) );
  }

  inline Context MaterialObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtMaterialGetContext( m_material, &c ) );
    return Context::take( c );
  }

  inline void MaterialObj::setClosestHitProgram(unsigned int ray_type_index, Program  program)
  {
    checkError( rtMaterialSetClosestHitProgram( m_material, ray_type_index, (program.get() != 0 ? program->get() : 0) ) );
  }

  inline Program MaterialObj::getClosestHitProgram(unsigned int ray_type_index) const
  {
    RTprogram result;
    checkError( rtMaterialGetClosestHitProgram( m_material, ray_type_index, &result ) );
    return Program::take( result );
  }

  inline void MaterialObj::setAnyHitProgram(unsigned int ray_type_index, Program  program)
  {
    checkError( rtMaterialSetAnyHitProgram( m_material, ray_type_index, program->get() ) );
  }

  inline Program MaterialObj::getAnyHitProgram(unsigned int ray_type_index) const
  {
    RTprogram result;
    checkError( rtMaterialGetAnyHitProgram( m_material, ray_type_index, &result ) );
    return Program::take( result );
  }

  inline Variable MaterialObj::declareVariable(const std::string& name)
  {
    RTvariable v;
    checkError( rtMaterialDeclareVariable( m_material, name.c_str(), &v ) );
    return Variable::take( v );
  }

  inline Variable MaterialObj::queryVariable(const std::string& name) const
  {
    RTvariable v;
    checkError( rtMaterialQueryVariable( m_material, name.c_str(), &v) );
    return Variable::take( v );
  }

  inline void MaterialObj::removeVariable(Variable v)
  {
    checkError( rtMaterialRemoveVariable( m_material, v->get() ) );
  }

  inline unsigned int MaterialObj::getVariableCount() const
  {
    unsigned int result;
    checkError( rtMaterialGetVariableCount( m_material, &result ) );
    return result;
  }

  inline Variable MaterialObj::getVariable(unsigned int index) const
  {
    RTvariable v;
    checkError( rtMaterialGetVariable( m_material, index, &v) );
    return Variable::take( v );
  }

  inline RTmaterial MaterialObj::get()
  {
    return m_material;
  }

  inline void TextureSamplerObj::destroy()
  {
    Context context = getContext();
    checkError( rtTextureSamplerDestroy( m_texturesampler ), context );
    m_texturesampler = 0;
  }

  inline void TextureSamplerObj::validate()
  {
    checkError( rtTextureSamplerValidate( m_texturesampler ) );
  }

  inline Context TextureSamplerObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtTextureSamplerGetContext( m_texturesampler, &c ) );
    return Context::take( c );
  }

  inline void TextureSamplerObj::setMipLevelCount(unsigned int  num_mip_levels)
  {
    checkError( rtTextureSamplerSetMipLevelCount(m_texturesampler, num_mip_levels ) );
  }

  inline unsigned int TextureSamplerObj::getMipLevelCount() const
  {
    unsigned int result;
    checkError( rtTextureSamplerGetMipLevelCount( m_texturesampler, &result ) );
    return result;
  }

  inline void TextureSamplerObj::setArraySize(unsigned int  num_textures_in_array)
  {
    checkError( rtTextureSamplerSetArraySize( m_texturesampler, num_textures_in_array ) );
  }

  inline unsigned int TextureSamplerObj::getArraySize() const
  {
    unsigned int result;
    checkError( rtTextureSamplerGetArraySize( m_texturesampler, &result ) );
    return result;
  }

  inline void TextureSamplerObj::setWrapMode(unsigned int dim, RTwrapmode wrapmode)
  {
    checkError( rtTextureSamplerSetWrapMode( m_texturesampler, dim, wrapmode ) );
  }

  inline RTwrapmode TextureSamplerObj::getWrapMode(unsigned int dim) const
  {
    RTwrapmode wrapmode;
    checkError( rtTextureSamplerGetWrapMode( m_texturesampler, dim, &wrapmode ) );
    return wrapmode;
  }

  inline void TextureSamplerObj::setFilteringModes(RTfiltermode  minification, RTfiltermode  magnification, RTfiltermode  mipmapping)
  {
    checkError( rtTextureSamplerSetFilteringModes( m_texturesampler, minification, magnification, mipmapping ) );
  }

  inline void TextureSamplerObj::getFilteringModes(RTfiltermode& minification, RTfiltermode& magnification, RTfiltermode& mipmapping) const
  {
    checkError( rtTextureSamplerGetFilteringModes( m_texturesampler, &minification, &magnification, &mipmapping ) );
  }

  inline void TextureSamplerObj::setMaxAnisotropy(float value)
  {
    checkError( rtTextureSamplerSetMaxAnisotropy(m_texturesampler, value ) );
  }

  inline float TextureSamplerObj::getMaxAnisotropy() const
  {
    float result;
    checkError( rtTextureSamplerGetMaxAnisotropy( m_texturesampler, &result) );
    return result;
  }

  inline void TextureSamplerObj::setMipLevelClamp(float minLevel, float maxLevel)
  {
    checkError( rtTextureSamplerSetMipLevelClamp(m_texturesampler, minLevel, maxLevel ) );
  }

  inline void TextureSamplerObj::getMipLevelClamp(float &minLevel, float &maxLevel) const
  {
    checkError( rtTextureSamplerGetMipLevelClamp( m_texturesampler, &minLevel, &maxLevel) );
  }

  inline void TextureSamplerObj::setMipLevelBias(float value)
  {
    checkError( rtTextureSamplerSetMipLevelBias(m_texturesampler, value ) );
  }

  inline float TextureSamplerObj::getMipLevelBias() const
  {
    float result;
    checkError( rtTextureSamplerGetMipLevelBias( m_texturesampler, &result) );
    return result;
  }

  inline int TextureSamplerObj::getId() const
  {
    int result;
    checkError( rtTextureSamplerGetId( m_texturesampler, &result) );
    return result;
  }

  inline void TextureSamplerObj::setReadMode(RTtexturereadmode  readmode)
  {
    checkError( rtTextureSamplerSetReadMode( m_texturesampler, readmode ) );
  }

  inline RTtexturereadmode TextureSamplerObj::getReadMode() const
  {
    RTtexturereadmode result;
    checkError( rtTextureSamplerGetReadMode( m_texturesampler, &result) );
    return result;
  }

  inline void TextureSamplerObj::setIndexingMode(RTtextureindexmode  indexmode)
  {
    checkError( rtTextureSamplerSetIndexingMode( m_texturesampler, indexmode ) );
  }

  inline RTtextureindexmode TextureSamplerObj::getIndexingMode() const
  {
    RTtextureindexmode result;
    checkError( rtTextureSamplerGetIndexingMode( m_texturesampler, &result ) );
    return result;
  }

  inline void TextureSamplerObj::setBuffer(unsigned int texture_array_idx, unsigned int mip_level, Buffer buffer)
  {
    checkError( rtTextureSamplerSetBuffer( m_texturesampler, texture_array_idx, mip_level, buffer->get() ) );
  }

  inline Buffer TextureSamplerObj::getBuffer(unsigned int texture_array_idx, unsigned int mip_level) const
  {
    RTbuffer result;
    checkError( rtTextureSamplerGetBuffer(m_texturesampler, texture_array_idx, mip_level, &result ) );
    return Buffer::take(result);
  }
   
  inline void TextureSamplerObj::setBuffer(Buffer buffer)
  {
    checkError( rtTextureSamplerSetBuffer( m_texturesampler, 0, 0, buffer->get() ) );
  }

  inline Buffer TextureSamplerObj::getBuffer() const
  {
    RTbuffer result;
    checkError( rtTextureSamplerGetBuffer(m_texturesampler, 0, 0, &result ) );
    return Buffer::take(result);
  }

  inline RTtexturesampler TextureSamplerObj::get()
  {
    return m_texturesampler;
  }

  inline void TextureSamplerObj::registerGLTexture()
  {
    checkError( rtTextureSamplerGLRegister( m_texturesampler ) );
  }

  inline void TextureSamplerObj::unregisterGLTexture()
  {
    checkError( rtTextureSamplerGLUnregister( m_texturesampler ) );
  }

#ifdef _WIN32

  inline void TextureSamplerObj::registerD3D9Texture()
  {
    checkError( rtTextureSamplerD3D9Register( m_texturesampler ) );
  }

  inline void TextureSamplerObj::registerD3D10Texture()
  {
    checkError( rtTextureSamplerD3D10Register( m_texturesampler ) );
  }

  inline void TextureSamplerObj::registerD3D11Texture()
  {
    checkError( rtTextureSamplerD3D11Register( m_texturesampler ) );
  }

  inline void TextureSamplerObj::unregisterD3D9Texture()
  {
    checkError( rtTextureSamplerD3D9Unregister( m_texturesampler ) );
  }

  inline void TextureSamplerObj::unregisterD3D10Texture()
  {
    checkError( rtTextureSamplerD3D10Unregister( m_texturesampler ) );
  }

  inline void TextureSamplerObj::unregisterD3D11Texture()
  {
    checkError( rtTextureSamplerD3D11Unregister( m_texturesampler ) );
  }

#endif

  inline void BufferObj::destroy()
  {
    Context context = getContext();
    checkError( rtBufferDestroy( m_buffer ), context );
    m_buffer = 0;
  }

  inline void BufferObj::validate()
  {
    checkError( rtBufferValidate( m_buffer ) );
  }

  inline Context BufferObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtBufferGetContext( m_buffer, &c ) );
    return Context::take( c );
  }

  inline void BufferObj::setFormat(RTformat format)
  {
    checkError( rtBufferSetFormat( m_buffer, format ) );
  }

  inline RTformat BufferObj::getFormat() const
  {
    RTformat result;
    checkError( rtBufferGetFormat( m_buffer, &result ) );
    return result;
  }

  inline void BufferObj::setElementSize(RTsize size_of_element)
  {
    checkError( rtBufferSetElementSize ( m_buffer, size_of_element ) );
  }

  inline RTsize BufferObj::getElementSize() const
  {
    RTsize result;
    checkError( rtBufferGetElementSize ( m_buffer, &result) );
    return result;
  }

  inline void BufferObj::getDevicePointer(unsigned int optix_device_number, CUdeviceptr *device_pointer)
  {
    checkError( rtBufferGetDevicePointer( m_buffer, optix_device_number, (void**)device_pointer ) );
  }

  inline CUdeviceptr BufferObj::getDevicePointer( unsigned int optix_device_number )
  {
    CUdeviceptr dptr;
    getDevicePointer( optix_device_number, &dptr );
    return dptr;
  }

  inline void BufferObj::setDevicePointer(unsigned int optix_device_number, CUdeviceptr device_pointer)
  {
    checkError( rtBufferSetDevicePointer( m_buffer, optix_device_number, device_pointer ) );
  }

  inline void BufferObj::markDirty()
  {
    checkError( rtBufferMarkDirty( m_buffer ) );
  }

  inline void BufferObj::setSize(RTsize width)
  {
    checkError( rtBufferSetSize1D( m_buffer, width ) );
  }

  inline void BufferObj::getSize(RTsize& width) const
  {
    checkError( rtBufferGetSize1D( m_buffer, &width ) );
  }
   
  inline void BufferObj::getMipLevelSize(unsigned int level, RTsize& width) const
  {
    checkError( rtBufferGetMipLevelSize1D( m_buffer, level, &width ) );
  }

  inline void BufferObj::setSize(RTsize width, RTsize height)
  {
    checkError( rtBufferSetSize2D( m_buffer, width, height ) );
  }

  inline void BufferObj::getSize(RTsize& width, RTsize& height) const
  {
    checkError( rtBufferGetSize2D( m_buffer, &width, &height ) );
  }

  inline void BufferObj::getMipLevelSize(unsigned int level, RTsize& width, RTsize& height) const
  {
    checkError( rtBufferGetMipLevelSize2D( m_buffer, level, &width, &height ) );
  }

  inline void BufferObj::setSize(RTsize width, RTsize height, RTsize depth)
  {
    checkError( rtBufferSetSize3D( m_buffer, width, height, depth ) );
  }

  inline void BufferObj::getSize(RTsize& width, RTsize& height, RTsize& depth) const
  {
    checkError( rtBufferGetSize3D( m_buffer, &width, &height, &depth ) );
  }

  inline void BufferObj::getMipLevelSize(unsigned int level, RTsize& width, RTsize& height, RTsize& depth) const
  {
    checkError( rtBufferGetMipLevelSize3D( m_buffer, level,  &width, &height, &depth ) );
  }

  inline void BufferObj::setSize(unsigned int dimensionality, const RTsize* dims)
  {
    checkError( rtBufferSetSizev( m_buffer, dimensionality, dims ) );
  }

  inline void BufferObj::getSize(unsigned int dimensionality, RTsize* dims) const
  {
    checkError( rtBufferGetSizev( m_buffer, dimensionality, dims ) );
  }

  inline unsigned int BufferObj::getDimensionality() const
  {
    unsigned int result;
    checkError( rtBufferGetDimensionality( m_buffer, &result ) );
    return result;
  }
   
  inline void BufferObj::setMipLevelCount(unsigned int levels)
  {
    checkError( rtBufferSetMipLevelCount( m_buffer, levels ) );
  }

  inline unsigned int BufferObj::getMipLevelCount() const
  {
    unsigned int result;
    checkError( rtBufferGetMipLevelCount( m_buffer, &result ) );
    return result;
  }
      
  inline int BufferObj::getId() const
  {
    int result;
    checkError( rtBufferGetId( m_buffer, &result ) );
    return result;
  }

  inline unsigned int BufferObj::getGLBOId() const
  {
    unsigned int result;
    checkError( rtBufferGetGLBOId( m_buffer, &result ) );
    return result;
  }

  inline void BufferObj::registerGLBuffer()
  {
    checkError( rtBufferGLRegister( m_buffer ) );
  }

  inline void BufferObj::unregisterGLBuffer()
  {
    checkError( rtBufferGLUnregister( m_buffer ) );
  }

#ifdef _WIN32

  inline void BufferObj::registerD3D9Buffer()
  {
    checkError( rtBufferD3D9Register( m_buffer ) );
  }

  inline void BufferObj::registerD3D10Buffer()
  {
    checkError( rtBufferD3D10Register( m_buffer ) );
  }

  inline void BufferObj::registerD3D11Buffer()
  {
    checkError( rtBufferD3D11Register( m_buffer ) );
  }

  inline void BufferObj::unregisterD3D9Buffer()
  {
    checkError( rtBufferD3D9Unregister( m_buffer ) );
  }

  inline void BufferObj::unregisterD3D10Buffer()
  {
    checkError( rtBufferD3D10Unregister( m_buffer ) );
  }

  inline void BufferObj::unregisterD3D11Buffer()
  {
    checkError( rtBufferD3D11Unregister( m_buffer ) );
  }

  inline IDirect3DResource9* BufferObj::getD3D9Resource()
  {
    IDirect3DResource9* result = NULL;
    checkError( rtBufferGetD3D9Resource( m_buffer, &result ) );
    return result;
  }
  
  inline ID3D10Resource* BufferObj::getD3D10Resource()
  {
    ID3D10Resource* result = NULL;
    checkError( rtBufferGetD3D10Resource( m_buffer, &result ) );
    return result;
  }
  
  inline ID3D11Resource* BufferObj::getD3D11Resource()
  {
    ID3D11Resource* result = NULL;
    checkError( rtBufferGetD3D11Resource( m_buffer, &result ) );
    return result;
  }

#endif

  inline void* BufferObj::map()
  {
    void* result;
    checkError( rtBufferMap( m_buffer, &result ) );
    return result;
  }

  inline void BufferObj::unmap()
  {
    checkError( rtBufferUnmap( m_buffer ) );
  }
    
  inline void* BufferObj::map(unsigned int level)
  {
    void* result;
    checkError( rtBufferMapEx( m_buffer, RT_BUFFER_MAP_READ_WRITE, level, 0, &result ) );
    return result;
  }

  inline void BufferObj::unmap(unsigned int level)
  {
    checkError( rtBufferUnmapEx( m_buffer, level ) );
  }

  inline void BufferObj::bindProgressiveStream( Buffer source )
  {
    checkError( rtBufferBindProgressiveStream( m_buffer, source->get() ) );
  }

  inline void BufferObj::getProgressiveUpdateReady( int* ready, unsigned int* subframe_count, unsigned int* max_subframes )
  {
    checkError( rtBufferGetProgressiveUpdateReady( m_buffer, ready, subframe_count, max_subframes ) );
  }

  inline RTbuffer BufferObj::get()
  {
    return m_buffer;
  }

  inline void BufferObj::setAttribute( RTbufferattribute attrib, RTsize size, void *p )
  {
    checkError( rtBufferSetAttribute( m_buffer, attrib, size, p ) );
  }

  inline void BufferObj::getAttribute( RTbufferattribute attrib, RTsize size, void *p )
  {
    checkError( rtBufferGetAttribute( m_buffer, attrib, size, p ) );
  }

  inline RemoteDevice RemoteDeviceObj::create( const std::string& url, const std::string& username, const std::string& password )
  {
    RTremotedevice rdev;
    if ( RTresult code = rtRemoteDeviceCreate( url.c_str(), username.c_str(), password.c_str(), &rdev) )
        throw Exception::makeException( code, 0 );

    return RemoteDevice::take(rdev);
  }


  inline Context RemoteDeviceObj::getContext() const 
  {
    RTcontext ctx = 0;
    return Context::take( ctx ); 
  }

  inline void RemoteDeviceObj::destroy()
  {
    checkErrorNoGetContext( rtRemoteDeviceDestroy( m_rdev ) );
    m_rdev = 0;
  }

  inline void RemoteDeviceObj::reserve( unsigned int num_nodes, unsigned int configuration_idx )
  {
    checkErrorNoGetContext( rtRemoteDeviceReserve( m_rdev, num_nodes, configuration_idx ) );
  }

  inline void RemoteDeviceObj::release()
  {
    checkErrorNoGetContext( rtRemoteDeviceRelease( m_rdev ) );
  }

  inline void RemoteDeviceObj::getAttribute( RTremotedeviceattribute attrib, RTsize size, void *p )
  {
    checkErrorNoGetContext( rtRemoteDeviceGetAttribute( m_rdev, attrib, size, p ) );
  }

  inline std::string RemoteDeviceObj::getConfiguration( unsigned int config_index )
  {
    char tmp[256];
    checkErrorNoGetContext( rtRemoteDeviceGetAttribute( m_rdev, (RTremotedeviceattribute)(RT_REMOTEDEVICE_ATTRIBUTE_CONFIGURATIONS+config_index), 256, tmp ) );
    return std::string( tmp );
  }

  inline RTremotedevice RemoteDeviceObj::get()
  {
    return m_rdev;
  }

  inline Context VariableObj::getContext() const
  {
    RTcontext c;
    checkErrorNoGetContext( rtVariableGetContext( m_variable, &c ) );
    return Context::take( c );
  }

  inline void VariableObj::setUint(unsigned int u1)
  {
    checkError( rtVariableSet1ui( m_variable, u1 ) );
  }

  inline void VariableObj::setUint(unsigned int u1, unsigned int u2)
  {
    checkError( rtVariableSet2ui( m_variable, u1, u2 ) );
  }

  inline void VariableObj::setUint(unsigned int u1, unsigned int u2, unsigned int u3)
  {
    checkError( rtVariableSet3ui( m_variable, u1, u2, u3 ) );
  }

  inline void VariableObj::setUint(unsigned int u1, unsigned int u2, unsigned int u3, unsigned int u4)
  {
    checkError( rtVariableSet4ui( m_variable, u1, u2, u3, u4 ) );
  }

  inline void VariableObj::setUint(optix::uint2 u)
  {
    checkError( rtVariableSet2uiv( m_variable, &u.x ) );
  }

  inline void VariableObj::setUint(optix::uint3 u)
  {
    checkError( rtVariableSet3uiv( m_variable, &u.x ) );
  }

  inline void VariableObj::setUint(optix::uint4 u)
  {
    checkError( rtVariableSet4uiv( m_variable, &u.x ) );
  }

  inline void VariableObj::set1uiv(const unsigned int* u)
  {
    checkError( rtVariableSet1uiv( m_variable, u ) );
  }

  inline void VariableObj::set2uiv(const unsigned int* u)
  {
    checkError( rtVariableSet2uiv( m_variable, u ) );
  }

  inline void VariableObj::set3uiv(const unsigned int* u)
  {
    checkError( rtVariableSet3uiv( m_variable, u ) );
  }

  inline void VariableObj::set4uiv(const unsigned int* u)
  {
    checkError( rtVariableSet4uiv( m_variable, u ) );
  }

  inline void VariableObj::setMatrix2x2fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix2x2fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix2x3fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix2x3fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix2x4fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix2x4fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix3x2fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix3x2fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix3x3fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix3x3fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix3x4fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix3x4fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix4x2fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix4x2fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix4x3fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix4x3fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setMatrix4x4fv(bool transpose, const float* m)
  {
    checkError( rtVariableSetMatrix4x4fv( m_variable, (int)transpose, m ) );
  }

  inline void VariableObj::setFloat(float f1)
  {
    checkError( rtVariableSet1f( m_variable, f1 ) );
  }

  inline void VariableObj::setFloat(optix::float2 f)
  {
    checkError( rtVariableSet2fv( m_variable, &f.x ) );
  }

  inline void VariableObj::setFloat(float f1, float f2)
  {
    checkError( rtVariableSet2f( m_variable, f1, f2 ) );
  }

  inline void VariableObj::setFloat(optix::float3 f)
  {
    checkError( rtVariableSet3fv( m_variable, &f.x ) );
  }

  inline void VariableObj::setFloat(float f1, float f2, float f3)
  {
    checkError( rtVariableSet3f( m_variable, f1, f2, f3 ) );
  }

  inline void VariableObj::setFloat(optix::float4 f)
  {
    checkError( rtVariableSet4fv( m_variable, &f.x ) );
  }

  inline void VariableObj::setFloat(float f1, float f2, float f3, float f4)
  {
    checkError( rtVariableSet4f( m_variable, f1, f2, f3, f4 ) );
  }

  inline void VariableObj::set1fv(const float* f)
  {
    checkError( rtVariableSet1fv( m_variable, f ) );
  }

  inline void VariableObj::set2fv(const float* f)
  {
    checkError( rtVariableSet2fv( m_variable, f ) );
  }

  inline void VariableObj::set3fv(const float* f)
  {
    checkError( rtVariableSet3fv( m_variable, f ) );
  }

  inline void VariableObj::set4fv(const float* f)
  {
    checkError( rtVariableSet4fv( m_variable, f ) );
  }

  inline void VariableObj::setInt(int i1)
  {
    checkError( rtVariableSet1i( m_variable, i1 ) );
  }

  inline void VariableObj::setInt(optix::int2 i)
  {
    checkError( rtVariableSet2iv( m_variable, &i.x ) );
  }

  inline void VariableObj::setInt(int i1, int i2)
  {
    checkError( rtVariableSet2i( m_variable, i1, i2 ) );
  }

  inline void VariableObj::setInt(optix::int3 i)
  {
    checkError( rtVariableSet3iv( m_variable, &i.x ) );
  }

  inline void VariableObj::setInt(int i1, int i2, int i3)
  {
    checkError( rtVariableSet3i( m_variable, i1, i2, i3 ) );
  }

  inline void VariableObj::setInt(optix::int4 i)
  {
    checkError( rtVariableSet4iv( m_variable, &i.x ) );
  }

  inline void VariableObj::setInt(int i1, int i2, int i3, int i4)
  {
    checkError( rtVariableSet4i( m_variable, i1, i2, i3, i4 ) );
  }

  inline void VariableObj::set1iv( const int* i )
  {
    checkError( rtVariableSet1iv( m_variable, i ) );
  }

  inline void VariableObj::set2iv( const int* i )
  {
    checkError( rtVariableSet2iv( m_variable, i ) );
  }

  inline void VariableObj::set3iv( const int* i )
  {
    checkError( rtVariableSet3iv( m_variable, i ) );
  }

  inline void VariableObj::set4iv( const int* i )
  {
    checkError( rtVariableSet4iv( m_variable, i ) );
  }

  inline void VariableObj::setBuffer(Buffer buffer)
  {
    checkError( rtVariableSetObject( m_variable, buffer->get() ) );
  }

  inline void VariableObj::set(Buffer buffer)
  {
    checkError( rtVariableSetObject( m_variable, buffer->get() ) );
  }

  inline void VariableObj::setUserData(RTsize size, const void* ptr)
  {
    checkError( rtVariableSetUserData( m_variable, size, ptr ) );
  }

  inline void VariableObj::getUserData(RTsize size,       void* ptr) const
  {
    checkError( rtVariableGetUserData( m_variable, size, ptr ) );
  }

  inline void VariableObj::setTextureSampler(TextureSampler texturesampler)
  {
    checkError( rtVariableSetObject( m_variable, texturesampler->get() ) );
  }

  inline void VariableObj::set(TextureSampler texturesampler)
  {
    checkError( rtVariableSetObject( m_variable, texturesampler->get() ) );
  }

  inline void VariableObj::set(GeometryGroup group)
  {
    checkError( rtVariableSetObject( m_variable, group->get() ) );
  }

  inline void VariableObj::set(Group group)
  {
    checkError( rtVariableSetObject( m_variable, group->get() ) );
  }

  inline void VariableObj::set(Program program)
  {
    checkError( rtVariableSetObject( m_variable, program->get() ) );
  }

  inline void VariableObj::setProgramId(Program program)
  {
    int id = program->getId();
    setInt(id);
  }
  
  inline void VariableObj::set(Selector sel)
  {
    checkError( rtVariableSetObject( m_variable, sel->get() ) );
  }

  inline void VariableObj::set(Transform tran)
  {
    checkError( rtVariableSetObject( m_variable, tran->get() ) );
  }

  inline Buffer VariableObj::getBuffer() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTbuffer buffer = reinterpret_cast<RTbuffer>(temp);
    return Buffer::take(buffer);
  }

  inline std::string VariableObj::getName() const
  {
    const char* name;
    checkError( rtVariableGetName( m_variable, &name ) );
    return std::string(name);
  }

  inline std::string VariableObj::getAnnotation() const
  {
    const char* annotation;
    checkError( rtVariableGetAnnotation( m_variable, &annotation ) );
    return std::string(annotation);
  }

  inline RTobjecttype VariableObj::getType() const
  {
    RTobjecttype type;
    checkError( rtVariableGetType( m_variable, &type ) );
    return type;
  }

  inline RTvariable VariableObj::get()
  {
    return m_variable;
  }

  inline RTsize VariableObj::getSize() const
  {
    RTsize size;
    checkError( rtVariableGetSize( m_variable, &size ) );
    return size;
  }

  inline optix::GeometryGroup VariableObj::getGeometryGroup() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTgeometrygroup geometrygroup = reinterpret_cast<RTgeometrygroup>(temp);
    return GeometryGroup::take( geometrygroup );
  }

  inline optix::GeometryInstance VariableObj::getGeometryInstance() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTgeometryinstance geometryinstance = 
      reinterpret_cast<RTgeometryinstance>(temp);
    return GeometryInstance::take( geometryinstance );
  }

  inline optix::Group VariableObj::getGroup() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTgroup group = reinterpret_cast<RTgroup>(temp);
    return Group::take( group );
  }

  inline optix::Program VariableObj::getProgram() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTprogram program = reinterpret_cast<RTprogram>(temp);
    return Program::take(program);
  }

  inline optix::Selector VariableObj::getSelector() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTselector selector = reinterpret_cast<RTselector>(temp);
    return Selector::take( selector );
  }

  inline optix::TextureSampler VariableObj::getTextureSampler() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTtexturesampler sampler = reinterpret_cast<RTtexturesampler>(temp);
    return TextureSampler::take(sampler);
  }

  inline optix::Transform VariableObj::getTransform() const
  {
    RTobject temp;
    checkError( rtVariableGetObject( m_variable, &temp ) );
    RTtransform transform = reinterpret_cast<RTtransform>(temp);
    return Transform::take( transform );
  }

  inline float VariableObj::getFloat() const
  {
    float f;
    checkError( rtVariableGet1f( m_variable, &f ) );
    return f;
  }

  inline optix::float2 VariableObj::getFloat2() const
  {
      optix::float2 f;
      checkError( rtVariableGet2f( m_variable, &f.x, &f.y ) );
      return f;

  }

  inline optix::float3 VariableObj::getFloat3() const
  {
      optix::float3 f;
      checkError( rtVariableGet3f( m_variable, &f.x, &f.y, &f.z ) );
      return f;
  }

  inline optix::float4 VariableObj::getFloat4() const
  {
      optix::float4 f;
      checkError( rtVariableGet4f( m_variable, &f.x, &f.y, &f.z, &f.w ) );
      return f;
  }

  inline void VariableObj::getFloat(float& f1) const
  {
    checkError( rtVariableGet1f( m_variable, &f1 ) );
  }

  inline void VariableObj::getFloat(float& f1, float& f2) const
  {
      checkError( rtVariableGet2f( m_variable, &f1, &f2 ) );
  }

  inline void VariableObj::getFloat(float& f1, float& f2, float& f3) const
  {
      checkError( rtVariableGet3f( m_variable, &f1, &f2, &f3 ) );
  }

  inline void VariableObj::getFloat(float& f1, float& f2, float& f3,
                                 float& f4) const
  {
      checkError( rtVariableGet4f( m_variable, &f1, &f2, &f3, &f4 ) );
  }


  inline unsigned VariableObj::getUint()  const
  {
    unsigned u;
    checkError( rtVariableGet1ui( m_variable, &u ) );
    return u;
  }

  inline optix::uint2 VariableObj::getUint2() const
  {
    optix::uint2 u;
    checkError( rtVariableGet2ui( m_variable, &u.x, &u.y ) );
    return u;
  }

  inline optix::uint3 VariableObj::getUint3() const
  {
    optix::uint3 u;
    checkError( rtVariableGet3ui( m_variable, &u.x, &u.y, &u.z ) );
    return u;
  }

  inline optix::uint4 VariableObj::getUint4() const
  {
    optix::uint4 u;
    checkError( rtVariableGet4ui( m_variable, &u.x, &u.y, &u.z, &u.w ) );
    return u;
  }

  inline void VariableObj::getUint(unsigned& u1) const
  {
    checkError( rtVariableGet1ui( m_variable, &u1 ) );
  }

  inline void VariableObj::getUint(unsigned& u1, unsigned& u2) const
  {
    checkError( rtVariableGet2ui( m_variable, &u1, &u2 ) );
  }

  inline void VariableObj::getUint(unsigned& u1, unsigned& u2, unsigned& u3) const
  {
    checkError( rtVariableGet3ui( m_variable, &u1, &u2, &u3 ) );
  }

  inline void VariableObj::getUint(unsigned& u1, unsigned& u2, unsigned& u3,
                                unsigned& u4) const
  {
    checkError( rtVariableGet4ui( m_variable, &u1, &u2, &u3, &u4 ) );
  }

  inline int VariableObj::getInt()  const
  {
    int i;
    checkError( rtVariableGet1i( m_variable, &i ) );
    return i;
  }

  inline optix::int2 VariableObj::getInt2() const
  {
    optix::int2 i;
    checkError( rtVariableGet2i( m_variable, &i.x, &i.y ) );
    return i;
  }

  inline optix::int3 VariableObj::getInt3() const
  {
    optix::int3 i;
    checkError( rtVariableGet3i( m_variable, &i.x, &i.y, &i.z ) );
    return i;
  }

  inline optix::int4 VariableObj::getInt4() const
  {
    optix::int4 i;
    checkError( rtVariableGet4i( m_variable, &i.x, &i.y, &i.z, &i.w ) );
    return i;
  }

  inline void VariableObj::getInt(int& i1) const
  {
    checkError( rtVariableGet1i( m_variable, &i1 ) );
  }

  inline void VariableObj::getInt(int& i1, int& i2) const
  {
    checkError( rtVariableGet2i( m_variable, &i1, &i2 ) );
  }

  inline void VariableObj::getInt(int& i1, int& i2, int& i3) const
  {
    checkError( rtVariableGet3i( m_variable, &i1, &i2, &i3 ) );
  }

  inline void VariableObj::getInt(int& i1, int& i2, int& i3, int& i4) const
  {
    checkError( rtVariableGet4i( m_variable, &i1, &i2, &i3, &i4 ) );
  }

  inline void VariableObj::getMatrix2x2(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix2x2fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix2x3(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix2x3fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix2x4(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix2x4fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix3x2(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix3x2fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix3x3(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix3x3fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix3x4(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix3x4fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix4x2(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix4x2fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix4x3(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix4x3fv( m_variable, transpose, m ) );
  }

  inline void VariableObj::getMatrix4x4(bool transpose, float* m) const
  {
    checkError( rtVariableGetMatrix4x4fv( m_variable, transpose, m ) );
  }
}

#endif /* __optixu_optixpp_namespace_h__ */