Indices.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/Object.h"
#include "objects/geometry/Vector.h"
 
NAMESPACE_SPH_BEGIN
 
#define SPH_NO_ROUNDING_MODE
 
class Indices {
private:
    union {
        __m128i i;
        int a[4];
    } data;
 
 
public:
    INLINE Indices() = default;
 
    INLINE Indices(__m128i i) {
        data.i = i;
    }
 
    INLINE explicit Indices(const int value) {
        data.i = _mm_set1_epi32(value);
    }
 
    INLINE Indices(const int i, const int j, const int k, const int l = 0) {
        data.i = _mm_set_epi32(l, k, j, i);
    }
 
#ifndef SPH_NO_ROUNDING_MODE
    INLINE explicit Indices(const BasicVector<float>& v) {
        data = _mm_cvtps_epi32(v.sse());
    }
#else
    INLINE explicit Indices(const BasicVector<float>& v)
        : Indices(int(v[X]), int(v[Y]), int(v[Z]), int(v[H])) {}
#endif
 
    INLINE explicit Indices(const BasicVector<double>& v) {
        *this = Indices(int(v[0]), int(v[1]), int(v[2]), int(v[3]));
    }
 
    INLINE Indices(const Indices& other)
        : data(other.data) {}
 
    INLINE static void init() {
#ifndef SPH_NO_ROUNDING_MODE
        _MM_SET_ROUNDING_MODE(_MM_ROUND_DOWN);
#endif
    }
 
    INLINE Indices& operator=(const Indices& other) {
        data = other.data;
        return *this;
    }
 
#ifndef SPH_NO_ROUNDING_MODE
    INLINE operator BasicVector<float>() const {
        return BasicVector<float>(_mm_cvtepi32_ps(data));
    }
#else
    INLINE operator BasicVector<float>() const {
        return BasicVector<float>((*this)[0], (*this)[1], (*this)[2], (*this)[3]);
    }
#endif
 
    INLINE operator BasicVector<double>() const {
        return BasicVector<double>((*this)[0], (*this)[1], (*this)[2], (*this)[3]);
    }
 
    INLINE int& operator[](const int idx) {
        SPH_ASSERT(unsigned(idx) < 4);
        return data.a[idx];
    }
 
    INLINE int operator[](const int idx) const {
        SPH_ASSERT(unsigned(idx) < 4);
        return data.a[idx];
    }
 
    INLINE Indices operator==(const Indices& other) const {
        return _mm_cmpeq_epi32(data.i, other.data.i);
    }
 
    INLINE Indices operator!=(const Indices& other) {
        return _mm_xor_si128(_mm_cmpeq_epi32(data.i, other.data.i), _mm_set1_epi32(-1));
    }
 
    INLINE Indices operator>(const Indices& other) const {
        return _mm_cmpgt_epi32(data.i, other.data.i);
    }
 
    INLINE Indices operator<(const Indices& other) const {
        return _mm_cmplt_epi32(data.i, other.data.i);
    }
 
    INLINE Indices operator+(const Indices& other) const {
        return _mm_add_epi32(data.i, other.data.i);
    }
 
    INLINE Indices operator-(const Indices& other) const {
        return _mm_sub_epi32(data.i, other.data.i);
    }
 
    INLINE Indices max(const Indices& other) const {
        return _mm_max_epi32(data.i, other.data.i);
    }
 
    INLINE Indices min(const Indices& other) const {
        return _mm_min_epi32(data.i, other.data.i);
    }
 
    friend std::ostream& operator<<(std::ostream& stream, const Indices& idxs) {
        for (int i = 0; i < 3; ++i) {
            stream << std::setw(20) << idxs[i];
        }
        return stream;
    }
};
 
INLINE Indices max(const Indices i1, const Indices i2) {
    return i1.max(i2);
}
 
INLINE Indices min(const Indices i1, const Indices i2) {
    return i1.min(i2);
}
 
INLINE bool all(const Indices& i) {
    return i[0] && i[1] && i[2];
}
 
INLINE bool any(const Indices& i) {
    return i[0] || i[1] || i[2];
}
 
template <>
INLINE auto floor(const Vector& v) {
    return Indices(int(std::floor(v[X])), int(std::floor(v[Y])), int(std::floor(v[Z])));
}
 
struct IndicesEqual {
    INLINE bool operator()(const Indices& i1, const Indices& i2) const {
        return all(i1 == i2);
    }
};
 
NAMESPACE_SPH_END
 
template <>
class std::hash<Sph::Indices> {
public:
    INLINE size_t operator()(const Sph::Indices& idxs) const {
        return (idxs[0] * 73856093ull) ^ (idxs[1] * 19349663ull) ^ (idxs[2] * 83492791ull);
    }
};