cuda_shared_types.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 *****************************************************************************/
 
#ifndef NVIDIA_INDEX_CUDA_SHARED_TYPES_H
#define NVIDIA_INDEX_CUDA_SHARED_TYPES_H
 
#ifndef __CUDACC__
#include "base/numeric_types.h"
#endif
 
#include "base_math/constants.h"
 
// Type definitions ///////////////////////////////////////////////////////////////////////////////
typedef unsigned int   uint;
typedef unsigned short ushort;
 
// Matrix math
template<typename T>
struct matrix2x2
{
    T xx;  
    T xy;  
    T yx;  
    T yy;  
};
 
template<typename T>
struct matrix3x3
{
    T xx;  
    T xy;  
    T xz;  
    T yx;  
    T yy;  
    T yz;  
    T zx;  
    T zy;  
    T zz;  
};
 
template<typename T>
struct matrix4x4
{
    T xx;  
    T xy;  
    T xz;  
    T xw;  
    T yx;  
    T yy;  
    T yz;  
    T yw;  
    T zx;  
    T zy;  
    T zz;  
    T zw;  
    T wx;  
    T wy;  
    T wz;  
    T ww;  
};
 
template<typename T>
struct bbox {
    T min;
    T max;
};
 
#ifdef __CUDACC__
 
namespace nv {
namespace index {
namespace cuda {
 
typedef int2                    Vec2i;
typedef int3                    Vec3i;
typedef int4                    Vec4i;
 
typedef uint2                   Vec2ui;
typedef uint3                   Vec3ui;
typedef uint4                   Vec4ui;
 
typedef float2                  Vec2f;
typedef float3                  Vec3f;
typedef float4                  Vec4f;
 
typedef matrix2x2<float>        Mat2x2f;
typedef matrix3x3<float>        Mat3x3f;
typedef matrix4x4<float>        Mat4x4f;
typedef matrix2x2<float>        Mat2f;
typedef matrix3x3<float>        Mat3f;
typedef matrix4x4<float>        Mat4f;
 
typedef bbox<float2>            Bbox2f;
typedef bbox<float3>            Bbox3f;
 
} // namespace cuda
} // namespace index
} // namespace nv
 
// Define basic mi types, so that we don't need the complex include file when using the CUDA
// compiler
 
namespace mi {
 
// The integer sizes are valid for both LP64 (Linux) and Windows (LLP64)
typedef short              Sint16;
typedef unsigned short     Uint16;
typedef int                Sint32;
typedef unsigned int       Uint32;
typedef long long          Sint64;
typedef unsigned long long Uint64;
typedef float              Float32;
typedef double             Float64;
 
}
 
#else // __CUDACC__
 
namespace nv {
namespace index {
namespace cuda {
 
typedef nv::index::Vector2s     Vec2i;
typedef nv::index::Vector3s     Vec3i;
typedef nv::index::Vector4s     Vec4i;
 
typedef nv::index::Vector2u     Vec2ui;
typedef nv::index::Vector3u     Vec3ui;
typedef nv::index::Vector4u     Vec4ui;
 
typedef nv::index::Vector2f     Vec2f;
typedef nv::index::Vector3f     Vec3f;
typedef nv::index::Vector4f     Vec4f;
 
typedef nv::index::Matrix2x2f   Mat2x2f;
typedef nv::index::Matrix3x3f   Mat3x3f;
typedef nv::index::Matrix4x4f   Mat4x4f;
typedef nv::index::Matrix2x2f   Mat2f;
typedef nv::index::Matrix3x3f   Mat3f;
typedef nv::index::Matrix4x4f   Mat4f;
 
typedef bbox<Vec2f>             Bbox2f;
typedef bbox<Vec3f>             Bbox3f;
 
} // namespace cuda
} // namespace index
} // namespace nv
 
#endif // __CUDACC__
 
// Function definitions ///////////////////////////////////////////////////////////////////////////
 
namespace nv {
namespace index {
namespace cuda {
 
#ifdef __CUDACC__
 
static __inline__ __host__ __device__
Vec3f make_vec3f(float x, float y, float z)
{
    return make_float3(x, y, z);
}
 
static __inline__ __host__ __device__
Vec4f make_vec4f(float x, float y, float z, float w)
{
    return make_float4(x, y, z, w);
}
 
static __inline__ __host__ __device__
Mat2x2f make_mat2x2f(float xx, float xy, float yx, float yy)
{
    matrix2x2<float> m;
    
    m.xx = xx;
    m.xy = xy;
    m.yx = yx;
    m.yy = yy;
    
    return m;
}
 
#else // __CUDACC__
 
// define missing math functions
static inline Vec2f make_vec2f(float x, float y)
{
    return Vec2f(x, y);
}
 
static inline Vec3f make_vec3f(float x, float y, float z)
{
    return Vec3f(x, y, z);
}
 
static inline Vec4f make_vec4f(float x, float y, float z, float w)
{
    return Vec4f(x, y, z, w);
}
 
static inline Mat2x2f make_mat2x2f(float xx, float xy, float yx, float yy)
{
    return Mat2x2f(xx, xy, yx, yy);
}
 
template <typename T, mi::Size DIM>
inline
mi::math::Vector<T,DIM> normalize(const mi::math::Vector<T, DIM>& v)
{
    mi::math::Vector<T, DIM> r(v);
    r.normalize();
    return r;
}
 
#endif // __CUDACC__
 
} // namespace cuda
} // namespace index
} // namespace nv
 
#endif // NVIDIA_INDEX_CUDA_SHARED_TYPES_H