fc4a12fd4f
The standard `matrix` type in MSL lacked a constructor in the `threadgroup` AS. This means that it was impossible to declare a `threadgroup` variable that contains a matrix. This appears to have been an oversight that was corrected in macOS 13/Xcode 14 beta 4. This workaround continues to be required, however, for older systems. To avoid changing interfaces unnecessarily (which shouldn't be a problem regardless because the old and new types take up the same amount of storage), only do this for structs if the struct is positively identified as being used for workgroup storage. I'm entirely aware this is inconsistent with the way packed matrices are handled. One of them should be changed to match the other. Not sure which one. Fixes 23 CTS tests under `dEQP-VK.memory_model.shared`.
1354 lines
42 KiB
Plaintext
1354 lines
42 KiB
Plaintext
#pragma clang diagnostic ignored "-Wmissing-prototypes"
|
|
#pragma clang diagnostic ignored "-Wmissing-braces"
|
|
|
|
#include <metal_stdlib>
|
|
#include <simd/simd.h>
|
|
|
|
using namespace metal;
|
|
|
|
template<typename T, size_t Num>
|
|
struct spvUnsafeArray
|
|
{
|
|
T elements[Num ? Num : 1];
|
|
|
|
thread T& operator [] (size_t pos) thread
|
|
{
|
|
return elements[pos];
|
|
}
|
|
constexpr const thread T& operator [] (size_t pos) const thread
|
|
{
|
|
return elements[pos];
|
|
}
|
|
|
|
device T& operator [] (size_t pos) device
|
|
{
|
|
return elements[pos];
|
|
}
|
|
constexpr const device T& operator [] (size_t pos) const device
|
|
{
|
|
return elements[pos];
|
|
}
|
|
|
|
constexpr const constant T& operator [] (size_t pos) const constant
|
|
{
|
|
return elements[pos];
|
|
}
|
|
|
|
threadgroup T& operator [] (size_t pos) threadgroup
|
|
{
|
|
return elements[pos];
|
|
}
|
|
constexpr const threadgroup T& operator [] (size_t pos) const threadgroup
|
|
{
|
|
return elements[pos];
|
|
}
|
|
};
|
|
|
|
template<typename T, int Cols, int Rows=Cols>
|
|
struct spvStorageMatrix
|
|
{
|
|
vec<T, Rows> columns[Cols];
|
|
|
|
spvStorageMatrix() thread = default;
|
|
thread spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) thread
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const thread spvStorageMatrix& m) thread = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const constant spvStorageMatrix& m) thread = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const device spvStorageMatrix& m) thread = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) thread = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) thread = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) thread = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) thread = default;
|
|
thread spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) thread
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
thread spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) thread = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const thread
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const thread
|
|
{
|
|
return columns[idx];
|
|
}
|
|
thread vec<T, Rows>& operator[](size_t idx) thread
|
|
{
|
|
return columns[idx];
|
|
}
|
|
|
|
spvStorageMatrix() constant = default;
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) constant = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) constant = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) constant = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) constant = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) constant = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) constant = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) constant
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) constant = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const constant
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const constant
|
|
{
|
|
return columns[idx];
|
|
}
|
|
|
|
spvStorageMatrix() device = default;
|
|
device spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) device
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const thread spvStorageMatrix& m) device = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const constant spvStorageMatrix& m) device = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const device spvStorageMatrix& m) device = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) device = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) device = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) device = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) device = default;
|
|
device spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) device
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
device spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) device = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const device
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const device
|
|
{
|
|
return columns[idx];
|
|
}
|
|
device vec<T, Rows>& operator[](size_t idx) device
|
|
{
|
|
return columns[idx];
|
|
}
|
|
|
|
spvStorageMatrix() threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) threadgroup
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const thread spvStorageMatrix& m) threadgroup = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const constant spvStorageMatrix& m) threadgroup = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const device spvStorageMatrix& m) threadgroup = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) threadgroup = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) threadgroup = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) threadgroup = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) threadgroup = default;
|
|
threadgroup spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) threadgroup
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) threadgroup = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const threadgroup
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const threadgroup
|
|
{
|
|
return columns[idx];
|
|
}
|
|
threadgroup vec<T, Rows>& operator[](size_t idx) threadgroup
|
|
{
|
|
return columns[idx];
|
|
}
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix() threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) threadgroup_imageblock
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const thread spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const constant spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const device spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) threadgroup_imageblock
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
threadgroup_imageblock spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) threadgroup_imageblock = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const threadgroup_imageblock
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const threadgroup_imageblock
|
|
{
|
|
return columns[idx];
|
|
}
|
|
threadgroup_imageblock vec<T, Rows>& operator[](size_t idx) threadgroup_imageblock
|
|
{
|
|
return columns[idx];
|
|
}
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix() ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) ray_data
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const thread spvStorageMatrix& m) ray_data = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const constant spvStorageMatrix& m) ray_data = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const device spvStorageMatrix& m) ray_data = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) ray_data = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) ray_data = default;
|
|
#endif
|
|
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) ray_data = default;
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) ray_data = default;
|
|
ray_data spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) ray_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
ray_data spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) ray_data = default;
|
|
#endif
|
|
|
|
operator matrix<T, Cols, Rows>() const ray_data
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const ray_data
|
|
{
|
|
return columns[idx];
|
|
}
|
|
ray_data vec<T, Rows>& operator[](size_t idx) ray_data
|
|
{
|
|
return columns[idx];
|
|
}
|
|
#endif
|
|
|
|
#ifdef __HAVE_MESH__
|
|
spvStorageMatrix() object_data = default;
|
|
object_data spvStorageMatrix& operator=(initializer_list<vec<T, Rows>> cols) object_data
|
|
{
|
|
size_t i;
|
|
thread vec<T, Rows>* col;
|
|
for (i = 0, col = cols.begin(); i < Cols; ++i, ++col)
|
|
columns[i] = *col;
|
|
return *this;
|
|
}
|
|
|
|
spvStorageMatrix(const thread matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const thread spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const thread matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const thread spvStorageMatrix& m) object_data = default;
|
|
|
|
spvStorageMatrix(const constant matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const constant spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const constant matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const constant spvStorageMatrix& m) object_data = default;
|
|
|
|
spvStorageMatrix(const device matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const device spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const device matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const device spvStorageMatrix& m) object_data = default;
|
|
|
|
spvStorageMatrix(const threadgroup matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const threadgroup matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const threadgroup spvStorageMatrix& m) object_data = default;
|
|
|
|
#ifdef __HAVE_IMAGEBLOCKS__
|
|
spvStorageMatrix(const threadgroup_imageblock matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const threadgroup_imageblock spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const threadgroup_imageblock matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const threadgroup_imageblock spvStorageMatrix& m) object_data = default;
|
|
#endif
|
|
|
|
#ifdef __HAVE_RAYTRACING__
|
|
spvStorageMatrix(const ray_data matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const ray_data spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const ray_data matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const ray_data spvStorageMatrix& m) object_data = default;
|
|
#endif
|
|
|
|
spvStorageMatrix(const object_data matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
}
|
|
spvStorageMatrix(const object_data spvStorageMatrix& m) object_data = default;
|
|
object_data spvStorageMatrix& operator=(const object_data matrix<T, Cols, Rows>& m) object_data
|
|
{
|
|
for (size_t i = 0; i < Cols; ++i)
|
|
columns[i] = m.columns[i];
|
|
return *this;
|
|
}
|
|
object_data spvStorageMatrix& operator=(const object_data spvStorageMatrix& m) object_data = default;
|
|
|
|
operator matrix<T, Cols, Rows>() const object_data
|
|
{
|
|
matrix<T, Cols, Rows> m;
|
|
for (int i = 0; i < Cols; ++i)
|
|
m.columns[i] = columns[i];
|
|
return m;
|
|
}
|
|
|
|
vec<T, Rows> operator[](size_t idx) const object_data
|
|
{
|
|
return columns[idx];
|
|
}
|
|
object_data vec<T, Rows>& operator[](size_t idx) object_data
|
|
{
|
|
return columns[idx];
|
|
}
|
|
#endif
|
|
|
|
};
|
|
|
|
template<typename T, int Cols, int Rows>
|
|
matrix<T, Rows, Cols> transpose(spvStorageMatrix<T, Cols, Rows> m)
|
|
{
|
|
return transpose(matrix<T, Cols, Rows>(m));
|
|
}
|
|
|
|
typedef spvStorageMatrix<half, 2, 2> spvStorage_half2x2;
|
|
typedef spvStorageMatrix<half, 2, 3> spvStorage_half2x3;
|
|
typedef spvStorageMatrix<half, 2, 4> spvStorage_half2x4;
|
|
typedef spvStorageMatrix<half, 3, 2> spvStorage_half3x2;
|
|
typedef spvStorageMatrix<half, 3, 3> spvStorage_half3x3;
|
|
typedef spvStorageMatrix<half, 3, 4> spvStorage_half3x4;
|
|
typedef spvStorageMatrix<half, 4, 2> spvStorage_half4x2;
|
|
typedef spvStorageMatrix<half, 4, 3> spvStorage_half4x3;
|
|
typedef spvStorageMatrix<half, 4, 4> spvStorage_half4x4;
|
|
typedef spvStorageMatrix<float, 2, 2> spvStorage_float2x2;
|
|
typedef spvStorageMatrix<float, 2, 3> spvStorage_float2x3;
|
|
typedef spvStorageMatrix<float, 2, 4> spvStorage_float2x4;
|
|
typedef spvStorageMatrix<float, 3, 2> spvStorage_float3x2;
|
|
typedef spvStorageMatrix<float, 3, 3> spvStorage_float3x3;
|
|
typedef spvStorageMatrix<float, 3, 4> spvStorage_float3x4;
|
|
typedef spvStorageMatrix<float, 4, 2> spvStorage_float4x2;
|
|
typedef spvStorageMatrix<float, 4, 3> spvStorage_float4x3;
|
|
typedef spvStorageMatrix<float, 4, 4> spvStorage_float4x4;
|
|
|
|
struct S1
|
|
{
|
|
spvStorage_float4x3 a[2];
|
|
float b;
|
|
spvUnsafeArray<float2, 3> c;
|
|
};
|
|
|
|
struct S2
|
|
{
|
|
int4 a;
|
|
spvUnsafeArray<spvUnsafeArray<spvUnsafeArray<short, 3>, 1>, 3> b;
|
|
};
|
|
|
|
struct block
|
|
{
|
|
uint passed;
|
|
};
|
|
|
|
constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(1u);
|
|
|
|
kernel void main0(device block& _383 [[buffer(0)]])
|
|
{
|
|
threadgroup S1 s1;
|
|
threadgroup S2 s2;
|
|
s1.a[0] = spvStorage_float4x3(float4x3(float3(0.0, 2.0, -8.0), float3(6.0, 7.0, 5.0), float3(-6.0, 1.0, 9.0), float3(-4.0, -3.0, 4.0)));
|
|
s1.a[1] = spvStorage_float4x3(float4x3(float3(4.0, 9.0, -9.0), float3(-8.0, -9.0, 8.0), float3(0.0, 4.0, -4.0), float3(7.0, 2.0, -1.0)));
|
|
s1.b = 7.0;
|
|
s1.c[0] = float2(-5.0, -4.0);
|
|
s1.c[1] = float2(3.0, -5.0);
|
|
s1.c[2] = float2(-3.0, -1.0);
|
|
s2.a = int4(1, 0, -3, 1);
|
|
s2.b[0][0][0] = short(true);
|
|
s2.b[0][0][1] = short(false);
|
|
s2.b[0][0][2] = short(false);
|
|
s2.b[1][0][0] = short(true);
|
|
s2.b[1][0][1] = short(false);
|
|
s2.b[1][0][2] = short(true);
|
|
s2.b[2][0][0] = short(false);
|
|
s2.b[2][0][1] = short(true);
|
|
s2.b[2][0][2] = short(true);
|
|
threadgroup_barrier(mem_flags::mem_threadgroup);
|
|
threadgroup_barrier(mem_flags::mem_device | mem_flags::mem_threadgroup | mem_flags::mem_texture);
|
|
bool _464 = abs(-float4x3(s1.a[0])[0].x) < 0.0500000007450580596923828125;
|
|
bool _449;
|
|
if (_464)
|
|
{
|
|
_449 = abs(2.0 - float4x3(s1.a[0])[0].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_449 = _464;
|
|
}
|
|
bool _457;
|
|
if (_449)
|
|
{
|
|
_457 = abs((-8.0) - float4x3(s1.a[0])[0].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_457 = _449;
|
|
}
|
|
bool _412;
|
|
if (_457)
|
|
{
|
|
bool _514 = abs(6.0 - float4x3(s1.a[0])[1].x) < 0.0500000007450580596923828125;
|
|
bool _499;
|
|
if (_514)
|
|
{
|
|
_499 = abs(7.0 - float4x3(s1.a[0])[1].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_499 = _514;
|
|
}
|
|
bool _507;
|
|
if (_499)
|
|
{
|
|
_507 = abs(5.0 - float4x3(s1.a[0])[1].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_507 = _499;
|
|
}
|
|
_412 = _507;
|
|
}
|
|
else
|
|
{
|
|
_412 = _457;
|
|
}
|
|
bool _420;
|
|
if (_412)
|
|
{
|
|
bool _564 = abs((-6.0) - float4x3(s1.a[0])[2].x) < 0.0500000007450580596923828125;
|
|
bool _549;
|
|
if (_564)
|
|
{
|
|
_549 = abs(1.0 - float4x3(s1.a[0])[2].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_549 = _564;
|
|
}
|
|
bool _557;
|
|
if (_549)
|
|
{
|
|
_557 = abs(9.0 - float4x3(s1.a[0])[2].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_557 = _549;
|
|
}
|
|
_420 = _557;
|
|
}
|
|
else
|
|
{
|
|
_420 = _412;
|
|
}
|
|
bool _428;
|
|
if (_420)
|
|
{
|
|
bool _614 = abs((-4.0) - float4x3(s1.a[0])[3].x) < 0.0500000007450580596923828125;
|
|
bool _599;
|
|
if (_614)
|
|
{
|
|
_599 = abs((-3.0) - float4x3(s1.a[0])[3].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_599 = _614;
|
|
}
|
|
bool _607;
|
|
if (_599)
|
|
{
|
|
_607 = abs(4.0 - float4x3(s1.a[0])[3].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_607 = _599;
|
|
}
|
|
_428 = _607;
|
|
}
|
|
else
|
|
{
|
|
_428 = _420;
|
|
}
|
|
bool _251;
|
|
if (_428)
|
|
{
|
|
bool _703 = abs(4.0 - float4x3(s1.a[1])[0].x) < 0.0500000007450580596923828125;
|
|
bool _688;
|
|
if (_703)
|
|
{
|
|
_688 = abs(9.0 - float4x3(s1.a[1])[0].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_688 = _703;
|
|
}
|
|
bool _696;
|
|
if (_688)
|
|
{
|
|
_696 = abs((-9.0) - float4x3(s1.a[1])[0].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_696 = _688;
|
|
}
|
|
bool _651;
|
|
if (_696)
|
|
{
|
|
bool _753 = abs((-8.0) - float4x3(s1.a[1])[1].x) < 0.0500000007450580596923828125;
|
|
bool _738;
|
|
if (_753)
|
|
{
|
|
_738 = abs((-9.0) - float4x3(s1.a[1])[1].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_738 = _753;
|
|
}
|
|
bool _746;
|
|
if (_738)
|
|
{
|
|
_746 = abs(8.0 - float4x3(s1.a[1])[1].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_746 = _738;
|
|
}
|
|
_651 = _746;
|
|
}
|
|
else
|
|
{
|
|
_651 = _696;
|
|
}
|
|
bool _659;
|
|
if (_651)
|
|
{
|
|
bool _803 = abs(-float4x3(s1.a[1])[2].x) < 0.0500000007450580596923828125;
|
|
bool _788;
|
|
if (_803)
|
|
{
|
|
_788 = abs(4.0 - float4x3(s1.a[1])[2].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_788 = _803;
|
|
}
|
|
bool _796;
|
|
if (_788)
|
|
{
|
|
_796 = abs((-4.0) - float4x3(s1.a[1])[2].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_796 = _788;
|
|
}
|
|
_659 = _796;
|
|
}
|
|
else
|
|
{
|
|
_659 = _651;
|
|
}
|
|
bool _667;
|
|
if (_659)
|
|
{
|
|
bool _853 = abs(7.0 - float4x3(s1.a[1])[3].x) < 0.0500000007450580596923828125;
|
|
bool _838;
|
|
if (_853)
|
|
{
|
|
_838 = abs(2.0 - float4x3(s1.a[1])[3].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_838 = _853;
|
|
}
|
|
bool _846;
|
|
if (_838)
|
|
{
|
|
_846 = abs((-1.0) - float4x3(s1.a[1])[3].z) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_846 = _838;
|
|
}
|
|
_667 = _846;
|
|
}
|
|
else
|
|
{
|
|
_667 = _659;
|
|
}
|
|
_251 = _667;
|
|
}
|
|
else
|
|
{
|
|
_251 = _428;
|
|
}
|
|
bool _260;
|
|
if (_251)
|
|
{
|
|
_260 = abs(7.0 - s1.b) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_260 = _251;
|
|
}
|
|
bool _269;
|
|
if (_260)
|
|
{
|
|
bool _900 = abs((-5.0) - s1.c[0].x) < 0.0500000007450580596923828125;
|
|
bool _893;
|
|
if (_900)
|
|
{
|
|
_893 = abs((-4.0) - s1.c[0].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_893 = _900;
|
|
}
|
|
_269 = _893;
|
|
}
|
|
else
|
|
{
|
|
_269 = _260;
|
|
}
|
|
bool _278;
|
|
if (_269)
|
|
{
|
|
bool _933 = abs(3.0 - s1.c[1].x) < 0.0500000007450580596923828125;
|
|
bool _926;
|
|
if (_933)
|
|
{
|
|
_926 = abs((-5.0) - s1.c[1].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_926 = _933;
|
|
}
|
|
_278 = _926;
|
|
}
|
|
else
|
|
{
|
|
_278 = _269;
|
|
}
|
|
bool _287;
|
|
if (_278)
|
|
{
|
|
bool _966 = abs((-3.0) - s1.c[2].x) < 0.0500000007450580596923828125;
|
|
bool _959;
|
|
if (_966)
|
|
{
|
|
_959 = abs((-1.0) - s1.c[2].y) < 0.0500000007450580596923828125;
|
|
}
|
|
else
|
|
{
|
|
_959 = _966;
|
|
}
|
|
_287 = _959;
|
|
}
|
|
else
|
|
{
|
|
_287 = _278;
|
|
}
|
|
bool _296;
|
|
if (_287)
|
|
{
|
|
_296 = all(int4(1, 0, -3, 1) == s2.a);
|
|
}
|
|
else
|
|
{
|
|
_296 = _287;
|
|
}
|
|
bool _305;
|
|
if (_296)
|
|
{
|
|
_305 = true == bool(s2.b[0][0][0]);
|
|
}
|
|
else
|
|
{
|
|
_305 = _296;
|
|
}
|
|
bool _314;
|
|
if (_305)
|
|
{
|
|
_314 = false == bool(s2.b[0][0][1]);
|
|
}
|
|
else
|
|
{
|
|
_314 = _305;
|
|
}
|
|
bool _323;
|
|
if (_314)
|
|
{
|
|
_323 = false == bool(s2.b[0][0][2]);
|
|
}
|
|
else
|
|
{
|
|
_323 = _314;
|
|
}
|
|
bool _332;
|
|
if (_323)
|
|
{
|
|
_332 = true == bool(s2.b[1][0][0]);
|
|
}
|
|
else
|
|
{
|
|
_332 = _323;
|
|
}
|
|
bool _341;
|
|
if (_332)
|
|
{
|
|
_341 = false == bool(s2.b[1][0][1]);
|
|
}
|
|
else
|
|
{
|
|
_341 = _332;
|
|
}
|
|
bool _350;
|
|
if (_341)
|
|
{
|
|
_350 = true == bool(s2.b[1][0][2]);
|
|
}
|
|
else
|
|
{
|
|
_350 = _341;
|
|
}
|
|
bool _359;
|
|
if (_350)
|
|
{
|
|
_359 = false == bool(s2.b[2][0][0]);
|
|
}
|
|
else
|
|
{
|
|
_359 = _350;
|
|
}
|
|
bool _368;
|
|
if (_359)
|
|
{
|
|
_368 = true == bool(s2.b[2][0][1]);
|
|
}
|
|
else
|
|
{
|
|
_368 = _359;
|
|
}
|
|
bool _377;
|
|
if (_368)
|
|
{
|
|
_377 = true == bool(s2.b[2][0][2]);
|
|
}
|
|
else
|
|
{
|
|
_377 = _368;
|
|
}
|
|
if (_377)
|
|
{
|
|
_383.passed++;
|
|
}
|
|
}
|
|
|