public static quaternion AsQuaternionRotation(uint3 u)
{
float3 rnd = AsFloat3(u, 0f, new float3(2.0f * math.PI, 2.0f * math.PI, 1.0f));
float u1 = rnd.z;
float2 theta_rho = rnd.xy;
float i = math.sqrt(1.0f - u1);
float j = math.sqrt(u1);
float2 sin_theta_rho;
float2 cos_theta_rho;
math.sincos(theta_rho, out sin_theta_rho, out cos_theta_rho);
quaternion q = new quaternion(i * sin_theta_rho.x, i * cos_theta_rho.x, j * sin_theta_rho.y, j * cos_theta_rho.y);
return(new quaternion(math.select(q.value, -q.value, q.value.w < 0.0f)));
}
void Start()
{
tex = new RenderTexture(source.width, source.height, 0);
tex.enableRandomWrite = true;
tex.Create();
int kernel = compute.FindKernel("CSMain");
uint3 groups = compute.GetThreadGroupSize(kernel);
Debug.Assert(source.width % groups.x == 0);
Debug.Assert(source.height % groups.y == 0);
compute.SetTexture(kernel, "Source", source, 0);
compute.SetTexture(kernel, "Result", tex);
compute.Dispatch(kernel, tex.width / (int)groups.x, tex.height / (int)groups.y, 1);
}
public CoeffTexture(uint3 size)
{
RenderTextureDescriptor desc = new RenderTextureDescriptor
{
autoGenerateMips = false,
bindMS = false,
colorFormat = RenderTextureFormat.ARGBHalf,
depthBufferBits = 0,
dimension = TextureDimension.Tex3D,
enableRandomWrite = true,
width = (int)size.x,
height = (int)size.y,
volumeDepth = (int)size.z,
memoryless = RenderTextureMemoryless.None,
msaaSamples = 1,
shadowSamplingMode = ShadowSamplingMode.None,
sRGB = false,
useDynamicScale = false,
useMipMap = false,
vrUsage = VRTextureUsage.None
};
coeff0 = new RenderTexture(desc);
coeff1 = new RenderTexture(desc);
coeff2 = new RenderTexture(desc);
coeff3 = new RenderTexture(desc);
coeff4 = new RenderTexture(desc);
coeff5 = new RenderTexture(desc);
coeff6 = new RenderTexture(desc);
coeff0.filterMode = FilterMode.Bilinear;
coeff1.filterMode = FilterMode.Bilinear;
coeff2.filterMode = FilterMode.Bilinear;
coeff3.filterMode = FilterMode.Bilinear;
coeff4.filterMode = FilterMode.Bilinear;
coeff5.filterMode = FilterMode.Bilinear;
coeff6.filterMode = FilterMode.Bilinear;
coeff0.Create();
coeff1.Create();
coeff2.Create();
coeff3.Create();
coeff4.Create();
coeff5.Create();
coeff6.Create();
}
public void InvariantNorm()
{
{
var v0 = new uint3(5u, 3u, 2u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(4u, 4u, 0u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(2u, 6u, 0u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(9u, 5u, 7u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(3u, 2u, 6u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(7u, 9u, 3u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(2u, 5u, 6u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(6u, 3u, 7u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(7u, 6u, 0u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
{
var v0 = new uint3(4u, 5u, 3u);
Assert.LessOrEqual(v0.NormMax, v0.Norm);
}
}
public void InvariantId()
{
{
var v0 = new uint3(4u, 1u, 2u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(5u, 3u, 1u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(4u, 8u, 5u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(4u, 4u, 9u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(1u, 7u, 8u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(1u, 1u, 3u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(5u, 4u, 6u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(8u, 2u, 2u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(5u, 5u, 0u);
Assert.AreEqual(v0, +v0);
}
{
var v0 = new uint3(8u, 8u, 5u);
Assert.AreEqual(v0, +v0);
}
}
public void InvariantTriple()
{
{
var v0 = new uint3(9u, 1u, 3u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(7u, 7u, 8u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(0u, 1u, 2u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(2u, 8u, 6u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(5u, 3u, 2u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(8u, 5u, 8u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(5u, 1u, 9u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(9u, 7u, 4u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(1u, 7u, 4u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
{
var v0 = new uint3(2u, 3u, 5u);
Assert.AreEqual(v0 + v0 + v0, 3 * v0);
}
}
public static int3 intpow(int3 x, uint3 n)
{
if (Sse2.IsSse2Supported)
{
v128 ZERO = default(v128);
v128 ONE = new v128(1);
v128 _x = *(v128 *)&x;
v128 _n = *(v128 *)&n;
v128 doneMask = ZERO;
v128 result = ZERO;
v128 p = _x;
v128 y = ONE;
Loop:
v128 y_times_p = Operator.mul_int(y, p);
y = Mask.BlendV(y, y_times_p, Sse2.cmpeq_epi32(ONE, Sse2.and_si128(ONE, _n)));
_n = Sse2.srli_epi32(_n, 1);
v128 n_is_zero = Sse2.cmpeq_epi32(ZERO, _n);
result = Mask.BlendV(result, y, Sse2.andnot_si128(doneMask, n_is_zero));
doneMask = n_is_zero;
if (bitmask32(3 * sizeof(int)) != (bitmask32(3 * sizeof(int)) & Sse2.movemask_epi8(doneMask)))
{
p = Operator.mul_int(p, p);
goto Loop;
}
else
{
return(*(int3 *)&result);
}
}
else
{
return(new int3(intpow(x.x, n.x), intpow(x.y, n.y), intpow(x.z, n.z)));
}
}
public uint8(uint3 x012, uint2 x34, uint3 x567)
{
if (Sse2.IsSse2Supported)
{
v128 lo;
v128 mid = Sse2.bslli_si128(*(v128 *)&x34, 3 * sizeof(uint));
if (Sse4_1.IsSse41Supported)
{
lo = Sse4_1.blend_epi16(*(v128 *)&x012, mid, 0b1100_0000);
}
else
{
lo = Mask.BlendEpi16_SSE2(*(v128 *)&x012, mid, 0b1100_0000);
}
mid = Sse2.bsrli_si128(*(v128 *)&x34, sizeof(uint));
v128 hi = Sse2.bslli_si128(*(v128 *)&x567, sizeof(uint));
if (Sse4_1.IsSse41Supported)
{
hi = Sse4_1.blend_epi16(mid, hi, 0b1111_1100);
}
else
{
hi = Mask.BlendEpi16_SSE2(mid, hi, 0b1111_1100);
}
this = new uint8(*(uint4 *)&lo, *(uint4 *)&hi);
}
else
{
this = new uint8
{
_v4_0 = new uint4(x012, x34.x),
_v4_4 = new uint4(x34.y, x567)
};
}
}
public void Indexer()
{
var v = new uint3(5u, 7u, 6u);
Assert.AreEqual(5u, v[0]);
Assert.AreEqual(7u, v[1]);
Assert.AreEqual(6u, v[2]);
Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-2147483648]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[-2147483648] = 0u; });
Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[-1]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[-1] = 0u; });
Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[3]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[3] = 0u; });
Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[2147483647]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[2147483647] = 0u; });
Assert.Throws <ArgumentOutOfRangeException>(() => { var s = v[5]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { v[5] = 0u; });
v[0] = 0u;
Assert.AreEqual(0u, v[0]);
v[0] = 1u;
Assert.AreEqual(1u, v[0]);
v[1] = 2u;
Assert.AreEqual(2u, v[1]);
v[1] = 3u;
Assert.AreEqual(3u, v[1]);
v[1] = 4u;
Assert.AreEqual(4u, v[1]);
v[2] = 5u;
Assert.AreEqual(5u, v[2]);
v[0] = 6u;
Assert.AreEqual(6u, v[0]);
v[1] = 7u;
Assert.AreEqual(7u, v[1]);
v[1] = 8u;
Assert.AreEqual(8u, v[1]);
v[2] = 9u;
Assert.AreEqual(9u, v[2]);
}
public void uint3_operator_postfix_inc()
{
uint3 a0 = uint3(241865086, 2145821641, 1596166022);
uint3 r0 = uint3(241865086, 2145821641, 1596166022);
TestUtils.AreEqual(a0++, r0);
uint3 a1 = uint3(803592338, 1656767229, 903047443);
uint3 r1 = uint3(803592338, 1656767229, 903047443);
TestUtils.AreEqual(a1++, r1);
uint3 a2 = uint3(1213663244, 1384002775, 389844650);
uint3 r2 = uint3(1213663244, 1384002775, 389844650);
TestUtils.AreEqual(a2++, r2);
uint3 a3 = uint3(1159795446, 1227160199, 947635082);
uint3 r3 = uint3(1159795446, 1227160199, 947635082);
TestUtils.AreEqual(a3++, r3);
}
public void uint3_operator_prefix_dec()
{
uint3 a0 = uint3(1331961415, 1612382200, 1401591249);
uint3 r0 = uint3(1331961414, 1612382199, 1401591248);
TestUtils.AreEqual(--a0, r0);
uint3 a1 = uint3(2042075388, 1895858159, 1467742422);
uint3 r1 = uint3(2042075387, 1895858158, 1467742421);
TestUtils.AreEqual(--a1, r1);
uint3 a2 = uint3(578341664, 2059077641, 1169239112);
uint3 r2 = uint3(578341663, 2059077640, 1169239111);
TestUtils.AreEqual(--a2, r2);
uint3 a3 = uint3(1862369220, 1027543764, 1595492535);
uint3 r3 = uint3(1862369219, 1027543763, 1595492534);
TestUtils.AreEqual(--a3, r3);
}
public void uint3_operator_neg()
{
uint3 a0 = uint3(1385088677, 94114564, 1350664872);
uint3 r0 = uint3(2909878619, 4200852732, 2944302424);
TestUtils.AreEqual(-a0, r0);
uint3 a1 = uint3(1458616659, 218122493, 958484951);
uint3 r1 = uint3(2836350637, 4076844803, 3336482345);
TestUtils.AreEqual(-a1, r1);
uint3 a2 = uint3(270553961, 270503114, 1928771252);
uint3 r2 = uint3(4024413335, 4024464182, 2366196044);
TestUtils.AreEqual(-a2, r2);
uint3 a3 = uint3(1427605822, 1434247484, 485368391);
uint3 r3 = uint3(2867361474, 2860719812, 3809598905);
TestUtils.AreEqual(-a3, r3);
}
public void uint3_operator_plus()
{
uint3 a0 = uint3(195392567, 222719748, 1002351013);
uint3 r0 = uint3(195392567, 222719748, 1002351013);
TestUtils.AreEqual(+a0, r0);
uint3 a1 = uint3(1570765263, 1515950277, 1689763402);
uint3 r1 = uint3(1570765263, 1515950277, 1689763402);
TestUtils.AreEqual(+a1, r1);
uint3 a2 = uint3(291471785, 1084131995, 195779102);
uint3 r2 = uint3(291471785, 1084131995, 195779102);
TestUtils.AreEqual(+a2, r2);
uint3 a3 = uint3(2131702223, 1995564647, 69731564);
uint3 r3 = uint3(2131702223, 1995564647, 69731564);
TestUtils.AreEqual(+a3, r3);
}
public void uint3_operator_prefix_inc()
{
uint3 a0 = uint3(780471723, 954741756, 272723451);
uint3 r0 = uint3(780471724, 954741757, 272723452);
TestUtils.AreEqual(++a0, r0);
uint3 a1 = uint3(2142862245, 1514814550, 250124151);
uint3 r1 = uint3(2142862246, 1514814551, 250124152);
TestUtils.AreEqual(++a1, r1);
uint3 a2 = uint3(444189162, 1915989169, 1348278302);
uint3 r2 = uint3(444189163, 1915989170, 1348278303);
TestUtils.AreEqual(++a2, r2);
uint3 a3 = uint3(129540735, 1170613526, 986715680);
uint3 r3 = uint3(129540736, 1170613527, 986715681);
TestUtils.AreEqual(++a3, r3);
}
public static bool3 isdivisible(uint3 dividend, uint divisor)
{
Assert.AreNotEqual(0u, divisor);
if (Constant.IsConstantExpression(divisor))
{
if (math.ispow2(divisor))
{
return((dividend & (divisor - 1)) == 0);
}
else
{
ulong3 compile = (new ulong3(ulong.MaxValue) / divisor) + 1;
return(dividend * compile <= compile - 1);
}
}
else
{
return(dividend % divisor == 0);
}
}
public void uint3_operator_postfix_dec()
{
uint3 a0 = uint3(1870005937, 1708534798, 704493460);
uint3 r0 = uint3(1870005937, 1708534798, 704493460);
TestUtils.AreEqual(a0--, r0);
uint3 a1 = uint3(462940703, 228744869, 940247280);
uint3 r1 = uint3(462940703, 228744869, 940247280);
TestUtils.AreEqual(a1--, r1);
uint3 a2 = uint3(1818778351, 862428933, 1401191870);
uint3 r2 = uint3(1818778351, 862428933, 1401191870);
TestUtils.AreEqual(a2--, r2);
uint3 a3 = uint3(2080259851, 140452688, 1928164223);
uint3 r3 = uint3(2080259851, 140452688, 1928164223);
TestUtils.AreEqual(a3--, r3);
}
public void uint3_operator_bitwise_not()
{
uint3 a0 = uint3(111796841, 603562399, 745091931);
uint3 r0 = uint3(4183170454, 3691404896, 3549875364);
TestUtils.AreEqual(~a0, r0);
uint3 a1 = uint3(853183268, 381888399, 1891338755);
uint3 r1 = uint3(3441784027, 3913078896, 2403628540);
TestUtils.AreEqual(~a1, r1);
uint3 a2 = uint3(1506860135, 787710759, 875964607);
uint3 r2 = uint3(2788107160, 3507256536, 3419002688);
TestUtils.AreEqual(~a2, r2);
uint3 a3 = uint3(96456785, 203444882, 1172294211);
uint3 r3 = uint3(4198510510, 4091522413, 3122673084);
TestUtils.AreEqual(~a3, r3);
}
public static uint3 bitmask32(uint3 numBits, uint3 index = default(uint3))
{
Assert.IsBetween(index.x, 0u, 32u);
Assert.IsBetween(index.y, 0u, 32u);
Assert.IsBetween(index.z, 0u, 32u);
Assert.IsBetween(numBits.x, 0u, 32u - index.x);
Assert.IsBetween(numBits.y, 0u, 32u - index.y);
Assert.IsBetween(numBits.z, 0u, 32u - index.z);
// mask
index = shl(uint.MaxValue, index);
if (Sse2.IsSse2Supported)
{
v128 isMaxBitsMask = Sse2.cmpeq_epi32(*(v128 *)&numBits, new v128(32));
return((*(uint3 *)&isMaxBitsMask) | andnot(index, shl(index, numBits)));
}
else
{
return((uint3)(-toint32(numBits == 32)) | andnot(index, shl(index, numBits)));
}
}
public static int indexof(uint3 v, uint x)
{
if (Sse2.IsSse2Supported)
{
return(math.tzcnt(bitmask32(3 * sizeof(uint)) & Sse.movemask_ps(Sse2.cmpeq_epi32(*(v128 *)&v, new v128(x)))));
}
else
{
for (int i = 0; i < 3; i++)
{
if (v[i] == x)
{
return(i);
}
else
{
continue;
}
}
return(32);
}
}
public static void AreEqual(uint3 a, uint3 b)
{
AreEqual(a.x, b.x);
AreEqual(a.y, b.y);
AreEqual(a.z, b.z);
}
public static void AreEqual(uint3 expected, uint3 actual)
{
AreEqual(expected.x, actual.x);
AreEqual(expected.y, actual.y);
AreEqual(expected.z, actual.z);
}
public static extern CUResult cuMemcpyDtoH_v2(ref uint3 dstHost, CUdeviceptr srcDevice, SizeT ByteCount);
public uint3x2(float v)
{
this.c0 = (uint3)v;
this.c1 = (uint3)v;
}
public uint3x2(int3x2 v)
{
this.c0 = (uint3)v.c0;
this.c1 = (uint3)v.c1;
}
public uint3x2(int v)
{
this.c0 = (uint3)v;
this.c1 = (uint3)v;
}
public static uint3x2 uint3x2(uint3 c0, uint3 c1)
{
return(new uint3x2(c0, c1));
}
public uint3x2(bool3x2 v)
{
this.c0 = math.select(new uint3(0u), new uint3(1u), v.c0);
this.c1 = math.select(new uint3(0u), new uint3(1u), v.c1);
}
public uint3x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
public uint3x2(uint3 c0, uint3 c1)
{
this.c0 = c0;
this.c1 = c1;
}
public uint3x2(double v)
{
this.c0 = (uint3)v;
this.c1 = (uint3)v;
}
private static int ConvertToInt(uint3 result)
{
return((int)(result.x + result.y * 10 + result.z * 100));
}
