MRIntersectionPrecomputes.h

Go to the documentation of this file.

#pragma once
 
#include "MRVector3.h"
#include "MRPch/MRBindingMacros.h"
 
#if defined(__x86_64__) || defined(_M_X64)
#include <xmmintrin.h> 
#elif defined(__aarch64__) || defined(_M_ARM64)
#include <arm_neon.h> 
#elif defined(__wasm_simd128__)
#include <wasm_simd128.h> 
#endif
 
namespace MR
{


template <typename T>
void findMaxVectorDim( int& dimX, int& dimY, int& dimZ, const Vector3<T>& dir )
{
    if( dir.x > dir.y )
    {
        if( dir.x > dir.z )
        {
            if( dir.y > dir.z )
            {
                if( -dir.z > dir.x )
                {
                    dimZ = 2; dimX = 1; dimY = 0;
                }
                else
                {
                    dimZ = 0; dimX = 1; dimY = 2;
                }
            }
            else
            {
                if( -dir.y > dir.x )
                {
                    dimZ = 1; dimX = 0; dimY = 2;
                }
                else
                {
                    dimZ = 0; dimX = 1; dimY = 2;
                }
            }
        }
        else
        {
            if( -dir.y > dir.z )
            {
                dimZ = 1; dimX = 0; dimY = 2;
            }
            else
            {
                dimZ = 2; dimX = 0; dimY = 1;
            }
        }
    }
    else
    {
        if( dir.y > dir.z )
        {
            if( dir.x < dir.z )
            {
                if( -dir.x > dir.y )
                {
                    dimZ = 0; dimX = 2; dimY = 1;
                }
                else
                {
                    dimZ = 1; dimX = 2; dimY = 0;
                }
            }
            else
            {
                if( -dir.z > dir.y )
                {
                    dimZ = 2; dimX = 1; dimY = 0;
                }
                else
                {
                    dimZ = 1; dimX = 2; dimY = 0;
                }
            }
        }
        else
        {
            if( -dir.x > dir.z )
            {
                dimZ = 0; dimX = 2; dimY = 1;
            }
            else
            {
                dimZ = 2; dimX = 0; dimY = 1;
            }
        }
    }
}

template<typename T>
struct IntersectionPrecomputes
{
    MR_BIND_IGNORE Vector3<T> invDir;
    int maxDimIdxZ = 2;
    int idxX = 0;
    int idxY = 1;

    MR_BIND_IGNORE Vector3i sign;

    T Sx, Sy, Sz;
    IntersectionPrecomputes() = default;
    IntersectionPrecomputes( const Vector3<T>& dir )
    {
        findMaxVectorDim( idxX, idxY, maxDimIdxZ, dir );
 
        sign.x = dir.x >= T( 0 ) ? 1 : 0;
        sign.y = dir.y >= T( 0 ) ? 1 : 0;
        sign.z = dir.z >= T( 0 ) ? 1 : 0;
 
        Sx = dir[idxX] / dir[maxDimIdxZ];
        Sy = dir[idxY] / dir[maxDimIdxZ];
        Sz = T( 1 ) / dir[maxDimIdxZ];
 
        invDir.x = ( dir.x == 0 ) ? std::numeric_limits<T>::max() : T( 1 ) / dir.x;
        invDir.y = ( dir.y == 0 ) ? std::numeric_limits<T>::max() : T( 1 ) / dir.y;
        invDir.z = ( dir.z == 0 ) ? std::numeric_limits<T>::max() : T( 1 ) / dir.z;
    }
 
};

#if defined(__x86_64__) || defined(_M_X64)
template<>
struct IntersectionPrecomputes<float>
{
    MR_BIND_IGNORE __m128 invDir;
    int maxDimIdxZ = 2;
    int idxX = 0;
    int idxY = 1;

    MR_BIND_IGNORE float Sx, Sy, Sz;
 
    IntersectionPrecomputes() = default;
    IntersectionPrecomputes( const Vector3<float>& dir )
    {
        findMaxVectorDim( idxX, idxY, maxDimIdxZ, dir );
 
        Sx = dir[idxX] / dir[maxDimIdxZ];
        Sy = dir[idxY] / dir[maxDimIdxZ];
        Sz = float( 1 ) / dir[maxDimIdxZ];
 
        invDir = _mm_set_ps(
            1,
            ( dir.z == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.z,
            ( dir.y == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.y,
            ( dir.x == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.x );
    }
 
};

#elif defined(__aarch64__) || defined(_M_ARM64)

MR_BIND_IGNORE inline float32x4_t toFloat32x4( float x, float y, float z, float w )
{
    const float a[4] = { x, y, z, w };
    return vld1q_f32( a );
}
 
template<>
struct IntersectionPrecomputes<float>
{
    MR_BIND_IGNORE float32x4_t invDir;
    int maxDimIdxZ = 2;
    int idxX = 0;
    int idxY = 1;

    MR_BIND_IGNORE float Sx, Sy, Sz;
 
    IntersectionPrecomputes() = default;
    IntersectionPrecomputes( const Vector3<float>& dir )
    {
        findMaxVectorDim( idxX, idxY, maxDimIdxZ, dir );
 
        Sx = dir[idxX] / dir[maxDimIdxZ];
        Sy = dir[idxY] / dir[maxDimIdxZ];
        Sz = float( 1 ) / dir[maxDimIdxZ];
 
        invDir = toFloat32x4(
            ( dir.x == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.x,
            ( dir.y == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.y,
            ( dir.z == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.z,
            1 );
    }
 
};

#elif defined(__wasm_simd128__)
template<>
struct IntersectionPrecomputes<float>
{
    MR_BIND_IGNORE v128_t invDir;
    int maxDimIdxZ = 2;
    int idxX = 0;
    int idxY = 1;

    MR_BIND_IGNORE float Sx, Sy, Sz;
 
    IntersectionPrecomputes() = default;
    IntersectionPrecomputes( const Vector3<float>& dir )
    {
        findMaxVectorDim( idxX, idxY, maxDimIdxZ, dir );
 
        Sx = dir[idxX] / dir[maxDimIdxZ];
        Sy = dir[idxY] / dir[maxDimIdxZ];
        Sz = float( 1 ) / dir[maxDimIdxZ];
 
        invDir = wasm_f32x4_make(
            ( dir.x == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.x,
            ( dir.y == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.y,
            ( dir.z == 0 ) ? std::numeric_limits<float>::max() : 1 / dir.z,
            1 );
    }
 
};
 
#else
    #pragma message("IntersectionPrecomputes<float>: no hardware optimized instructions")
#endif

 
}