AblativeAbsolute/rimworld-animation-studio
1
0
Fork 0
mirror of https://gitgud.io/AbstractConcept/rimworld-animation-studio.git synced 2024-08-15 00:43:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Initial commit

Browse source
This commit is contained in:
AbstractConcept 2022-09-13 00:36:34 -05:00
commit 3c7cc0c973
8391 changed files with 704313 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise.meta Normal file
View file

@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: abc6c021d7cd541b3956a3969c8c3ccb
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

20
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/LICENSE Normal file
View file

@ -0,0 +1,20 @@
Copyright (C) 2011 by Ashima Arts (Simplex noise)
Copyright (C) 2011-2016 by Stefan Gustavson (Classic noise and others)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

7
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/LICENSE.meta Normal file
View file

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: e8895079ca68e498482a3075d7e34508
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

16
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README Normal file
View file

@ -0,0 +1,16 @@
These files contain noise functions that are compatible with all
current versions of GLSL (1.20 and up), and all you need to use them
is provided in the source file. There is no external data, and no
setup procedure. Just cut and paste and call the function.
GLSL has a very rudimentary linker, so some helper functions are
included in several of the files with the same name. If you want to
use more than one of these functions in the same shader, you may run
into problems with redefinition of the functions mod289() and permute().
If that happens, just delete any superfluous definitions.
-----
Source: https://github.com/ashima/webgl-noise
Changes:
- 10 April 2018, Unity Technologies, Ported to HPC#

7
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README.meta Normal file
View file

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: 16687ba1ea1804a9fb7cb7c2410eab23
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

58
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2D.cs Normal file
View file

@ -0,0 +1,58 @@
// Cellular noise ("Worley noise") in 2D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.
// https://github.com/stegu/webgl-noise
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Cellular noise, returning F1 and F2 in a float2.
// Standard 3x3 search window for good F1 and F2 values
public static float2 cellular(float2 P)
{
const float K = 0.142857142857f; // 1/7
const float Ko = 0.428571428571f; // 3/7
const float jitter = 1.0f; // Less gives more regular pattern
float2 Pi = mod289(floor(P));
float2 Pf = frac(P);
float3 oi = float3(-1.0f, 0.0f, 1.0f);
float3 of = float3(-0.5f, 0.5f, 1.5f);
float3 px = permute(Pi.x + oi);
float3 p = permute(px.x + Pi.y + oi); // p11, p12, p13
float3 ox = frac(p * K) - Ko;
float3 oy = mod7(floor(p * K)) * K - Ko;
float3 dx = Pf.x + 0.5f + jitter * ox;
float3 dy = Pf.y - of + jitter * oy;
float3 d1 = dx * dx + dy * dy; // d11, d12 and d13, squared
p = permute(px.y + Pi.y + oi); // p21, p22, p23
ox = frac(p * K) - Ko;
oy = mod7(floor(p * K)) * K - Ko;
dx = Pf.x - 0.5f + jitter * ox;
dy = Pf.y - of + jitter * oy;
float3 d2 = dx * dx + dy * dy; // d21, d22 and d23, squared
p = permute(px.z + Pi.y + oi); // p31, p32, p33
ox = frac(p * K) - Ko;
oy = mod7(floor(p * K)) * K - Ko;
dx = Pf.x - 1.5f + jitter * ox;
dy = Pf.y - of + jitter * oy;
float3 d3 = dx * dx + dy * dy; // d31, d32 and d33, squared
// Sort out the two smallest distances (F1, F2)
float3 d1a = min(d1, d2);
d2 = max(d1, d2); // Swap to keep candidates for F2
d2 = min(d2, d3); // neither F1 nor F2 are now in d3
d1 = min(d1a, d2); // F1 is now in d1
d2 = max(d1a, d2); // Swap to keep candidates for F2
d1.xy = (d1.x < d1.y) ? d1.xy : d1.yx; // Swap if smaller
d1.xz = (d1.x < d1.z) ? d1.xz : d1.zx; // F1 is in d1.x
d1.yz = min(d1.yz, d2.yz); // F2 is now not in d2.yz
d1.y = min(d1.y, d1.z); // nor in d1.z
d1.y = min(d1.y, d2.x); // F2 is in d1.y, we're done.
return sqrt(d1.xy);
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7bc458fcf5f30484da36c2a11ca0c50a
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

46
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2x2.cs Normal file
View file

@ -0,0 +1,46 @@
// Cellular noise ("Worley noise") in 2D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.
// https://github.com/stegu/webgl-noise
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Cellular noise, returning F1 and F2 in a float2.
// Speeded up by umath.sing 2x2 search window instead of 3x3,
// at the expense of some strong pattern artifacts.
// F2 is often wrong and has sharp discontinuities.
// If you need a smooth F2, use the slower 3x3 version.
// F1 is sometimes wrong, too, but OK for most purposes.
public static float2 cellular2x2(float2 P)
{
const float K = 0.142857142857f; // 1/7
const float K2 = 0.0714285714285f; // K/2
const float jitter = 0.8f; // jitter 1.0 makes F1 wrong more often
float2 Pi = mod289(floor(P));
float2 Pf = frac(P);
float4 Pfx = Pf.x + float4(-0.5f, -1.5f, -0.5f, -1.5f);
float4 Pfy = Pf.y + float4(-0.5f, -0.5f, -1.5f, -1.5f);
float4 p = permute(Pi.x + float4(0.0f, 1.0f, 0.0f, 1.0f));
p = permute(p + Pi.y + float4(0.0f, 0.0f, 1.0f, 1.0f));
float4 ox = mod7(p) * K + K2;
float4 oy = mod7(floor(p * K)) * K + K2;
float4 dx = Pfx + jitter * ox;
float4 dy = Pfy + jitter * oy;
float4 d = dx * dx + dy * dy; // d11, d12, d21 and d22, squared
// Sort out the two smallest distances
// Do it right and find both F1 and F2
d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap if smaller
d.xz = (d.x < d.z) ? d.xz : d.zx;
d.xw = (d.x < d.w) ? d.xw : d.wx;
d.y = min(d.y, d.z);
d.y = min(d.y, d.w);
return sqrt(d.xy);
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2x2.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: fb26f7539fea841ac9538c01e2c20bc4
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

65
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2x2x2.cs Normal file
View file

@ -0,0 +1,65 @@
// Cellular noise ("Worley noise") in 3D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.
// https://github.com/stegu/webgl-noise
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Cellular noise, returning F1 and F2 in a float2.
// Speeded up by umath.sing 2x2x2 search window instead of 3x3x3,
// at the expense of some pattern artifacts.
// F2 is often wrong and has sharp discontinuities.
// If you need a good F2, use the slower 3x3x3 version.
public static float2 cellular2x2x2(float3 P)
{
const float K = 0.142857142857f; // 1/7
const float Ko = 0.428571428571f; // 1/2-K/2
const float K2 = 0.020408163265306f; // 1/(7*7)
const float Kz = 0.166666666667f; // 1/6
const float Kzo = 0.416666666667f; // 1/2-1/6*2
const float jitter = 0.8f; // smaller jitter gives less errors in F2
float3 Pi = mod289(floor(P));
float3 Pf = frac(P);
float4 Pfx = Pf.x + float4(0.0f, -1.0f, 0.0f, -1.0f);
float4 Pfy = Pf.y + float4(0.0f, 0.0f, -1.0f, -1.0f);
float4 p = permute(Pi.x + float4(0.0f, 1.0f, 0.0f, 1.0f));
p = permute(p + Pi.y + float4(0.0f, 0.0f, 1.0f, 1.0f));
float4 p1 = permute(p + Pi.z); // z+0
float4 p2 = permute(p + Pi.z + float4(1.0f,1.0f,1.0f,1.0f)); // z+1
float4 ox1 = frac(p1 * K) - Ko;
float4 oy1 = mod7(floor(p1 * K)) * K - Ko;
float4 oz1 = floor(p1 * K2) * Kz - Kzo; // p1 < 289 guaranteed
float4 ox2 = frac(p2 * K) - Ko;
float4 oy2 = mod7(floor(p2 * K)) * K - Ko;
float4 oz2 = floor(p2 * K2) * Kz - Kzo;
float4 dx1 = Pfx + jitter * ox1;
float4 dy1 = Pfy + jitter * oy1;
float4 dz1 = Pf.z + jitter * oz1;
float4 dx2 = Pfx + jitter * ox2;
float4 dy2 = Pfy + jitter * oy2;
float4 dz2 = Pf.z - 1.0f + jitter * oz2;
float4 d1 = dx1 * dx1 + dy1 * dy1 + dz1 * dz1; // z+0
float4 d2 = dx2 * dx2 + dy2 * dy2 + dz2 * dz2; // z+1
// Sort out the two smallest distances (F1, F2)
// Do it right and sort out both F1 and F2
float4 d = min(d1,d2); // F1 is now in d
d2 = max(d1,d2); // Make sure we keep all candidates for F2
d.xy = (d.x < d.y) ? d.xy : d.yx; // Swap smallest to d.x
d.xz = (d.x < d.z) ? d.xz : d.zx;
d.xw = (d.x < d.w) ? d.xw : d.wx; // F1 is now in d.x
d.yzw = min(d.yzw, d2.yzw); // F2 now not in d2.yzw
d.y = min(d.y, d.z); // nor in d.z
d.y = min(d.y, d.w); // nor in d.w
d.y = min(d.y, d2.x); // F2 is now in d.y
return sqrt(d.xy); // F1 and F2
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular2x2x2.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4d0dbb238670f4580aa39c5272c2911c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

169
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular3D.cs Normal file
View file

@ -0,0 +1,169 @@
// Cellular noise ("Worley noise") in 3D in GLSL.
// Copyright (c) Stefan Gustavson 2011-04-19. All rights reserved.
// This code is released under the conditions of the MIT license.
// See LICENSE file for details.
// https://github.com/stegu/webgl-noise
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Cellular noise, returning F1 and F2 in a float2.
// 3x3x3 search region for good F2 everywhere, but a lot
// slower than the 2x2x2 version.
// The code below is a bit scary even to its author,
// but it has at least half decent performance on a
// math.modern GPU. In any case, it beats any software
// implementation of Worley noise hands down.
public static float2 cellular(float3 P)
{
const float K = 0.142857142857f; // 1/7
const float Ko = 0.428571428571f; // 1/2-K/2
const float K2 = 0.020408163265306f; // 1/(7*7)
const float Kz = 0.166666666667f; // 1/6
const float Kzo = 0.416666666667f; // 1/2-1/6*2
const float jitter = 1.0f; // smaller jitter gives more regular pattern
float3 Pi = mod289(floor(P));
float3 Pf = frac(P) - 0.5f;
float3 Pfx = Pf.x + float3(1.0f, 0.0f, -1.0f);
float3 Pfy = Pf.y + float3(1.0f, 0.0f, -1.0f);
float3 Pfz = Pf.z + float3(1.0f, 0.0f, -1.0f);
float3 p = permute(Pi.x + float3(-1.0f, 0.0f, 1.0f));
float3 p1 = permute(p + Pi.y - 1.0f);
float3 p2 = permute(p + Pi.y);
float3 p3 = permute(p + Pi.y + 1.0f);
float3 p11 = permute(p1 + Pi.z - 1.0f);
float3 p12 = permute(p1 + Pi.z);
float3 p13 = permute(p1 + Pi.z + 1.0f);
float3 p21 = permute(p2 + Pi.z - 1.0f);
float3 p22 = permute(p2 + Pi.z);
float3 p23 = permute(p2 + Pi.z + 1.0f);
float3 p31 = permute(p3 + Pi.z - 1.0f);
float3 p32 = permute(p3 + Pi.z);
float3 p33 = permute(p3 + Pi.z + 1.0f);
float3 ox11 = frac(p11 * K) - Ko;
float3 oy11 = mod7(floor(p11 * K)) * K - Ko;
float3 oz11 = floor(p11 * K2) * Kz - Kzo; // p11 < 289 guaranteed
float3 ox12 = frac(p12 * K) - Ko;
float3 oy12 = mod7(floor(p12 * K)) * K - Ko;
float3 oz12 = floor(p12 * K2) * Kz - Kzo;
float3 ox13 = frac(p13 * K) - Ko;
float3 oy13 = mod7(floor(p13 * K)) * K - Ko;
float3 oz13 = floor(p13 * K2) * Kz - Kzo;
float3 ox21 = frac(p21 * K) - Ko;
float3 oy21 = mod7(floor(p21 * K)) * K - Ko;
float3 oz21 = floor(p21 * K2) * Kz - Kzo;
float3 ox22 = frac(p22 * K) - Ko;
float3 oy22 = mod7(floor(p22 * K)) * K - Ko;
float3 oz22 = floor(p22 * K2) * Kz - Kzo;
float3 ox23 = frac(p23 * K) - Ko;
float3 oy23 = mod7(floor(p23 * K)) * K - Ko;
float3 oz23 = floor(p23 * K2) * Kz - Kzo;
float3 ox31 = frac(p31 * K) - Ko;
float3 oy31 = mod7(floor(p31 * K)) * K - Ko;
float3 oz31 = floor(p31 * K2) * Kz - Kzo;
float3 ox32 = frac(p32 * K) - Ko;
float3 oy32 = mod7(floor(p32 * K)) * K - Ko;
float3 oz32 = floor(p32 * K2) * Kz - Kzo;
float3 ox33 = frac(p33 * K) - Ko;
float3 oy33 = mod7(floor(p33 * K)) * K - Ko;
float3 oz33 = floor(p33 * K2) * Kz - Kzo;
float3 dx11 = Pfx + jitter * ox11;
float3 dy11 = Pfy.x + jitter * oy11;
float3 dz11 = Pfz.x + jitter * oz11;
float3 dx12 = Pfx + jitter * ox12;
float3 dy12 = Pfy.x + jitter * oy12;
float3 dz12 = Pfz.y + jitter * oz12;
float3 dx13 = Pfx + jitter * ox13;
float3 dy13 = Pfy.x + jitter * oy13;
float3 dz13 = Pfz.z + jitter * oz13;
float3 dx21 = Pfx + jitter * ox21;
float3 dy21 = Pfy.y + jitter * oy21;
float3 dz21 = Pfz.x + jitter * oz21;
float3 dx22 = Pfx + jitter * ox22;
float3 dy22 = Pfy.y + jitter * oy22;
float3 dz22 = Pfz.y + jitter * oz22;
float3 dx23 = Pfx + jitter * ox23;
float3 dy23 = Pfy.y + jitter * oy23;
float3 dz23 = Pfz.z + jitter * oz23;
float3 dx31 = Pfx + jitter * ox31;
float3 dy31 = Pfy.z + jitter * oy31;
float3 dz31 = Pfz.x + jitter * oz31;
float3 dx32 = Pfx + jitter * ox32;
float3 dy32 = Pfy.z + jitter * oy32;
float3 dz32 = Pfz.y + jitter * oz32;
float3 dx33 = Pfx + jitter * ox33;
float3 dy33 = Pfy.z + jitter * oy33;
float3 dz33 = Pfz.z + jitter * oz33;
float3 d11 = dx11 * dx11 + dy11 * dy11 + dz11 * dz11;
float3 d12 = dx12 * dx12 + dy12 * dy12 + dz12 * dz12;
float3 d13 = dx13 * dx13 + dy13 * dy13 + dz13 * dz13;
float3 d21 = dx21 * dx21 + dy21 * dy21 + dz21 * dz21;
float3 d22 = dx22 * dx22 + dy22 * dy22 + dz22 * dz22;
float3 d23 = dx23 * dx23 + dy23 * dy23 + dz23 * dz23;
float3 d31 = dx31 * dx31 + dy31 * dy31 + dz31 * dz31;
float3 d32 = dx32 * dx32 + dy32 * dy32 + dz32 * dz32;
float3 d33 = dx33 * dx33 + dy33 * dy33 + dz33 * dz33;
// Sort out the two smallest distances (F1, F2)
// Do it right and sort out both F1 and F2
float3 d1a = min(d11, d12);
d12 = max(d11, d12);
d11 = min(d1a, d13); // Smallest now not in d12 or d13
d13 = max(d1a, d13);
d12 = min(d12, d13); // 2nd smallest now not in d13
float3 d2a = min(d21, d22);
d22 = max(d21, d22);
d21 = min(d2a, d23); // Smallest now not in d22 or d23
d23 = max(d2a, d23);
d22 = min(d22, d23); // 2nd smallest now not in d23
float3 d3a = min(d31, d32);
d32 = max(d31, d32);
d31 = min(d3a, d33); // Smallest now not in d32 or d33
d33 = max(d3a, d33);
d32 = min(d32, d33); // 2nd smallest now not in d33
float3 da = min(d11, d21);
d21 = max(d11, d21);
d11 = min(da, d31); // Smallest now in d11
d31 = max(da, d31); // 2nd smallest now not in d31
d11.xy = (d11.x < d11.y) ? d11.xy : d11.yx;
d11.xz = (d11.x < d11.z) ? d11.xz : d11.zx; // d11.x now smallest
d12 = min(d12, d21); // 2nd smallest now not in d21
d12 = min(d12, d22); // nor in d22
d12 = min(d12, d31); // nor in d31
d12 = min(d12, d32); // nor in d32
d11.yz = min(d11.yz, d12.xy); // nor in d12.yz
d11.y = min(d11.y, d12.z); // Only two more to go
d11.y = min(d11.y, d11.z); // Done! (Phew!)
return sqrt(d11.xy); // F1, F2
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/cellular3D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6cea5378726344e72bf53fa723c6c3fb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

102
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise2D.cs Normal file
View file

@ -0,0 +1,102 @@
//
// GLSL textureless classic 2D noise "cnoise",
// with an RSL-style periodic variant "pnoise".
// Author: Stefan Gustavson (stefan.gustavson@liu.se)
// Version: 2011-08-22
//
// Many thanks to Ian McEwan of Ashima Arts for the
// ideas for permutation and gradient selection.
//
// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
// Distributed under the MIT license. See LICENSE file.
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Classic Perlin noise
public static float cnoise(float2 P)
{
float4 Pi = floor(P.xyxy) + float4(0.0f, 0.0f, 1.0f, 1.0f);
float4 Pf = frac(P.xyxy) - float4(0.0f, 0.0f, 1.0f, 1.0f);
Pi = mod289(Pi); // To avoid truncation effects in permutation
float4 ix = Pi.xzxz;
float4 iy = Pi.yyww;
float4 fx = Pf.xzxz;
float4 fy = Pf.yyww;
float4 i = permute(permute(ix) + iy);
float4 gx = frac(i * (1.0f / 41.0f)) * 2.0f - 1.0f;
float4 gy = abs(gx) - 0.5f;
float4 tx = floor(gx + 0.5f);
gx = gx - tx;
float2 g00 = float2(gx.x, gy.x);
float2 g10 = float2(gx.y, gy.y);
float2 g01 = float2(gx.z, gy.z);
float2 g11 = float2(gx.w, gy.w);
float4 norm = taylorInvSqrt(float4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, float2(fx.x, fy.x));
float n10 = dot(g10, float2(fx.y, fy.y));
float n01 = dot(g01, float2(fx.z, fy.z));
float n11 = dot(g11, float2(fx.w, fy.w));
float2 fade_xy = fade(Pf.xy);
float2 n_x = lerp(float2(n00, n01), float2(n10, n11), fade_xy.x);
float n_xy = lerp(n_x.x, n_x.y, fade_xy.y);
return 2.3f * n_xy;
}
// Classic Perlin noise, periodic variant
public static float pnoise(float2 P, float2 rep)
{
float4 Pi = floor(P.xyxy) + float4(0.0f, 0.0f, 1.0f, 1.0f);
float4 Pf = frac(P.xyxy) - float4(0.0f, 0.0f, 1.0f, 1.0f);
Pi = fmod(Pi, rep.xyxy); // To create noise with explicit period
Pi = mod289(Pi); // To avoid truncation effects in permutation
float4 ix = Pi.xzxz;
float4 iy = Pi.yyww;
float4 fx = Pf.xzxz;
float4 fy = Pf.yyww;
float4 i = permute(permute(ix) + iy);
float4 gx = frac(i * (1.0f / 41.0f)) * 2.0f - 1.0f;
float4 gy = abs(gx) - 0.5f;
float4 tx = floor(gx + 0.5f);
gx = gx - tx;
float2 g00 = float2(gx.x, gy.x);
float2 g10 = float2(gx.y, gy.y);
float2 g01 = float2(gx.z, gy.z);
float2 g11 = float2(gx.w, gy.w);
float4 norm = taylorInvSqrt(float4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
g00 *= norm.x;
g01 *= norm.y;
g10 *= norm.z;
g11 *= norm.w;
float n00 = dot(g00, float2(fx.x, fy.x));
float n10 = dot(g10, float2(fx.y, fy.y));
float n01 = dot(g01, float2(fx.z, fy.z));
float n11 = dot(g11, float2(fx.w, fy.w));
float2 fade_xy = fade(Pf.xy);
float2 n_x = lerp(float2(n00, n01), float2(n10, n11), fade_xy.x);
float n_xy = lerp(n_x.x, n_x.y, fade_xy.y);
return 2.3f * n_xy;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise2D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: cdfa008cc8af3440983f8c7beef680b9
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

161
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise3D.cs Normal file
View file

@ -0,0 +1,161 @@
//
// GLSL textureless classic 3D noise "cnoise",
// with an RSL-style periodic variant "pnoise".
// Author: Stefan Gustavson (stefan.gustavson@liu.se)
// Version: 2011-10-11
//
// Many thanks to Ian McEwan of Ashima Arts for the
// ideas for permutation and gradient selection.
//
// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
// Distributed under the MIT license. See LICENSE file.
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Classic Perlin noise
public static float cnoise(float3 P)
{
float3 Pi0 = floor(P); // Integer part for indexing
float3 Pi1 = Pi0 + float3(1.0f); // Integer part + 1
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
float3 Pf0 = frac(P); // Fractional part for interpolation
float3 Pf1 = Pf0 - float3(1.0f); // Fractional part - 1.0
float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
float4 iy = float4(Pi0.yy, Pi1.yy);
float4 iz0 = Pi0.zzzz;
float4 iz1 = Pi1.zzzz;
float4 ixy = permute(permute(ix) + iy);
float4 ixy0 = permute(ixy + iz0);
float4 ixy1 = permute(ixy + iz1);
float4 gx0 = ixy0 * (1.0f / 7.0f);
float4 gy0 = frac(floor(gx0) * (1.0f / 7.0f)) - 0.5f;
gx0 = frac(gx0);
float4 gz0 = float4(0.5f) - abs(gx0) - abs(gy0);
float4 sz0 = step(gz0, float4(0.0f));
gx0 -= sz0 * (step(0.0f, gx0) - 0.5f);
gy0 -= sz0 * (step(0.0f, gy0) - 0.5f);
float4 gx1 = ixy1 * (1.0f / 7.0f);
float4 gy1 = frac(floor(gx1) * (1.0f / 7.0f)) - 0.5f;
gx1 = frac(gx1);
float4 gz1 = float4(0.5f) - abs(gx1) - abs(gy1);
float4 sz1 = step(gz1, float4(0.0f));
gx1 -= sz1 * (step(0.0f, gx1) - 0.5f);
gy1 -= sz1 * (step(0.0f, gy1) - 0.5f);
float3 g000 = float3(gx0.x, gy0.x, gz0.x);
float3 g100 = float3(gx0.y, gy0.y, gz0.y);
float3 g010 = float3(gx0.z, gy0.z, gz0.z);
float3 g110 = float3(gx0.w, gy0.w, gz0.w);
float3 g001 = float3(gx1.x, gy1.x, gz1.x);
float3 g101 = float3(gx1.y, gy1.y, gz1.y);
float3 g011 = float3(gx1.z, gy1.z, gz1.z);
float3 g111 = float3(gx1.w, gy1.w, gz1.w);
float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 *= norm0.x;
g010 *= norm0.y;
g100 *= norm0.z;
g110 *= norm0.w;
float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 *= norm1.x;
g011 *= norm1.y;
g101 *= norm1.z;
g111 *= norm1.w;
float n000 = dot(g000, Pf0);
float n100 = dot(g100, float3(Pf1.x, Pf0.yz));
float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
float n110 = dot(g110, float3(Pf1.xy, Pf0.z));
float n001 = dot(g001, float3(Pf0.xy, Pf1.z));
float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
float n011 = dot(g011, float3(Pf0.x, Pf1.yz));
float n111 = dot(g111, Pf1);
float3 fade_xyz = fade(Pf0);
float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2f * n_xyz;
}
// Classic Perlin noise, periodic variant
public static float pnoise(float3 P, float3 rep)
{
float3 Pi0 = fmod(floor(P), rep); // Integer part, math.modulo period
float3 Pi1 = fmod(Pi0 + float3(1.0f), rep); // Integer part + 1, math.mod period
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
float3 Pf0 = frac(P); // Fractional part for interpolation
float3 Pf1 = Pf0 - float3(1.0f); // Fractional part - 1.0
float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
float4 iy = float4(Pi0.yy, Pi1.yy);
float4 iz0 = Pi0.zzzz;
float4 iz1 = Pi1.zzzz;
float4 ixy = permute(permute(ix) + iy);
float4 ixy0 = permute(ixy + iz0);
float4 ixy1 = permute(ixy + iz1);
float4 gx0 = ixy0 * (1.0f / 7.0f);
float4 gy0 = frac(floor(gx0) * (1.0f / 7.0f)) - 0.5f;
gx0 = frac(gx0);
float4 gz0 = float4(0.5f) - abs(gx0) - abs(gy0);
float4 sz0 = step(gz0, float4(0.0f));
gx0 -= sz0 * (step(0.0f, gx0) - 0.5f);
gy0 -= sz0 * (step(0.0f, gy0) - 0.5f);
float4 gx1 = ixy1 * (1.0f / 7.0f);
float4 gy1 = frac(floor(gx1) * (1.0f / 7.0f)) - 0.5f;
gx1 = frac(gx1);
float4 gz1 = float4(0.5f) - abs(gx1) - abs(gy1);
float4 sz1 = step(gz1, float4(0.0f));
gx1 -= sz1 * (step(0.0f, gx1) - 0.5f);
gy1 -= sz1 * (step(0.0f, gy1) - 0.5f);
float3 g000 = float3(gx0.x, gy0.x, gz0.x);
float3 g100 = float3(gx0.y, gy0.y, gz0.y);
float3 g010 = float3(gx0.z, gy0.z, gz0.z);
float3 g110 = float3(gx0.w, gy0.w, gz0.w);
float3 g001 = float3(gx1.x, gy1.x, gz1.x);
float3 g101 = float3(gx1.y, gy1.y, gz1.y);
float3 g011 = float3(gx1.z, gy1.z, gz1.z);
float3 g111 = float3(gx1.w, gy1.w, gz1.w);
float4 norm0 = taylorInvSqrt(float4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
g000 *= norm0.x;
g010 *= norm0.y;
g100 *= norm0.z;
g110 *= norm0.w;
float4 norm1 = taylorInvSqrt(float4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
g001 *= norm1.x;
g011 *= norm1.y;
g101 *= norm1.z;
g111 *= norm1.w;
float n000 = dot(g000, Pf0);
float n100 = dot(g100, float3(Pf1.x, Pf0.yz));
float n010 = dot(g010, float3(Pf0.x, Pf1.y, Pf0.z));
float n110 = dot(g110, float3(Pf1.xy, Pf0.z));
float n001 = dot(g001, float3(Pf0.xy, Pf1.z));
float n101 = dot(g101, float3(Pf1.x, Pf0.y, Pf1.z));
float n011 = dot(g011, float3(Pf0.x, Pf1.yz));
float n111 = dot(g111, Pf1);
float3 fade_xyz = fade(Pf0);
float4 n_z = lerp(float4(n000, n100, n010, n110), float4(n001, n101, n011, n111), fade_xyz.z);
float2 n_yz = lerp(n_z.xy, n_z.zw, fade_xyz.y);
float n_xyz = lerp(n_yz.x, n_yz.y, fade_xyz.x);
return 2.2f * n_xyz;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise3D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ab5efd242473d4ce9b3d98450681549c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

291
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise4D.cs Normal file
View file

@ -0,0 +1,291 @@
//
// GLSL textureless classic 4D noise "cnoise",
// with an RSL-style periodic variant "pnoise".
// Author: Stefan Gustavson (stefan.gustavson@liu.se)
// Version: 2011-08-22
//
// Many thanks to Ian McEwan of Ashima Arts for the
// ideas for permutation and gradient selection.
//
// Copyright (c) 2011 Stefan Gustavson. All rights reserved.
// Distributed under the MIT license. See LICENSE file.
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Classic Perlin noise
public static float cnoise(float4 P)
{
float4 Pi0 = floor(P); // Integer part for indexing
float4 Pi1 = Pi0 + 1.0f; // Integer part + 1
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
float4 Pf0 = frac(P); // Fractional part for interpolation
float4 Pf1 = Pf0 - 1.0f; // Fractional part - 1.0
float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
float4 iy = float4(Pi0.yy, Pi1.yy);
float4 iz0 = float4(Pi0.zzzz);
float4 iz1 = float4(Pi1.zzzz);
float4 iw0 = float4(Pi0.wwww);
float4 iw1 = float4(Pi1.wwww);
float4 ixy = permute(permute(ix) + iy);
float4 ixy0 = permute(ixy + iz0);
float4 ixy1 = permute(ixy + iz1);
float4 ixy00 = permute(ixy0 + iw0);
float4 ixy01 = permute(ixy0 + iw1);
float4 ixy10 = permute(ixy1 + iw0);
float4 ixy11 = permute(ixy1 + iw1);
float4 gx00 = ixy00 * (1.0f / 7.0f);
float4 gy00 = floor(gx00) * (1.0f / 7.0f);
float4 gz00 = floor(gy00) * (1.0f / 6.0f);
gx00 = frac(gx00) - 0.5f;
gy00 = frac(gy00) - 0.5f;
gz00 = frac(gz00) - 0.5f;
float4 gw00 = float4(0.75f) - abs(gx00) - abs(gy00) - abs(gz00);
float4 sw00 = step(gw00, float4(0.0f));
gx00 -= sw00 * (step(0.0f, gx00) - 0.5f);
gy00 -= sw00 * (step(0.0f, gy00) - 0.5f);
float4 gx01 = ixy01 * (1.0f / 7.0f);
float4 gy01 = floor(gx01) * (1.0f / 7.0f);
float4 gz01 = floor(gy01) * (1.0f / 6.0f);
gx01 = frac(gx01) - 0.5f;
gy01 = frac(gy01) - 0.5f;
gz01 = frac(gz01) - 0.5f;
float4 gw01 = float4(0.75f) - abs(gx01) - abs(gy01) - abs(gz01);
float4 sw01 = step(gw01, float4(0.0f));
gx01 -= sw01 * (step(0.0f, gx01) - 0.5f);
gy01 -= sw01 * (step(0.0f, gy01) - 0.5f);
float4 gx10 = ixy10 * (1.0f / 7.0f);
float4 gy10 = floor(gx10) * (1.0f / 7.0f);
float4 gz10 = floor(gy10) * (1.0f / 6.0f);
gx10 = frac(gx10) - 0.5f;
gy10 = frac(gy10) - 0.5f;
gz10 = frac(gz10) - 0.5f;
float4 gw10 = float4(0.75f) - abs(gx10) - abs(gy10) - abs(gz10);
float4 sw10 = step(gw10, float4(0.0f));
gx10 -= sw10 * (step(0.0f, gx10) - 0.5f);
gy10 -= sw10 * (step(0.0f, gy10) - 0.5f);
float4 gx11 = ixy11 * (1.0f / 7.0f);
float4 gy11 = floor(gx11) * (1.0f / 7.0f);
float4 gz11 = floor(gy11) * (1.0f / 6.0f);
gx11 = frac(gx11) - 0.5f;
gy11 = frac(gy11) - 0.5f;
gz11 = frac(gz11) - 0.5f;
float4 gw11 = float4(0.75f) - abs(gx11) - abs(gy11) - abs(gz11);
float4 sw11 = step(gw11, float4(0.0f));
gx11 -= sw11 * (step(0.0f, gx11) - 0.5f);
gy11 -= sw11 * (step(0.0f, gy11) - 0.5f);
float4 g0000 = float4(gx00.x, gy00.x, gz00.x, gw00.x);
float4 g1000 = float4(gx00.y, gy00.y, gz00.y, gw00.y);
float4 g0100 = float4(gx00.z, gy00.z, gz00.z, gw00.z);
float4 g1100 = float4(gx00.w, gy00.w, gz00.w, gw00.w);
float4 g0010 = float4(gx10.x, gy10.x, gz10.x, gw10.x);
float4 g1010 = float4(gx10.y, gy10.y, gz10.y, gw10.y);
float4 g0110 = float4(gx10.z, gy10.z, gz10.z, gw10.z);
float4 g1110 = float4(gx10.w, gy10.w, gz10.w, gw10.w);
float4 g0001 = float4(gx01.x, gy01.x, gz01.x, gw01.x);
float4 g1001 = float4(gx01.y, gy01.y, gz01.y, gw01.y);
float4 g0101 = float4(gx01.z, gy01.z, gz01.z, gw01.z);
float4 g1101 = float4(gx01.w, gy01.w, gz01.w, gw01.w);
float4 g0011 = float4(gx11.x, gy11.x, gz11.x, gw11.x);
float4 g1011 = float4(gx11.y, gy11.y, gz11.y, gw11.y);
float4 g0111 = float4(gx11.z, gy11.z, gz11.z, gw11.z);
float4 g1111 = float4(gx11.w, gy11.w, gz11.w, gw11.w);
float4 norm00 = taylorInvSqrt(float4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
g0000 *= norm00.x;
g0100 *= norm00.y;
g1000 *= norm00.z;
g1100 *= norm00.w;
float4 norm01 = taylorInvSqrt(float4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
g0001 *= norm01.x;
g0101 *= norm01.y;
g1001 *= norm01.z;
g1101 *= norm01.w;
float4 norm10 = taylorInvSqrt(float4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
g0010 *= norm10.x;
g0110 *= norm10.y;
g1010 *= norm10.z;
g1110 *= norm10.w;
float4 norm11 = taylorInvSqrt(float4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
g0011 *= norm11.x;
g0111 *= norm11.y;
g1011 *= norm11.z;
g1111 *= norm11.w;
float n0000 = dot(g0000, Pf0);
float n1000 = dot(g1000, float4(Pf1.x, Pf0.yzw));
float n0100 = dot(g0100, float4(Pf0.x, Pf1.y, Pf0.zw));
float n1100 = dot(g1100, float4(Pf1.xy, Pf0.zw));
float n0010 = dot(g0010, float4(Pf0.xy, Pf1.z, Pf0.w));
float n1010 = dot(g1010, float4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
float n0110 = dot(g0110, float4(Pf0.x, Pf1.yz, Pf0.w));
float n1110 = dot(g1110, float4(Pf1.xyz, Pf0.w));
float n0001 = dot(g0001, float4(Pf0.xyz, Pf1.w));
float n1001 = dot(g1001, float4(Pf1.x, Pf0.yz, Pf1.w));
float n0101 = dot(g0101, float4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
float n1101 = dot(g1101, float4(Pf1.xy, Pf0.z, Pf1.w));
float n0011 = dot(g0011, float4(Pf0.xy, Pf1.zw));
float n1011 = dot(g1011, float4(Pf1.x, Pf0.y, Pf1.zw));
float n0111 = dot(g0111, float4(Pf0.x, Pf1.yzw));
float n1111 = dot(g1111, Pf1);
float4 fade_xyzw = fade(Pf0);
float4 n_0w = lerp(float4(n0000, n1000, n0100, n1100), float4(n0001, n1001, n0101, n1101), fade_xyzw.w);
float4 n_1w = lerp(float4(n0010, n1010, n0110, n1110), float4(n0011, n1011, n0111, n1111), fade_xyzw.w);
float4 n_zw = lerp(n_0w, n_1w, fade_xyzw.z);
float2 n_yzw = lerp(n_zw.xy, n_zw.zw, fade_xyzw.y);
float n_xyzw = lerp(n_yzw.x, n_yzw.y, fade_xyzw.x);
return 2.2f * n_xyzw;
}
// Classic Perlin noise, periodic version
public static float pnoise(float4 P, float4 rep)
{
float4 Pi0 = fmod(floor(P), rep); // Integer part math.modulo rep
float4 Pi1 = fmod(Pi0 + 1.0f, rep); // Integer part + 1 math.mod rep
Pi0 = mod289(Pi0);
Pi1 = mod289(Pi1);
float4 Pf0 = frac(P); // Fractional part for interpolation
float4 Pf1 = Pf0 - 1.0f; // Fractional part - 1.0
float4 ix = float4(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
float4 iy = float4(Pi0.yy, Pi1.yy);
float4 iz0 = float4(Pi0.zzzz);
float4 iz1 = float4(Pi1.zzzz);
float4 iw0 = float4(Pi0.wwww);
float4 iw1 = float4(Pi1.wwww);
float4 ixy = permute(permute(ix) + iy);
float4 ixy0 = permute(ixy + iz0);
float4 ixy1 = permute(ixy + iz1);
float4 ixy00 = permute(ixy0 + iw0);
float4 ixy01 = permute(ixy0 + iw1);
float4 ixy10 = permute(ixy1 + iw0);
float4 ixy11 = permute(ixy1 + iw1);
float4 gx00 = ixy00 * (1.0f / 7.0f);
float4 gy00 = floor(gx00) * (1.0f / 7.0f);
float4 gz00 = floor(gy00) * (1.0f / 6.0f);
gx00 = frac(gx00) - 0.5f;
gy00 = frac(gy00) - 0.5f;
gz00 = frac(gz00) - 0.5f;
float4 gw00 = float4(0.75f) - abs(gx00) - abs(gy00) - abs(gz00);
float4 sw00 = step(gw00, float4(0.0f));
gx00 -= sw00 * (step(0.0f, gx00) - 0.5f);
gy00 -= sw00 * (step(0.0f, gy00) - 0.5f);
float4 gx01 = ixy01 * (1.0f / 7.0f);
float4 gy01 = floor(gx01) * (1.0f / 7.0f);
float4 gz01 = floor(gy01) * (1.0f / 6.0f);
gx01 = frac(gx01) - 0.5f;
gy01 = frac(gy01) - 0.5f;
gz01 = frac(gz01) - 0.5f;
float4 gw01 = float4(0.75f) - abs(gx01) - abs(gy01) - abs(gz01);
float4 sw01 = step(gw01, float4(0.0f));
gx01 -= sw01 * (step(0.0f, gx01) - 0.5f);
gy01 -= sw01 * (step(0.0f, gy01) - 0.5f);
float4 gx10 = ixy10 * (1.0f / 7.0f);
float4 gy10 = floor(gx10) * (1.0f / 7.0f);
float4 gz10 = floor(gy10) * (1.0f / 6.0f);
gx10 = frac(gx10) - 0.5f;
gy10 = frac(gy10) - 0.5f;
gz10 = frac(gz10) - 0.5f;
float4 gw10 = float4(0.75f) - abs(gx10) - abs(gy10) - abs(gz10);
float4 sw10 = step(gw10, float4(0.0f));
gx10 -= sw10 * (step(0.0f, gx10) - 0.5f);
gy10 -= sw10 * (step(0.0f, gy10) - 0.5f);
float4 gx11 = ixy11 * (1.0f / 7.0f);
float4 gy11 = floor(gx11) * (1.0f / 7.0f);
float4 gz11 = floor(gy11) * (1.0f / 6.0f);
gx11 = frac(gx11) - 0.5f;
gy11 = frac(gy11) - 0.5f;
gz11 = frac(gz11) - 0.5f;
float4 gw11 = float4(0.75f) - abs(gx11) - abs(gy11) - abs(gz11);
float4 sw11 = step(gw11, float4(0.0f));
gx11 -= sw11 * (step(0.0f, gx11) - 0.5f);
gy11 -= sw11 * (step(0.0f, gy11) - 0.5f);
float4 g0000 = float4(gx00.x, gy00.x, gz00.x, gw00.x);
float4 g1000 = float4(gx00.y, gy00.y, gz00.y, gw00.y);
float4 g0100 = float4(gx00.z, gy00.z, gz00.z, gw00.z);
float4 g1100 = float4(gx00.w, gy00.w, gz00.w, gw00.w);
float4 g0010 = float4(gx10.x, gy10.x, gz10.x, gw10.x);
float4 g1010 = float4(gx10.y, gy10.y, gz10.y, gw10.y);
float4 g0110 = float4(gx10.z, gy10.z, gz10.z, gw10.z);
float4 g1110 = float4(gx10.w, gy10.w, gz10.w, gw10.w);
float4 g0001 = float4(gx01.x, gy01.x, gz01.x, gw01.x);
float4 g1001 = float4(gx01.y, gy01.y, gz01.y, gw01.y);
float4 g0101 = float4(gx01.z, gy01.z, gz01.z, gw01.z);
float4 g1101 = float4(gx01.w, gy01.w, gz01.w, gw01.w);
float4 g0011 = float4(gx11.x, gy11.x, gz11.x, gw11.x);
float4 g1011 = float4(gx11.y, gy11.y, gz11.y, gw11.y);
float4 g0111 = float4(gx11.z, gy11.z, gz11.z, gw11.z);
float4 g1111 = float4(gx11.w, gy11.w, gz11.w, gw11.w);
float4 norm00 = taylorInvSqrt(float4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
g0000 *= norm00.x;
g0100 *= norm00.y;
g1000 *= norm00.z;
g1100 *= norm00.w;
float4 norm01 = taylorInvSqrt(float4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
g0001 *= norm01.x;
g0101 *= norm01.y;
g1001 *= norm01.z;
g1101 *= norm01.w;
float4 norm10 = taylorInvSqrt(float4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
g0010 *= norm10.x;
g0110 *= norm10.y;
g1010 *= norm10.z;
g1110 *= norm10.w;
float4 norm11 = taylorInvSqrt(float4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
g0011 *= norm11.x;
g0111 *= norm11.y;
g1011 *= norm11.z;
g1111 *= norm11.w;
float n0000 = dot(g0000, Pf0);
float n1000 = dot(g1000, float4(Pf1.x, Pf0.yzw));
float n0100 = dot(g0100, float4(Pf0.x, Pf1.y, Pf0.zw));
float n1100 = dot(g1100, float4(Pf1.xy, Pf0.zw));
float n0010 = dot(g0010, float4(Pf0.xy, Pf1.z, Pf0.w));
float n1010 = dot(g1010, float4(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
float n0110 = dot(g0110, float4(Pf0.x, Pf1.yz, Pf0.w));
float n1110 = dot(g1110, float4(Pf1.xyz, Pf0.w));
float n0001 = dot(g0001, float4(Pf0.xyz, Pf1.w));
float n1001 = dot(g1001, float4(Pf1.x, Pf0.yz, Pf1.w));
float n0101 = dot(g0101, float4(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
float n1101 = dot(g1101, float4(Pf1.xy, Pf0.z, Pf1.w));
float n0011 = dot(g0011, float4(Pf0.xy, Pf1.zw));
float n1011 = dot(g1011, float4(Pf1.x, Pf0.y, Pf1.zw));
float n0111 = dot(g0111, float4(Pf0.x, Pf1.yzw));
float n1111 = dot(g1111, Pf1);
float4 fade_xyzw = fade(Pf0);
float4 n_0w = lerp(float4(n0000, n1000, n0100, n1100), float4(n0001, n1001, n0101, n1101), fade_xyzw.w);
float4 n_1w = lerp(float4(n0010, n1010, n0110, n1110), float4(n0011, n1011, n0111, n1111), fade_xyzw.w);
float4 n_zw = lerp(n_0w, n_1w, fade_xyzw.z);
float2 n_yzw = lerp(n_zw.xy, n_zw.zw, fade_xyzw.y);
float n_xyzw = lerp(n_yzw.x, n_yzw.y, fade_xyzw.x);
return 2.2f * n_xyzw;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/classicnoise4D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 283464e0e530a4cdfbf4fae82efed3e3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

50
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/common.cs Normal file
View file

@ -0,0 +1,50 @@
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
// Modulo 289 without a division (only multiplications)
static float mod289(float x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
static float2 mod289(float2 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
static float3 mod289(float3 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
static float4 mod289(float4 x) { return x - floor(x * (1.0f / 289.0f)) * 289.0f; }
// Modulo 7 without a division
static float3 mod7(float3 x) { return x - floor(x * (1.0f / 7.0f)) * 7.0f; }
static float4 mod7(float4 x) { return x - floor(x * (1.0f / 7.0f)) * 7.0f; }
// Permutation polynomial: (34x^2 + x) math.mod 289
static float permute(float x) { return mod289((34.0f * x + 1.0f) * x); }
static float3 permute(float3 x) { return mod289((34.0f * x + 1.0f) * x); }
static float4 permute(float4 x) { return mod289((34.0f * x + 1.0f) * x); }
static float taylorInvSqrt(float r) { return 1.79284291400159f - 0.85373472095314f * r; }
static float4 taylorInvSqrt(float4 r) { return 1.79284291400159f - 0.85373472095314f * r; }
static float2 fade(float2 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
static float3 fade(float3 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
static float4 fade(float4 t) { return t*t*t*(t*(t*6.0f-15.0f)+10.0f); }
static float4 grad4(float j, float4 ip)
{
float4 ones = float4(1.0f, 1.0f, 1.0f, -1.0f);
float3 pxyz = floor(frac(float3(j) * ip.xyz) * 7.0f) * ip.z - 1.0f;
float pw = 1.5f - dot(abs(pxyz), ones.xyz);
float4 p = float4(pxyz, pw);
float4 s = float4(p < 0.0f);
p.xyz = p.xyz + (s.xyz*2.0f - 1.0f) * s.www;
return p;
}
// Hashed 2-D gradients with an extra rotation.
// (The constant 0.0243902439 is 1/41)
static float2 rgrad2(float2 p, float rot)
{
// For more isotropic gradients, math.sin/math.cos can be used instead.
float u = permute(permute(p.x) + p.y) * 0.0243902439f + rot; // Rotate by shift
u = frac(u) * 6.28318530718f; // 2*pi
return float2(cos(u), sin(u));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/common.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e99a8e417be944dfaad14c2d60f8450d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

68
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise2D.cs Normal file
View file

@ -0,0 +1,68 @@
//
// Description : Array and textureless GLSL 2D simplex noise function.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmath.mod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
public static float snoise(float2 v)
{
float4 C = float4(0.211324865405187f, // (3.0-math.sqrt(3.0))/6.0
0.366025403784439f, // 0.5*(math.sqrt(3.0)-1.0)
-0.577350269189626f, // -1.0 + 2.0 * C.x
0.024390243902439f); // 1.0 / 41.0
// First corner
float2 i = floor(v + dot(v, C.yy));
float2 x0 = v - i + dot(i, C.xx);
// Other corners
float2 i1;
//i1.x = math.step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
//i1.y = 1.0 - i1.x;
i1 = (x0.x > x0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
// x0 = x0 - 0.0 + 0.0 * C.xx ;
// x1 = x0 - i1 + 1.0 * C.xx ;
// x2 = x0 - 1.0 + 2.0 * C.xx ;
float4 x12 = x0.xyxy + C.xxzz;
x12.xy -= i1;
// Permutations
i = mod289(i); // Avoid truncation effects in permutation
float3 p = permute(permute(i.y + float3(0.0f, i1.y, 1.0f)) + i.x + float3(0.0f, i1.x, 1.0f));
float3 m = max(0.5f - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0f);
m = m * m;
m = m * m;
// Gradients: 41 points uniformly over a line, mapped onto a diamond.
// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
float3 x = 2.0f * frac(p * C.www) - 1.0f;
float3 h = abs(x) - 0.5f;
float3 ox = floor(x + 0.5f);
float3 a0 = x - ox;
// Normalise gradients implicitly by scaling m
// Approximation of: m *= inversemath.sqrt( a0*a0 + h*h );
m *= 1.79284291400159f - 0.85373472095314f * (a0 * a0 + h * h);
// Compute final noise value at P
float gx = a0.x * x0.x + h.x * x0.y;
float2 gyz = a0.yz * x12.xz + h.yz * x12.yw;
float3 g = float3(gx,gyz);
return 130.0f * dot(m, g);
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise2D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a44cd1da263fb47c2a45958442e14af6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

93
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise3D.cs Normal file
View file

@ -0,0 +1,93 @@
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmath.mod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
public static float snoise(float3 v)
{
float2 C = float2(1.0f / 6.0f, 1.0f / 3.0f);
float4 D = float4(0.0f, 0.5f, 1.0f, 2.0f);
// First corner
float3 i = floor(v + dot(v, C.yyy));
float3 x0 = v - i + dot(i, C.xxx);
// Other corners
float3 g = step(x0.yzx, x0.xyz);
float3 l = 1.0f - g;
float3 i1 = min(g.xyz, l.zxy);
float3 i2 = max(g.xyz, l.zxy);
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
float3 x1 = x0 - i1 + C.xxx;
float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
float3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
float4 p = permute(permute(permute(
i.z + float4(0.0f, i1.z, i2.z, 1.0f))
+ i.y + float4(0.0f, i1.y, i2.y, 1.0f))
+ i.x + float4(0.0f, i1.x, i2.x, 1.0f));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
float n_ = 0.142857142857f; // 1.0/7.0
float3 ns = n_ * D.wyz - D.xzx;
float4 j = p - 49.0f * floor(p * ns.z * ns.z); // math.mod(p,7*7)
float4 x_ = floor(j * ns.z);
float4 y_ = floor(j - 7.0f * x_); // math.mod(j,N)
float4 x = x_ * ns.x + ns.yyyy;
float4 y = y_ * ns.x + ns.yyyy;
float4 h = 1.0f - abs(x) - abs(y);
float4 b0 = float4(x.xy, y.xy);
float4 b1 = float4(x.zw, y.zw);
//float4 s0 = float4(math.lessThan(b0,0.0))*2.0 - 1.0;
//float4 s1 = float4(math.lessThan(b1,0.0))*2.0 - 1.0;
float4 s0 = floor(b0) * 2.0f + 1.0f;
float4 s1 = floor(b1) * 2.0f + 1.0f;
float4 sh = -step(h, float4(0.0f));
float4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
float4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
float3 p0 = float3(a0.xy, h.x);
float3 p1 = float3(a0.zw, h.y);
float3 p2 = float3(a1.xy, h.z);
float3 p3 = float3(a1.zw, h.w);
//Normalise gradients
float4 norm = taylorInvSqrt(float4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
float4 m = max(0.6f - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0f);
m = m * m;
return 42.0f * dot(m * m, float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3)));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise3D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 466846e8fd30645168912f2824cedb87
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

102
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise3Dgrad.cs Normal file
View file

@ -0,0 +1,102 @@
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmath.mod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
public static float snoise(float3 v, out float3 gradient)
{
float2 C = float2(1.0f / 6.0f, 1.0f / 3.0f);
float4 D = float4(0.0f, 0.5f, 1.0f, 2.0f);
// First corner
float3 i = floor(v + dot(v, C.yyy));
float3 x0 = v - i + dot(i, C.xxx);
// Other corners
float3 g = step(x0.yzx, x0.xyz);
float3 l = 1.0f - g;
float3 i1 = min(g.xyz, l.zxy);
float3 i2 = max(g.xyz, l.zxy);
// x0 = x0 - 0.0 + 0.0 * C.xxx;
// x1 = x0 - i1 + 1.0 * C.xxx;
// x2 = x0 - i2 + 2.0 * C.xxx;
// x3 = x0 - 1.0 + 3.0 * C.xxx;
float3 x1 = x0 - i1 + C.xxx;
float3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
float3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y
// Permutations
i = mod289(i);
float4 p = permute(permute(permute(
i.z + float4(0.0f, i1.z, i2.z, 1.0f))
+ i.y + float4(0.0f, i1.y, i2.y, 1.0f))
+ i.x + float4(0.0f, i1.x, i2.x, 1.0f));
// Gradients: 7x7 points over a square, mapped onto an octahedron.
// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
float n_ = 0.142857142857f; // 1.0/7.0
float3 ns = n_ * D.wyz - D.xzx;
float4 j = p - 49.0f * floor(p * ns.z * ns.z); // math.mod(p,7*7)
float4 x_ = floor(j * ns.z);
float4 y_ = floor(j - 7.0f * x_); // math.mod(j,N)
float4 x = x_ * ns.x + ns.yyyy;
float4 y = y_ * ns.x + ns.yyyy;
float4 h = 1.0f - abs(x) - abs(y);
float4 b0 = float4(x.xy, y.xy);
float4 b1 = float4(x.zw, y.zw);
//float4 s0 = float4(math.lessThan(b0,0.0))*2.0 - 1.0;
//float4 s1 = float4(math.lessThan(b1,0.0))*2.0 - 1.0;
float4 s0 = floor(b0) * 2.0f + 1.0f;
float4 s1 = floor(b1) * 2.0f + 1.0f;
float4 sh = -step(h, float4(0.0f));
float4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
float4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
float3 p0 = float3(a0.xy, h.x);
float3 p1 = float3(a0.zw, h.y);
float3 p2 = float3(a1.xy, h.z);
float3 p3 = float3(a1.zw, h.w);
//Normalise gradients
float4 norm = taylorInvSqrt(float4(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
// Mix final noise value
float4 m = max(0.6f - float4(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), 0.0f);
float4 m2 = m * m;
float4 m4 = m2 * m2;
float4 pdotx = float4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3));
// Determath.mine noise gradient
float4 temp = m2 * m * pdotx;
gradient = -8.0f * (temp.x * x0 + temp.y * x1 + temp.z * x2 + temp.w * x3);
gradient += m4.x * p0 + m4.y * p1 + m4.z * p2 + m4.w * p3;
gradient *= 42.0f;
return 42.0f * dot(m4, pdotx);
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise3Dgrad.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6849bb8369e5b4b2eb95e435578ff960
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

99
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise4D.cs Normal file
View file

@ -0,0 +1,99 @@
//
// Description : Array and textureless GLSL 2D/3D/4D simplex
// noise functions.
// Author : Ian McEwan, Ashima Arts.
// Maintainer : stegu
// Lastmath.mod : 20110822 (ijm)
// License : Copyright (C) 2011 Ashima Arts. All rights reserved.
// Distributed under the MIT License. See LICENSE file.
// https://github.com/ashima/webgl-noise
// https://github.com/stegu/webgl-noise
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
public static float snoise(float4 v)
{
// (math.sqrt(5) - 1)/4 = F4, used once below
const float F4 = 0.309016994374947451f;
float4 C = float4( 0.138196601125011f, // (5 - math.sqrt(5))/20 G4
0.276393202250021f, // 2 * G4
0.414589803375032f, // 3 * G4
-0.447213595499958f); // -1 + 4 * G4
// First corner
float4 i = floor(v + dot(v, float4(F4)) );
float4 x0 = v - i + dot(i, C.xxxx);
// Other corners
// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
float4 i0 = float4(0.0f);
float3 isX = step( x0.yzw, x0.xxx );
float3 isYZ = step( x0.zww, x0.yyz );
// i0.x = math.dot( isX, float3( 1.0 ) );
i0.x = isX.x + isX.y + isX.z;
i0.yzw = 1.0f - isX;
// i0.y += math.dot( isYZ.xy, float2( 1.0 ) );
i0.y += isYZ.x + isYZ.y;
i0.zw += 1.0f - isYZ.xy;
i0.z += isYZ.z;
i0.w += 1.0f - isYZ.z;
// i0 now contains the unique values 0,1,2,3 in each channel
float4 i3 = clamp( i0, 0.0f, 1.0f );
float4 i2 = clamp( i0-1.0f, 0.0f, 1.0f );
float4 i1 = clamp( i0-2.0f, 0.0f, 1.0f );
// x0 = x0 - 0.0 + 0.0 * C.xxxx
// x1 = x0 - i1 + 1.0 * C.xxxx
// x2 = x0 - i2 + 2.0 * C.xxxx
// x3 = x0 - i3 + 3.0 * C.xxxx
// x4 = x0 - 1.0 + 4.0 * C.xxxx
float4 x1 = x0 - i1 + C.xxxx;
float4 x2 = x0 - i2 + C.yyyy;
float4 x3 = x0 - i3 + C.zzzz;
float4 x4 = x0 + C.wwww;
// Permutations
i = mod289(i);
float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x);
float4 j1 = permute( permute( permute( permute (
i.w + float4(i1.w, i2.w, i3.w, 1.0f ))
+ i.z + float4(i1.z, i2.z, i3.z, 1.0f ))
+ i.y + float4(i1.y, i2.y, i3.y, 1.0f ))
+ i.x + float4(i1.x, i2.x, i3.x, 1.0f ));
// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
float4 ip = float4(1.0f/294.0f, 1.0f/49.0f, 1.0f/7.0f, 0.0f) ;
float4 p0 = grad4(j0, ip);
float4 p1 = grad4(j1.x, ip);
float4 p2 = grad4(j1.y, ip);
float4 p3 = grad4(j1.z, ip);
float4 p4 = grad4(j1.w, ip);
// Normalise gradients
float4 norm = taylorInvSqrt(float4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
p0 *= norm.x;
p1 *= norm.y;
p2 *= norm.z;
p3 *= norm.w;
p4 *= taylorInvSqrt(dot(p4,p4));
// Mix contributions from the five corners
float3 m0 = max(0.6f - float3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0f);
float2 m1 = max(0.6f - float2(dot(x3,x3), dot(x4,x4) ), 0.0f);
m0 = m0 * m0;
m1 = m1 * m1;
return 49.0f * ( dot(m0*m0, float3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 )))
+ dot(m1*m1, float2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/noise4D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b0d0317cc486b452580ad028220b03bf
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

439
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/psrdnoise2D.cs Normal file
View file

@ -0,0 +1,439 @@
//
// float3 psrdnoise(float2 pos, float2 per, float rot)
// float3 psrdnoise(float2 pos, float2 per)
// float psrnoise(float2 pos, float2 per, float rot)
// float psrnoise(float2 pos, float2 per)
// float3 srdnoise(float2 pos, float rot)
// float3 srdnoise(float2 pos)
// float srnoise(float2 pos, float rot)
// float srnoise(float2 pos)
//
// Periodic (tiling) 2-D simplex noise (hexagonal lattice gradient noise)
// with rotating gradients and analytic derivatives.
// Variants also without the derivative (no "d" in the name), without
// the tiling property (no "p" in the name) and without the rotating
// gradients (no "r" in the name).
//
// This is (yet) another variation on simplex noise. It's similar to the
// version presented by Ken Perlin, but the grid is axis-aligned and
// slightly stretched in the y direction to permit rectangular tiling.
//
// The noise can be made to tile seamlessly to any integer period in x and
// any even integer period in y. Odd periods may be specified for y, but
// then the actual tiling period will be twice that number.
//
// The rotating gradients give the appearance of a swirling motion, and can
// serve a similar purpose for animation as motion along z in 3-D noise.
// The rotating gradients in conjunction with the analytic derivatives
// can make "flow noise" effects as presented by Perlin and Neyret.
//
// float3 {p}s{r}dnoise(float2 pos {, float2 per} {, float rot})
// "pos" is the input (x,y) coordinate
// "per" is the x and y period, where per.x is a positive integer
// and per.y is a positive even integer
// "rot" is the angle to rotate the gradients (any float value,
// where 0.0 is no rotation and 1.0 is one full turn)
// The first component of the 3-element return vector is the noise value.
// The second and third components are the x and y partial derivatives.
//
// float {p}s{r}noise(float2 pos {, float2 per} {, float rot})
// "pos" is the input (x,y) coordinate
// "per" is the x and y period, where per.x is a positive integer
// and per.y is a positive even integer
// "rot" is the angle to rotate the gradients (any float value,
// where 0.0 is no rotation and 1.0 is one full turn)
// The return value is the noise value.
// Partial derivatives are not computed, making these functions faster.
//
// Author: Stefan Gustavson (stefan.gustavson@gmail.com)
// Version 2016-05-10.
//
// Many thanks to Ian McEwan of Ashima Arts for the
// idea of umath.sing a permutation polynomial.
//
// Copyright (c) 2016 Stefan Gustavson. All rights reserved.
// Distributed under the MIT license. See LICENSE file.
// https://github.com/stegu/webgl-noise
//
//
// TODO: One-pixel wide artefacts used to occur due to precision issues with
// the gradient indexing. This is specific to this variant of noise, because
// one axis of the simplex grid is perfectly aligned with the input x axis.
// The errors were rare, and they are now very unlikely to ever be visible
// after a quick fix was introduced: a small offset is added to the y coordinate.
// A proper fix would involve umath.sing round() instead of math.floor() in selected
// places, but the quick fix works fine.
// (If you run into problems with this, please let me know.)
//
using static Unity.Mathematics.math;
namespace Unity.Mathematics
{
public static partial class noise
{
//
// 2-D tiling simplex noise with rotating gradients and analytical derivative.
// The first component of the 3-element return vector is the noise value,
// and the second and third components are the x and y partial derivatives.
//
public static float3 psrdnoise(float2 pos, float2 per, float rot)
{
// Hack: offset y slightly to hide some rare artifacts
pos.y += 0.01f;
// Skew to hexagonal grid
float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
float2 i0 = floor(uv);
float2 f0 = frac(uv);
// Traversal order
float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
// Unskewed grid points in (x,y) space
float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
// Vectors in unskewed (x,y) coordinates from
// each of the simplex corners to the evaluation point
float2 d0 = pos - p0;
float2 d1 = pos - p1;
float2 d2 = pos - p2;
// Wrap p0, p1 and p2 to the desired period before gradient hashing:
// wrap points in (x,y), map to (u,v)
float3 xw = fmod(float3(p0.x, p1.x, p2.x), per.x);
float3 yw = fmod(float3(p0.y, p1.y, p2.y), per.y);
float3 iuw = xw + 0.5f * yw;
float3 ivw = yw;
// Create gradients from indices
float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
// Gradients math.dot vectors to corresponding corners
// (The derivatives of this are simply the gradients)
float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
// Radial weights from corners
// 0.8 is the square of 2/math.sqrt(5), the distance from
// a grid point to the nearest simplex boundary
float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
// Partial derivatives for analytical gradient computation
float3 dtdx = -2.0f * float3(d0.x, d1.x, d2.x);
float3 dtdy = -2.0f * float3(d0.y, d1.y, d2.y);
// Set influence of each surflet to zero outside radius math.sqrt(0.8)
if (t.x < 0.0f)
{
dtdx.x = 0.0f;
dtdy.x = 0.0f;
t.x = 0.0f;
}
if (t.y < 0.0f)
{
dtdx.y = 0.0f;
dtdy.y = 0.0f;
t.y = 0.0f;
}
if (t.z < 0.0f)
{
dtdx.z = 0.0f;
dtdy.z = 0.0f;
t.z = 0.0f;
}
// Fourth power of t (and third power for derivative)
float3 t2 = t * t;
float3 t4 = t2 * t2;
float3 t3 = t2 * t;
// Final noise value is:
// sum of ((radial weights) times (gradient math.dot vector from corner))
float n = dot(t4, w);
// Final analytical derivative (gradient of a sum of scalar products)
float2 dt0 = float2(dtdx.x, dtdy.x) * 4.0f * t3.x;
float2 dn0 = t4.x * g0 + dt0 * w.x;
float2 dt1 = float2(dtdx.y, dtdy.y) * 4.0f * t3.y;
float2 dn1 = t4.y * g1 + dt1 * w.y;
float2 dt2 = float2(dtdx.z, dtdy.z) * 4.0f * t3.z;
float2 dn2 = t4.z * g2 + dt2 * w.z;
return 11.0f * float3(n, dn0 + dn1 + dn2);
}
//
// 2-D tiling simplex noise with fixed gradients
// and analytical derivative.
// This function is implemented as a wrapper to "psrdnoise",
// at the math.minimal math.cost of three extra additions.
//
public static float3 psrdnoise(float2 pos, float2 per)
{
return psrdnoise(pos, per, 0.0f);
}
//
// 2-D tiling simplex noise with rotating gradients,
// but without the analytical derivative.
//
public static float psrnoise(float2 pos, float2 per, float rot)
{
// Offset y slightly to hide some rare artifacts
pos.y += 0.001f;
// Skew to hexagonal grid
float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
float2 i0 = floor(uv);
float2 f0 = frac(uv);
// Traversal order
float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
// Unskewed grid points in (x,y) space
float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
// Vectors in unskewed (x,y) coordinates from
// each of the simplex corners to the evaluation point
float2 d0 = pos - p0;
float2 d1 = pos - p1;
float2 d2 = pos - p2;
// Wrap p0, p1 and p2 to the desired period before gradient hashing:
// wrap points in (x,y), map to (u,v)
float3 xw = fmod(float3(p0.x, p1.x, p2.x), per.x);
float3 yw = fmod(float3(p0.y, p1.y, p2.y), per.y);
float3 iuw = xw + 0.5f * yw;
float3 ivw = yw;
// Create gradients from indices
float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
// Gradients math.dot vectors to corresponding corners
// (The derivatives of this are simply the gradients)
float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
// Radial weights from corners
// 0.8 is the square of 2/math.sqrt(5), the distance from
// a grid point to the nearest simplex boundary
float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
// Set influence of each surflet to zero outside radius math.sqrt(0.8)
t = max(t, 0.0f);
// Fourth power of t
float3 t2 = t * t;
float3 t4 = t2 * t2;
// Final noise value is:
// sum of ((radial weights) times (gradient math.dot vector from corner))
float n = dot(t4, w);
// Rescale to cover the range [-1,1] reasonably well
return 11.0f * n;
}
//
// 2-D tiling simplex noise with fixed gradients,
// without the analytical derivative.
// This function is implemented as a wrapper to "psrnoise",
// at the math.minimal math.cost of three extra additions.
//
public static float psrnoise(float2 pos, float2 per)
{
return psrnoise(pos, per, 0.0f);
}
//
// 2-D non-tiling simplex noise with rotating gradients and analytical derivative.
// The first component of the 3-element return vector is the noise value,
// and the second and third components are the x and y partial derivatives.
//
public static float3 srdnoise(float2 pos, float rot)
{
// Offset y slightly to hide some rare artifacts
pos.y += 0.001f;
// Skew to hexagonal grid
float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
float2 i0 = floor(uv);
float2 f0 = frac(uv);
// Traversal order
float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
// Unskewed grid points in (x,y) space
float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
// Vectors in unskewed (x,y) coordinates from
// each of the simplex corners to the evaluation point
float2 d0 = pos - p0;
float2 d1 = pos - p1;
float2 d2 = pos - p2;
float3 x = float3(p0.x, p1.x, p2.x);
float3 y = float3(p0.y, p1.y, p2.y);
float3 iuw = x + 0.5f * y;
float3 ivw = y;
// Avoid precision issues in permutation
iuw = mod289(iuw);
ivw = mod289(ivw);
// Create gradients from indices
float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
// Gradients math.dot vectors to corresponding corners
// (The derivatives of this are simply the gradients)
float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
// Radial weights from corners
// 0.8 is the square of 2/math.sqrt(5), the distance from
// a grid point to the nearest simplex boundary
float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
// Partial derivatives for analytical gradient computation
float3 dtdx = -2.0f * float3(d0.x, d1.x, d2.x);
float3 dtdy = -2.0f * float3(d0.y, d1.y, d2.y);
// Set influence of each surflet to zero outside radius math.sqrt(0.8)
if (t.x < 0.0f)
{
dtdx.x = 0.0f;
dtdy.x = 0.0f;
t.x = 0.0f;
}
if (t.y < 0.0f)
{
dtdx.y = 0.0f;
dtdy.y = 0.0f;
t.y = 0.0f;
}
if (t.z < 0.0f)
{
dtdx.z = 0.0f;
dtdy.z = 0.0f;
t.z = 0.0f;
}
// Fourth power of t (and third power for derivative)
float3 t2 = t * t;
float3 t4 = t2 * t2;
float3 t3 = t2 * t;
// Final noise value is:
// sum of ((radial weights) times (gradient math.dot vector from corner))
float n = dot(t4, w);
// Final analytical derivative (gradient of a sum of scalar products)
float2 dt0 = float2(dtdx.x, dtdy.x) * 4.0f * t3.x;
float2 dn0 = t4.x * g0 + dt0 * w.x;
float2 dt1 = float2(dtdx.y, dtdy.y) * 4.0f * t3.y;
float2 dn1 = t4.y * g1 + dt1 * w.y;
float2 dt2 = float2(dtdx.z, dtdy.z) * 4.0f * t3.z;
float2 dn2 = t4.z * g2 + dt2 * w.z;
return 11.0f * float3(n, dn0 + dn1 + dn2);
}
//
// 2-D non-tiling simplex noise with fixed gradients and analytical derivative.
// This function is implemented as a wrapper to "srdnoise",
// at the math.minimal math.cost of three extra additions.
//
public static float3 srdnoise(float2 pos)
{
return srdnoise(pos, 0.0f);
}
//
// 2-D non-tiling simplex noise with rotating gradients,
// without the analytical derivative.
//
public static float srnoise(float2 pos, float rot)
{
// Offset y slightly to hide some rare artifacts
pos.y += 0.001f;
// Skew to hexagonal grid
float2 uv = float2(pos.x + pos.y * 0.5f, pos.y);
float2 i0 = floor(uv);
float2 f0 = frac(uv);
// Traversal order
float2 i1 = (f0.x > f0.y) ? float2(1.0f, 0.0f) : float2(0.0f, 1.0f);
// Unskewed grid points in (x,y) space
float2 p0 = float2(i0.x - i0.y * 0.5f, i0.y);
float2 p1 = float2(p0.x + i1.x - i1.y * 0.5f, p0.y + i1.y);
float2 p2 = float2(p0.x + 0.5f, p0.y + 1.0f);
// Vectors in unskewed (x,y) coordinates from
// each of the simplex corners to the evaluation point
float2 d0 = pos - p0;
float2 d1 = pos - p1;
float2 d2 = pos - p2;
float3 x = float3(p0.x, p1.x, p2.x);
float3 y = float3(p0.y, p1.y, p2.y);
float3 iuw = x + 0.5f * y;
float3 ivw = y;
// Avoid precision issues in permutation
iuw = mod289(iuw);
ivw = mod289(ivw);
// Create gradients from indices
float2 g0 = rgrad2(float2(iuw.x, ivw.x), rot);
float2 g1 = rgrad2(float2(iuw.y, ivw.y), rot);
float2 g2 = rgrad2(float2(iuw.z, ivw.z), rot);
// Gradients math.dot vectors to corresponding corners
// (The derivatives of this are simply the gradients)
float3 w = float3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
// Radial weights from corners
// 0.8 is the square of 2/math.sqrt(5), the distance from
// a grid point to the nearest simplex boundary
float3 t = 0.8f - float3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
// Set influence of each surflet to zero outside radius math.sqrt(0.8)
t = max(t, 0.0f);
// Fourth power of t
float3 t2 = t * t;
float3 t4 = t2 * t2;
// Final noise value is:
// sum of ((radial weights) times (gradient math.dot vector from corner))
float n = dot(t4, w);
// Rescale to cover the range [-1,1] reasonably well
return 11.0f * n;
}
//
// 2-D non-tiling simplex noise with fixed gradients,
// without the analytical derivative.
// This function is implemented as a wrapper to "srnoise",
// at the math.minimal math.cost of three extra additions.
// Note: if this kind of noise is all you want, there are faster
// GLSL implementations of non-tiling simplex noise out there.
// This one is included mainly for completeness and compatibility
// with the other functions in the file.
//
public static float srnoise(float2 pos)
{
return srnoise(pos, 0.0f);
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/psrdnoise2D.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8bf609f94feab4ac5af33f75a100630c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

6
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs Normal file
View file

@ -0,0 +1,6 @@
namespace Unity.Mathematics
{
public class PostNormalizeAttribute : UnityEngine.PropertyAttribute {}
public class DoNotNormalizeAttribute : UnityEngine.PropertyAttribute {}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/PropertyAttributes.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 61cbbdd02bb00406b94029228cb3b73b
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

4
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef Normal file
View file

@ -0,0 +1,4 @@
{
"name": "Unity.Mathematics",
"allowUnsafeCode": true
}

7
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Unity.Mathematics.asmdef.meta Normal file
View file

@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: d8b63aba1907145bea998dd612889d6b
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

501
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2.gen.cs Normal file
View file

@ -0,0 +1,501 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Diagnostics;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[DebuggerTypeProxy(typeof(bool2.DebuggerProxy))]
[System.Serializable]
public partial struct bool2 : System.IEquatable<bool2>
{
[MarshalAs(UnmanagedType.U1)]
public bool x;
[MarshalAs(UnmanagedType.U1)]
public bool y;
/// <summary>Constructs a bool2 vector from two bool values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2(bool x, bool y)
{
this.x = x;
this.y = y;
}
/// <summary>Constructs a bool2 vector from a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2(bool2 xy)
{
this.x = xy.x;
this.y = xy.y;
}
/// <summary>Constructs a bool2 vector from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2(bool v)
{
this.x = v;
this.y = v;
}
/// <summary>Implicitly converts a single bool value to a bool2 vector by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool2(bool v) { return new bool2(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
/// <summary>Returns the result of a componentwise equality operation on a bool2 vector and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (bool2 lhs, bool rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (bool lhs, bool2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on a bool2 vector and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (bool2 lhs, bool rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (bool lhs, bool2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
/// <summary>Returns the result of a componentwise not operation on a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator ! (bool2 val) { return new bool2 (!val.x, !val.y); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator & (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x & rhs.x, lhs.y & rhs.y); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool2 vector and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator & (bool2 lhs, bool rhs) { return new bool2 (lhs.x & rhs, lhs.y & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator & (bool lhs, bool2 rhs) { return new bool2 (lhs & rhs.x, lhs & rhs.y); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator | (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x | rhs.x, lhs.y | rhs.y); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool2 vector and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator | (bool2 lhs, bool rhs) { return new bool2 (lhs.x | rhs, lhs.y | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator | (bool lhs, bool2 rhs) { return new bool2 (lhs | rhs.x, lhs | rhs.y); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator ^ (bool2 lhs, bool2 rhs) { return new bool2 (lhs.x ^ rhs.x, lhs.y ^ rhs.y); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2 vector and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator ^ (bool2 lhs, bool rhs) { return new bool2 (lhs.x ^ rhs, lhs.y ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator ^ (bool lhs, bool2 rhs) { return new bool2 (lhs ^ rhs.x, lhs ^ rhs.y); }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 xyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(x, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool4 yyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool4(y, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 xxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 xxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 xyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 xyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 yxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 yxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 yyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool3 yyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool3(y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool2 xx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool2(x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool2 xy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool2(x, y); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { x = value.x; y = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool2 yx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool2(y, x); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { y = value.x; x = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public bool2 yy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new bool2(y, y); }
}
/// <summary>Returns the bool element at a specified index.</summary>
unsafe public bool this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (bool2* array = &this) { return ((bool*)array)[index]; }
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (bool* array = &x) { array[index] = value; }
}
}
/// <summary>Returns true if the bool2 is equal to a given bool2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool2 rhs) { return x == rhs.x && y == rhs.y; }
/// <summary>Returns true if the bool2 is equal to a given bool2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool2)o); }
/// <summary>Returns a hash code for the bool2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool2({0}, {1})", x, y);
}
internal sealed class DebuggerProxy
{
public bool x;
public bool y;
public DebuggerProxy(bool2 v)
{
x = v.x;
y = v.y;
}
}
}
public static partial class math
{
/// <summary>Returns a bool2 vector constructed from two bool values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 bool2(bool x, bool y) { return new bool2(x, y); }
/// <summary>Returns a bool2 vector constructed from a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 bool2(bool2 xy) { return new bool2(xy); }
/// <summary>Returns a bool2 vector constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 bool2(bool v) { return new bool2(v); }
/// <summary>Returns a uint hash code of a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool2 v)
{
return csum(select(uint2(0x90A285BBu, 0x5D19E1D5u), uint2(0xFAAF07DDu, 0x625C45BDu), v));
}
/// <summary>
/// Returns a uint2 vector hash code of a bool2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(bool2 v)
{
return (select(uint2(0xC9F27FCBu, 0x6D2523B1u), uint2(0x6E2BF6A9u, 0xCC74B3B7u), v));
}
/// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool shuffle(bool2 a, bool2 b, ShuffleComponent x)
{
return select_shuffle_component(a, b, x);
}
/// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 shuffle(bool2 a, bool2 b, ShuffleComponent x, ShuffleComponent y)
{
return bool2(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y));
}
/// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3 shuffle(bool2 a, bool2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
{
return bool3(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z));
}
/// <summary>Returns the result of specified shuffling of the components from two bool2 vectors into a bool4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4 shuffle(bool2 a, bool2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
{
return bool4(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z),
select_shuffle_component(a, b, w));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static bool select_shuffle_component(bool2 a, bool2 b, ShuffleComponent component)
{
switch(component)
{
case ShuffleComponent.LeftX:
return a.x;
case ShuffleComponent.LeftY:
return a.y;
case ShuffleComponent.RightX:
return b.x;
case ShuffleComponent.RightY:
return b.y;
default:
throw new System.ArgumentException("Invalid shuffle component: " + component);
}
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 0790199222baf67419fdf802d76f93f5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

209
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x2.gen.cs Normal file
View file

@ -0,0 +1,209 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool2x2 : System.IEquatable<bool2x2>
{
public bool2 c0;
public bool2 c1;
/// <summary>Constructs a bool2x2 matrix from two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x2(bool2 c0, bool2 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a bool2x2 matrix from 4 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x2(bool m00, bool m01,
bool m10, bool m11)
{
this.c0 = new bool2(m00, m10);
this.c1 = new bool2(m01, m11);
}
/// <summary>Constructs a bool2x2 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x2(bool v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Implicitly converts a single bool value to a bool2x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool2x2(bool v) { return new bool2x2(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a bool2x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two bool2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a bool2x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the result of a componentwise not operation on a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator ! (bool2x2 val) { return new bool2x2 (!val.c0, !val.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator & (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool2x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator & (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator & (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs & rhs.c0, lhs & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator | (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool2x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator | (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator | (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs | rhs.c0, lhs | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator ^ (bool2x2 lhs, bool2x2 rhs) { return new bool2x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator ^ (bool2x2 lhs, bool rhs) { return new bool2x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator ^ (bool lhs, bool2x2 rhs) { return new bool2x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
/// <summary>Returns the bool2 element at a specified index.</summary>
unsafe public ref bool2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (bool2x2* array = &this) { return ref ((bool2*)array)[index]; }
}
}
/// <summary>Returns true if the bool2x2 is equal to a given bool2x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the bool2x2 is equal to a given bool2x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool2x2)o); }
/// <summary>Returns a hash code for the bool2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool2x2({0}, {1}, {2}, {3})", c0.x, c1.x, c0.y, c1.y);
}
}
public static partial class math
{
/// <summary>Returns a bool2x2 matrix constructed from two bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 bool2x2(bool2 c0, bool2 c1) { return new bool2x2(c0, c1); }
/// <summary>Returns a bool2x2 matrix constructed from from 4 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 bool2x2(bool m00, bool m01,
bool m10, bool m11)
{
return new bool2x2(m00, m01,
m10, m11);
}
/// <summary>Returns a bool2x2 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 bool2x2(bool v) { return new bool2x2(v); }
/// <summary>Return the bool2x2 transpose of a bool2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 transpose(bool2x2 v)
{
return bool2x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y);
}
/// <summary>Returns a uint hash code of a bool2x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool2x2 v)
{
return csum(select(uint2(0x7AF32C49u, 0xAE131389u), uint2(0x5D1B165Bu, 0x87096CD7u), v.c0) +
select(uint2(0x4C7F6DD1u, 0x4822A3E9u), uint2(0xAAC3C25Du, 0xD21D0945u), v.c1));
}
/// <summary>
/// Returns a uint2 vector hash code of a bool2x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(bool2x2 v)
{
return (select(uint2(0x88FCAB2Du, 0x614DA60Du), uint2(0x5BA2C50Bu, 0x8C455ACBu), v.c0) +
select(uint2(0xCD266C89u, 0xF1852A33u), uint2(0x77E35E77u, 0x863E3729u), v.c1));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 466955346f18d45f1811f3683f9cf707
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

216
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x3.gen.cs Normal file
View file

@ -0,0 +1,216 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool2x3 : System.IEquatable<bool2x3>
{
public bool2 c0;
public bool2 c1;
public bool2 c2;
/// <summary>Constructs a bool2x3 matrix from three bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x3(bool2 c0, bool2 c1, bool2 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a bool2x3 matrix from 6 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12)
{
this.c0 = new bool2(m00, m10);
this.c1 = new bool2(m01, m11);
this.c2 = new bool2(m02, m12);
}
/// <summary>Constructs a bool2x3 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x3(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Implicitly converts a single bool value to a bool2x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool2x3(bool v) { return new bool2x3(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a bool2x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two bool2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a bool2x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the result of a componentwise not operation on a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator ! (bool2x3 val) { return new bool2x3 (!val.c0, !val.c1, !val.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator & (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool2x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator & (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator & (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator | (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool2x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator | (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator | (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator ^ (bool2x3 lhs, bool2x3 rhs) { return new bool2x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator ^ (bool2x3 lhs, bool rhs) { return new bool2x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator ^ (bool lhs, bool2x3 rhs) { return new bool2x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
/// <summary>Returns the bool2 element at a specified index.</summary>
unsafe public ref bool2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (bool2x3* array = &this) { return ref ((bool2*)array)[index]; }
}
}
/// <summary>Returns true if the bool2x3 is equal to a given bool2x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the bool2x3 is equal to a given bool2x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool2x3)o); }
/// <summary>Returns a hash code for the bool2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool2x3({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
}
}
public static partial class math
{
/// <summary>Returns a bool2x3 matrix constructed from three bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 bool2x3(bool2 c0, bool2 c1, bool2 c2) { return new bool2x3(c0, c1, c2); }
/// <summary>Returns a bool2x3 matrix constructed from from 6 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 bool2x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12)
{
return new bool2x3(m00, m01, m02,
m10, m11, m12);
}
/// <summary>Returns a bool2x3 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 bool2x3(bool v) { return new bool2x3(v); }
/// <summary>Return the bool3x2 transpose of a bool2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 transpose(bool2x3 v)
{
return bool3x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y);
}
/// <summary>Returns a uint hash code of a bool2x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool2x3 v)
{
return csum(select(uint2(0x7BE39F3Bu, 0xFAB9913Fu), uint2(0xB4501269u, 0xE04B89FDu), v.c0) +
select(uint2(0xDB3DE101u, 0x7B6D1B4Bu), uint2(0x58399E77u, 0x5EAC29C9u), v.c1) +
select(uint2(0xFC6014F9u, 0x6BF6693Fu), uint2(0x9D1B1D9Bu, 0xF842F5C1u), v.c2));
}
/// <summary>
/// Returns a uint2 vector hash code of a bool2x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(bool2x3 v)
{
return (select(uint2(0xA47EC335u, 0xA477DF57u), uint2(0xC4B1493Fu, 0xBA0966D3u), v.c0) +
select(uint2(0xAFBEE253u, 0x5B419C01u), uint2(0x515D90F5u, 0xEC9F68F3u), v.c1) +
select(uint2(0xF9EA92D5u, 0xC2FAFCB9u), uint2(0x616E9CA1u, 0xC5C5394Bu), v.c2));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 2da7f6798be134406a5cc96b770b5e70
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

223
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x4.gen.cs Normal file
View file

@ -0,0 +1,223 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool2x4 : System.IEquatable<bool2x4>
{
public bool2 c0;
public bool2 c1;
public bool2 c2;
public bool2 c3;
/// <summary>Constructs a bool2x4 matrix from four bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a bool2x4 matrix from 8 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13)
{
this.c0 = new bool2(m00, m10);
this.c1 = new bool2(m01, m11);
this.c2 = new bool2(m02, m12);
this.c3 = new bool2(m03, m13);
}
/// <summary>Constructs a bool2x4 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool2x4(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Implicitly converts a single bool value to a bool2x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool2x4(bool v) { return new bool2x4(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a bool2x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two bool2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a bool2x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the result of a componentwise not operation on a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator ! (bool2x4 val) { return new bool2x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator & (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool2x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator & (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator & (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator | (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool2x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator | (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator | (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator ^ (bool2x4 lhs, bool2x4 rhs) { return new bool2x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool2x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator ^ (bool2x4 lhs, bool rhs) { return new bool2x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator ^ (bool lhs, bool2x4 rhs) { return new bool2x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
/// <summary>Returns the bool2 element at a specified index.</summary>
unsafe public ref bool2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (bool2x4* array = &this) { return ref ((bool2*)array)[index]; }
}
}
/// <summary>Returns true if the bool2x4 is equal to a given bool2x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the bool2x4 is equal to a given bool2x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool2x4)o); }
/// <summary>Returns a hash code for the bool2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool2x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y);
}
}
public static partial class math
{
/// <summary>Returns a bool2x4 matrix constructed from four bool2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 bool2x4(bool2 c0, bool2 c1, bool2 c2, bool2 c3) { return new bool2x4(c0, c1, c2, c3); }
/// <summary>Returns a bool2x4 matrix constructed from from 8 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 bool2x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13)
{
return new bool2x4(m00, m01, m02, m03,
m10, m11, m12, m13);
}
/// <summary>Returns a bool2x4 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 bool2x4(bool v) { return new bool2x4(v); }
/// <summary>Return the bool4x2 transpose of a bool2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 transpose(bool2x4 v)
{
return bool4x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y,
v.c3.x, v.c3.y);
}
/// <summary>Returns a uint hash code of a bool2x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool2x4 v)
{
return csum(select(uint2(0x45A22087u, 0xFC104C3Bu), uint2(0x5FFF6B19u, 0x5E6CBF3Bu), v.c0) +
select(uint2(0xB546F2A5u, 0xBBCF63E7u), uint2(0xC53F4755u, 0x6985C229u), v.c1) +
select(uint2(0xE133B0B3u, 0xC3E0A3B9u), uint2(0xFE31134Fu, 0x712A34D7u), v.c2) +
select(uint2(0x9D77A59Bu, 0x4942CA39u), uint2(0xB40EC62Du, 0x565ED63Fu), v.c3));
}
/// <summary>
/// Returns a uint2 vector hash code of a bool2x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(bool2x4 v)
{
return (select(uint2(0x93C30C2Bu, 0xDCAF0351u), uint2(0x6E050B01u, 0x750FDBF5u), v.c0) +
select(uint2(0x7F3DD499u, 0x52EAAEBBu), uint2(0x4599C793u, 0x83B5E729u), v.c1) +
select(uint2(0xC267163Fu, 0x67BC9149u), uint2(0xAD7C5EC1u, 0x822A7D6Du), v.c2) +
select(uint2(0xB492BF15u, 0xD37220E3u), uint2(0x7AA2C2BDu, 0xE16BC89Du), v.c3));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool2x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f3638df1ef4a049fb957126fc52d1a20
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

1270
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 75aefc1758f9fbc41af3579fdd45aa62
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

212
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x2.gen.cs Normal file
View file

@ -0,0 +1,212 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool3x2 : System.IEquatable<bool3x2>
{
public bool3 c0;
public bool3 c1;
/// <summary>Constructs a bool3x2 matrix from two bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x2(bool3 c0, bool3 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a bool3x2 matrix from 6 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x2(bool m00, bool m01,
bool m10, bool m11,
bool m20, bool m21)
{
this.c0 = new bool3(m00, m10, m20);
this.c1 = new bool3(m01, m11, m21);
}
/// <summary>Constructs a bool3x2 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x2(bool v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Implicitly converts a single bool value to a bool3x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool3x2(bool v) { return new bool3x2(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a bool3x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two bool3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a bool3x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the result of a componentwise not operation on a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator ! (bool3x2 val) { return new bool3x2 (!val.c0, !val.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator & (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool3x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator & (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator & (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs & rhs.c0, lhs & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator | (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool3x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator | (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator | (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs | rhs.c0, lhs | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator ^ (bool3x2 lhs, bool3x2 rhs) { return new bool3x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator ^ (bool3x2 lhs, bool rhs) { return new bool3x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator ^ (bool lhs, bool3x2 rhs) { return new bool3x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
/// <summary>Returns the bool3 element at a specified index.</summary>
unsafe public ref bool3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (bool3x2* array = &this) { return ref ((bool3*)array)[index]; }
}
}
/// <summary>Returns true if the bool3x2 is equal to a given bool3x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the bool3x2 is equal to a given bool3x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool3x2)o); }
/// <summary>Returns a hash code for the bool3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z);
}
}
public static partial class math
{
/// <summary>Returns a bool3x2 matrix constructed from two bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 bool3x2(bool3 c0, bool3 c1) { return new bool3x2(c0, c1); }
/// <summary>Returns a bool3x2 matrix constructed from from 6 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 bool3x2(bool m00, bool m01,
bool m10, bool m11,
bool m20, bool m21)
{
return new bool3x2(m00, m01,
m10, m11,
m20, m21);
}
/// <summary>Returns a bool3x2 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 bool3x2(bool v) { return new bool3x2(v); }
/// <summary>Return the bool2x3 transpose of a bool3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 transpose(bool3x2 v)
{
return bool2x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z);
}
/// <summary>Returns a uint hash code of a bool3x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool3x2 v)
{
return csum(select(uint3(0x9C9F0823u, 0x5A9CA13Bu, 0xAFCDD5EFu), uint3(0xA88D187Du, 0xCF6EBA1Du, 0x9D88E5A1u), v.c0) +
select(uint3(0xEADF0775u, 0x747A9D7Bu, 0x4111F799u), uint3(0xB5F05AF1u, 0xFD80290Bu, 0x8B65ADB7u), v.c1));
}
/// <summary>
/// Returns a uint3 vector hash code of a bool3x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(bool3x2 v)
{
return (select(uint3(0xDFF4F563u, 0x7069770Du, 0xD1224537u), uint3(0xE99ED6F3u, 0x48125549u, 0xEEE2123Bu), v.c0) +
select(uint3(0xE3AD9FE5u, 0xCE1CF8BFu, 0x7BE39F3Bu), uint3(0xFAB9913Fu, 0xB4501269u, 0xE04B89FDu), v.c1));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 21b83123b388e4dcb80da9576a60ebd2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

219
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x3.gen.cs Normal file
View file

@ -0,0 +1,219 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool3x3 : System.IEquatable<bool3x3>
{
public bool3 c0;
public bool3 c1;
public bool3 c2;
/// <summary>Constructs a bool3x3 matrix from three bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x3(bool3 c0, bool3 c1, bool3 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a bool3x3 matrix from 9 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12,
bool m20, bool m21, bool m22)
{
this.c0 = new bool3(m00, m10, m20);
this.c1 = new bool3(m01, m11, m21);
this.c2 = new bool3(m02, m12, m22);
}
/// <summary>Constructs a bool3x3 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x3(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Implicitly converts a single bool value to a bool3x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool3x3(bool v) { return new bool3x3(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a bool3x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two bool3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a bool3x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the result of a componentwise not operation on a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator ! (bool3x3 val) { return new bool3x3 (!val.c0, !val.c1, !val.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator & (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool3x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator & (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator & (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator | (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool3x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator | (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator | (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator ^ (bool3x3 lhs, bool3x3 rhs) { return new bool3x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator ^ (bool3x3 lhs, bool rhs) { return new bool3x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator ^ (bool lhs, bool3x3 rhs) { return new bool3x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
/// <summary>Returns the bool3 element at a specified index.</summary>
unsafe public ref bool3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (bool3x3* array = &this) { return ref ((bool3*)array)[index]; }
}
}
/// <summary>Returns true if the bool3x3 is equal to a given bool3x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the bool3x3 is equal to a given bool3x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool3x3)o); }
/// <summary>Returns a hash code for the bool3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z);
}
}
public static partial class math
{
/// <summary>Returns a bool3x3 matrix constructed from three bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 bool3x3(bool3 c0, bool3 c1, bool3 c2) { return new bool3x3(c0, c1, c2); }
/// <summary>Returns a bool3x3 matrix constructed from from 9 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 bool3x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12,
bool m20, bool m21, bool m22)
{
return new bool3x3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
/// <summary>Returns a bool3x3 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 bool3x3(bool v) { return new bool3x3(v); }
/// <summary>Return the bool3x3 transpose of a bool3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 transpose(bool3x3 v)
{
return bool3x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z);
}
/// <summary>Returns a uint hash code of a bool3x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool3x3 v)
{
return csum(select(uint3(0xE7579997u, 0xEF7D56C7u, 0x66F38F0Bu), uint3(0x624256A3u, 0x5292ADE1u, 0xD2E590E5u), v.c0) +
select(uint3(0xF25BE857u, 0x9BC17CE7u, 0xC8B86851u), uint3(0x64095221u, 0xADF428FFu, 0xA3977109u), v.c1) +
select(uint3(0x745ED837u, 0x9CDC88F5u, 0xFA62D721u), uint3(0x7E4DB1CFu, 0x68EEE0F5u, 0xBC3B0A59u), v.c2));
}
/// <summary>
/// Returns a uint3 vector hash code of a bool3x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(bool3x3 v)
{
return (select(uint3(0x816EFB5Du, 0xA24E82B7u, 0x45A22087u), uint3(0xFC104C3Bu, 0x5FFF6B19u, 0x5E6CBF3Bu), v.c0) +
select(uint3(0xB546F2A5u, 0xBBCF63E7u, 0xC53F4755u), uint3(0x6985C229u, 0xE133B0B3u, 0xC3E0A3B9u), v.c1) +
select(uint3(0xFE31134Fu, 0x712A34D7u, 0x9D77A59Bu), uint3(0x4942CA39u, 0xB40EC62Du, 0x565ED63Fu), v.c2));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a3b4b734e76c94d5099484b5b6c5b029
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

226
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x4.gen.cs Normal file
View file

@ -0,0 +1,226 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool3x4 : System.IEquatable<bool3x4>
{
public bool3 c0;
public bool3 c1;
public bool3 c2;
public bool3 c3;
/// <summary>Constructs a bool3x4 matrix from four bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a bool3x4 matrix from 12 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13,
bool m20, bool m21, bool m22, bool m23)
{
this.c0 = new bool3(m00, m10, m20);
this.c1 = new bool3(m01, m11, m21);
this.c2 = new bool3(m02, m12, m22);
this.c3 = new bool3(m03, m13, m23);
}
/// <summary>Constructs a bool3x4 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool3x4(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Implicitly converts a single bool value to a bool3x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool3x4(bool v) { return new bool3x4(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a bool3x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two bool3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a bool3x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the result of a componentwise not operation on a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator ! (bool3x4 val) { return new bool3x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator & (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool3x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator & (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator & (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator | (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool3x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator | (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator | (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator ^ (bool3x4 lhs, bool3x4 rhs) { return new bool3x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool3x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator ^ (bool3x4 lhs, bool rhs) { return new bool3x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator ^ (bool lhs, bool3x4 rhs) { return new bool3x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
/// <summary>Returns the bool3 element at a specified index.</summary>
unsafe public ref bool3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (bool3x4* array = &this) { return ref ((bool3*)array)[index]; }
}
}
/// <summary>Returns true if the bool3x4 is equal to a given bool3x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the bool3x4 is equal to a given bool3x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool3x4)o); }
/// <summary>Returns a hash code for the bool3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z);
}
}
public static partial class math
{
/// <summary>Returns a bool3x4 matrix constructed from four bool3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 bool3x4(bool3 c0, bool3 c1, bool3 c2, bool3 c3) { return new bool3x4(c0, c1, c2, c3); }
/// <summary>Returns a bool3x4 matrix constructed from from 12 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 bool3x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13,
bool m20, bool m21, bool m22, bool m23)
{
return new bool3x4(m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23);
}
/// <summary>Returns a bool3x4 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 bool3x4(bool v) { return new bool3x4(v); }
/// <summary>Return the bool4x3 transpose of a bool3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 transpose(bool3x4 v)
{
return bool4x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z,
v.c3.x, v.c3.y, v.c3.z);
}
/// <summary>Returns a uint hash code of a bool3x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool3x4 v)
{
return csum(select(uint3(0x83B58237u, 0x833E3E29u, 0xA9D919BFu), uint3(0xC3EC1D97u, 0xB8B208C7u, 0x5D3ED947u), v.c0) +
select(uint3(0x4473BBB1u, 0xCBA11D5Fu, 0x685835CFu), uint3(0xC3D32AE1u, 0xB966942Fu, 0xFE9856B3u), v.c1) +
select(uint3(0xFA3A3285u, 0xAD55999Du, 0xDCDD5341u), uint3(0x94DDD769u, 0xA1E92D39u, 0x4583C801u), v.c2) +
select(uint3(0x9536A0F5u, 0xAF816615u, 0x9AF8D62Du), uint3(0xE3600729u, 0x5F17300Du, 0x670D6809u), v.c3));
}
/// <summary>
/// Returns a uint3 vector hash code of a bool3x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(bool3x4 v)
{
return (select(uint3(0x7AF32C49u, 0xAE131389u, 0x5D1B165Bu), uint3(0x87096CD7u, 0x4C7F6DD1u, 0x4822A3E9u), v.c0) +
select(uint3(0xAAC3C25Du, 0xD21D0945u, 0x88FCAB2Du), uint3(0x614DA60Du, 0x5BA2C50Bu, 0x8C455ACBu), v.c1) +
select(uint3(0xCD266C89u, 0xF1852A33u, 0x77E35E77u), uint3(0x863E3729u, 0xE191B035u, 0x68586FAFu), v.c2) +
select(uint3(0xD4DFF6D3u, 0xCB634F4Du, 0x9B13B92Du), uint3(0x4ABF0813u, 0x86068063u, 0xD75513F9u), v.c3));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool3x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 82510cd108c8a4a7ebe40f0cec12d18c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

3187
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 64216725f837f8345b407a998b4970b3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

215
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x2.gen.cs Normal file
View file

@ -0,0 +1,215 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool4x2 : System.IEquatable<bool4x2>
{
public bool4 c0;
public bool4 c1;
/// <summary>Constructs a bool4x2 matrix from two bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x2(bool4 c0, bool4 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a bool4x2 matrix from 8 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x2(bool m00, bool m01,
bool m10, bool m11,
bool m20, bool m21,
bool m30, bool m31)
{
this.c0 = new bool4(m00, m10, m20, m30);
this.c1 = new bool4(m01, m11, m21, m31);
}
/// <summary>Constructs a bool4x2 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x2(bool v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Implicitly converts a single bool value to a bool4x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool4x2(bool v) { return new bool4x2(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a bool4x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two bool4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a bool4x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the result of a componentwise not operation on a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator ! (bool4x2 val) { return new bool4x2 (!val.c0, !val.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator & (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool4x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator & (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 & rhs, lhs.c1 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator & (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs & rhs.c0, lhs & rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator | (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool4x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator | (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 | rhs, lhs.c1 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator | (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs | rhs.c0, lhs | rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator ^ (bool4x2 lhs, bool4x2 rhs) { return new bool4x2 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x2 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator ^ (bool4x2 lhs, bool rhs) { return new bool4x2 (lhs.c0 ^ rhs, lhs.c1 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator ^ (bool lhs, bool4x2 rhs) { return new bool4x2 (lhs ^ rhs.c0, lhs ^ rhs.c1); }
/// <summary>Returns the bool4 element at a specified index.</summary>
unsafe public ref bool4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (bool4x2* array = &this) { return ref ((bool4*)array)[index]; }
}
}
/// <summary>Returns true if the bool4x2 is equal to a given bool4x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the bool4x2 is equal to a given bool4x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool4x2)o); }
/// <summary>Returns a hash code for the bool4x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool4x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w);
}
}
public static partial class math
{
/// <summary>Returns a bool4x2 matrix constructed from two bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 bool4x2(bool4 c0, bool4 c1) { return new bool4x2(c0, c1); }
/// <summary>Returns a bool4x2 matrix constructed from from 8 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 bool4x2(bool m00, bool m01,
bool m10, bool m11,
bool m20, bool m21,
bool m30, bool m31)
{
return new bool4x2(m00, m01,
m10, m11,
m20, m21,
m30, m31);
}
/// <summary>Returns a bool4x2 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 bool4x2(bool v) { return new bool4x2(v); }
/// <summary>Return the bool2x4 transpose of a bool4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 transpose(bool4x2 v)
{
return bool2x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w);
}
/// <summary>Returns a uint hash code of a bool4x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool4x2 v)
{
return csum(select(uint4(0xD19764C7u, 0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu), uint4(0x56A1530Du, 0x804B722Du, 0x738E50E5u, 0x4FC93C25u), v.c0) +
select(uint4(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du, 0xA10D9E27u), uint4(0x568DAAA9u, 0x7530254Fu, 0x9F090439u, 0x5E9F85C9u), v.c1));
}
/// <summary>
/// Returns a uint4 vector hash code of a bool4x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(bool4x2 v)
{
return (select(uint4(0x8C4CA03Fu, 0xB8D969EDu, 0xAC5DB57Bu, 0xA91A02EDu), uint4(0xB3C49313u, 0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u), v.c0) +
select(uint4(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu, 0xEBD0D005u), uint4(0x91475DF7u, 0x55E84827u, 0x90A285BBu, 0x5D19E1D5u), v.c1));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: d34b6dd47888145b8870e017d6c84d4e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

222
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x3.gen.cs Normal file
View file

@ -0,0 +1,222 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool4x3 : System.IEquatable<bool4x3>
{
public bool4 c0;
public bool4 c1;
public bool4 c2;
/// <summary>Constructs a bool4x3 matrix from three bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x3(bool4 c0, bool4 c1, bool4 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a bool4x3 matrix from 12 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12,
bool m20, bool m21, bool m22,
bool m30, bool m31, bool m32)
{
this.c0 = new bool4(m00, m10, m20, m30);
this.c1 = new bool4(m01, m11, m21, m31);
this.c2 = new bool4(m02, m12, m22, m32);
}
/// <summary>Constructs a bool4x3 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x3(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Implicitly converts a single bool value to a bool4x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool4x3(bool v) { return new bool4x3(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a bool4x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two bool4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a bool4x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the result of a componentwise not operation on a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator ! (bool4x3 val) { return new bool4x3 (!val.c0, !val.c1, !val.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator & (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool4x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator & (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator & (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator | (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool4x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator | (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator | (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator ^ (bool4x3 lhs, bool4x3 rhs) { return new bool4x3 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x3 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator ^ (bool4x3 lhs, bool rhs) { return new bool4x3 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator ^ (bool lhs, bool4x3 rhs) { return new bool4x3 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2); }
/// <summary>Returns the bool4 element at a specified index.</summary>
unsafe public ref bool4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (bool4x3* array = &this) { return ref ((bool4*)array)[index]; }
}
}
/// <summary>Returns true if the bool4x3 is equal to a given bool4x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the bool4x3 is equal to a given bool4x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool4x3)o); }
/// <summary>Returns a hash code for the bool4x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool4x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w);
}
}
public static partial class math
{
/// <summary>Returns a bool4x3 matrix constructed from three bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 bool4x3(bool4 c0, bool4 c1, bool4 c2) { return new bool4x3(c0, c1, c2); }
/// <summary>Returns a bool4x3 matrix constructed from from 12 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 bool4x3(bool m00, bool m01, bool m02,
bool m10, bool m11, bool m12,
bool m20, bool m21, bool m22,
bool m30, bool m31, bool m32)
{
return new bool4x3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22,
m30, m31, m32);
}
/// <summary>Returns a bool4x3 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 bool4x3(bool v) { return new bool4x3(v); }
/// <summary>Return the bool3x4 transpose of a bool4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 transpose(bool4x3 v)
{
return bool3x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w,
v.c2.x, v.c2.y, v.c2.z, v.c2.w);
}
/// <summary>Returns a uint hash code of a bool4x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool4x3 v)
{
return csum(select(uint4(0xEADF0775u, 0x747A9D7Bu, 0x4111F799u, 0xB5F05AF1u), uint4(0xFD80290Bu, 0x8B65ADB7u, 0xDFF4F563u, 0x7069770Du), v.c0) +
select(uint4(0xD1224537u, 0xE99ED6F3u, 0x48125549u, 0xEEE2123Bu), uint4(0xE3AD9FE5u, 0xCE1CF8BFu, 0x7BE39F3Bu, 0xFAB9913Fu), v.c1) +
select(uint4(0xB4501269u, 0xE04B89FDu, 0xDB3DE101u, 0x7B6D1B4Bu), uint4(0x58399E77u, 0x5EAC29C9u, 0xFC6014F9u, 0x6BF6693Fu), v.c2));
}
/// <summary>
/// Returns a uint4 vector hash code of a bool4x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(bool4x3 v)
{
return (select(uint4(0x9D1B1D9Bu, 0xF842F5C1u, 0xA47EC335u, 0xA477DF57u), uint4(0xC4B1493Fu, 0xBA0966D3u, 0xAFBEE253u, 0x5B419C01u), v.c0) +
select(uint4(0x515D90F5u, 0xEC9F68F3u, 0xF9EA92D5u, 0xC2FAFCB9u), uint4(0x616E9CA1u, 0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u), v.c1) +
select(uint4(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u, 0x91D13847u), uint4(0x52F7230Fu, 0xCF286E83u, 0xE121E6ADu, 0xC9CA1249u), v.c2));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e3e9b9173355b4d25aad23fb08782200
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

229
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x4.gen.cs Normal file
View file

@ -0,0 +1,229 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct bool4x4 : System.IEquatable<bool4x4>
{
public bool4 c0;
public bool4 c1;
public bool4 c2;
public bool4 c3;
/// <summary>Constructs a bool4x4 matrix from four bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a bool4x4 matrix from 16 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13,
bool m20, bool m21, bool m22, bool m23,
bool m30, bool m31, bool m32, bool m33)
{
this.c0 = new bool4(m00, m10, m20, m30);
this.c1 = new bool4(m01, m11, m21, m31);
this.c2 = new bool4(m02, m12, m22, m32);
this.c3 = new bool4(m03, m13, m23, m33);
}
/// <summary>Constructs a bool4x4 matrix from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool4x4(bool v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Implicitly converts a single bool value to a bool4x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator bool4x4(bool v) { return new bool4x4(v); }
/// <summary>Returns the result of a componentwise equality operation on two bool4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a bool4x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a bool value and a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two bool4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a bool4x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a bool value and a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the result of a componentwise not operation on a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator ! (bool4x4 val) { return new bool4x4 (!val.c0, !val.c1, !val.c2, !val.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on two bool4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator & (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 & rhs.c0, lhs.c1 & rhs.c1, lhs.c2 & rhs.c2, lhs.c3 & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool4x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator & (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 & rhs, lhs.c1 & rhs, lhs.c2 & rhs, lhs.c3 & rhs); }
/// <summary>Returns the result of a componentwise bitwise and operation on a bool value and a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator & (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs & rhs.c0, lhs & rhs.c1, lhs & rhs.c2, lhs & rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on two bool4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator | (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 | rhs.c0, lhs.c1 | rhs.c1, lhs.c2 | rhs.c2, lhs.c3 | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool4x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator | (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 | rhs, lhs.c1 | rhs, lhs.c2 | rhs, lhs.c3 | rhs); }
/// <summary>Returns the result of a componentwise bitwise or operation on a bool value and a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator | (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs | rhs.c0, lhs | rhs.c1, lhs | rhs.c2, lhs | rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on two bool4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator ^ (bool4x4 lhs, bool4x4 rhs) { return new bool4x4 (lhs.c0 ^ rhs.c0, lhs.c1 ^ rhs.c1, lhs.c2 ^ rhs.c2, lhs.c3 ^ rhs.c3); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool4x4 matrix and a bool value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator ^ (bool4x4 lhs, bool rhs) { return new bool4x4 (lhs.c0 ^ rhs, lhs.c1 ^ rhs, lhs.c2 ^ rhs, lhs.c3 ^ rhs); }
/// <summary>Returns the result of a componentwise bitwise exclusive or operation on a bool value and a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator ^ (bool lhs, bool4x4 rhs) { return new bool4x4 (lhs ^ rhs.c0, lhs ^ rhs.c1, lhs ^ rhs.c2, lhs ^ rhs.c3); }
/// <summary>Returns the bool4 element at a specified index.</summary>
unsafe public ref bool4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (bool4x4* array = &this) { return ref ((bool4*)array)[index]; }
}
}
/// <summary>Returns true if the bool4x4 is equal to a given bool4x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(bool4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the bool4x4 is equal to a given bool4x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((bool4x4)o); }
/// <summary>Returns a hash code for the bool4x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the bool4x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("bool4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w);
}
}
public static partial class math
{
/// <summary>Returns a bool4x4 matrix constructed from four bool4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 bool4x4(bool4 c0, bool4 c1, bool4 c2, bool4 c3) { return new bool4x4(c0, c1, c2, c3); }
/// <summary>Returns a bool4x4 matrix constructed from from 16 bool values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 bool4x4(bool m00, bool m01, bool m02, bool m03,
bool m10, bool m11, bool m12, bool m13,
bool m20, bool m21, bool m22, bool m23,
bool m30, bool m31, bool m32, bool m33)
{
return new bool4x4(m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23,
m30, m31, m32, m33);
}
/// <summary>Returns a bool4x4 matrix constructed from a single bool value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 bool4x4(bool v) { return new bool4x4(v); }
/// <summary>Return the bool4x4 transpose of a bool4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 transpose(bool4x4 v)
{
return bool4x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w,
v.c2.x, v.c2.y, v.c2.z, v.c2.w,
v.c3.x, v.c3.y, v.c3.z, v.c3.w);
}
/// <summary>Returns a uint hash code of a bool4x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(bool4x4 v)
{
return csum(select(uint4(0xD19764C7u, 0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu), uint4(0x56A1530Du, 0x804B722Du, 0x738E50E5u, 0x4FC93C25u), v.c0) +
select(uint4(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du, 0xA10D9E27u), uint4(0x568DAAA9u, 0x7530254Fu, 0x9F090439u, 0x5E9F85C9u), v.c1) +
select(uint4(0x8C4CA03Fu, 0xB8D969EDu, 0xAC5DB57Bu, 0xA91A02EDu), uint4(0xB3C49313u, 0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u), v.c2) +
select(uint4(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu, 0xEBD0D005u), uint4(0x91475DF7u, 0x55E84827u, 0x90A285BBu, 0x5D19E1D5u), v.c3));
}
/// <summary>
/// Returns a uint4 vector hash code of a bool4x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(bool4x4 v)
{
return (select(uint4(0xFAAF07DDu, 0x625C45BDu, 0xC9F27FCBu, 0x6D2523B1u), uint4(0x6E2BF6A9u, 0xCC74B3B7u, 0x83B58237u, 0x833E3E29u), v.c0) +
select(uint4(0xA9D919BFu, 0xC3EC1D97u, 0xB8B208C7u, 0x5D3ED947u), uint4(0x4473BBB1u, 0xCBA11D5Fu, 0x685835CFu, 0xC3D32AE1u), v.c1) +
select(uint4(0xB966942Fu, 0xFE9856B3u, 0xFA3A3285u, 0xAD55999Du), uint4(0xDCDD5341u, 0x94DDD769u, 0xA1E92D39u, 0x4583C801u), v.c2) +
select(uint4(0x9536A0F5u, 0xAF816615u, 0x9AF8D62Du, 0xE3600729u), uint4(0x5F17300Du, 0x670D6809u, 0x7AF32C49u, 0xAE131389u), v.c3));
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/bool4x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ec21b45eb93de4c05962f95aee69aee6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

760
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2.gen.cs Normal file
View file

@ -0,0 +1,760 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
using System.Diagnostics;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[DebuggerTypeProxy(typeof(double2.DebuggerProxy))]
[System.Serializable]
public partial struct double2 : System.IEquatable<double2>, IFormattable
{
public double x;
public double y;
/// <summary>double2 zero value.</summary>
public static readonly double2 zero;
/// <summary>Constructs a double2 vector from two double values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(double x, double y)
{
this.x = x;
this.y = y;
}
/// <summary>Constructs a double2 vector from a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(double2 xy)
{
this.x = xy.x;
this.y = xy.y;
}
/// <summary>Constructs a double2 vector from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(double v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a double2 vector from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(bool v)
{
this.x = v ? 1.0 : 0.0;
this.y = v ? 1.0 : 0.0;
}
/// <summary>Constructs a double2 vector from a bool2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(bool2 v)
{
this.x = v.x ? 1.0 : 0.0;
this.y = v.y ? 1.0 : 0.0;
}
/// <summary>Constructs a double2 vector from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(int v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a double2 vector from a int2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(int2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a double2 vector from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(uint v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a double2 vector from a uint2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(uint2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a double2 vector from a single half value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(half v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a double2 vector from a half2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(half2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a double2 vector from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(float v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a double2 vector from a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2(float2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Implicitly converts a single double value to a double2 vector by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(double v) { return new double2(v); }
/// <summary>Explicitly converts a single bool value to a double2 vector by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2(bool v) { return new double2(v); }
/// <summary>Explicitly converts a bool2 vector to a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2(bool2 v) { return new double2(v); }
/// <summary>Implicitly converts a single int value to a double2 vector by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(int v) { return new double2(v); }
/// <summary>Implicitly converts a int2 vector to a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(int2 v) { return new double2(v); }
/// <summary>Implicitly converts a single uint value to a double2 vector by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(uint v) { return new double2(v); }
/// <summary>Implicitly converts a uint2 vector to a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(uint2 v) { return new double2(v); }
/// <summary>Implicitly converts a single half value to a double2 vector by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(half v) { return new double2(v); }
/// <summary>Implicitly converts a half2 vector to a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(half2 v) { return new double2(v); }
/// <summary>Implicitly converts a single float value to a double2 vector by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(float v) { return new double2(v); }
/// <summary>Implicitly converts a float2 vector to a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2(float2 v) { return new double2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator * (double2 lhs, double2 rhs) { return new double2 (lhs.x * rhs.x, lhs.y * rhs.y); }
/// <summary>Returns the result of a componentwise multiplication operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator * (double2 lhs, double rhs) { return new double2 (lhs.x * rhs, lhs.y * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator * (double lhs, double2 rhs) { return new double2 (lhs * rhs.x, lhs * rhs.y); }
/// <summary>Returns the result of a componentwise addition operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator + (double2 lhs, double2 rhs) { return new double2 (lhs.x + rhs.x, lhs.y + rhs.y); }
/// <summary>Returns the result of a componentwise addition operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator + (double2 lhs, double rhs) { return new double2 (lhs.x + rhs, lhs.y + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator + (double lhs, double2 rhs) { return new double2 (lhs + rhs.x, lhs + rhs.y); }
/// <summary>Returns the result of a componentwise subtraction operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator - (double2 lhs, double2 rhs) { return new double2 (lhs.x - rhs.x, lhs.y - rhs.y); }
/// <summary>Returns the result of a componentwise subtraction operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator - (double2 lhs, double rhs) { return new double2 (lhs.x - rhs, lhs.y - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator - (double lhs, double2 rhs) { return new double2 (lhs - rhs.x, lhs - rhs.y); }
/// <summary>Returns the result of a componentwise division operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator / (double2 lhs, double2 rhs) { return new double2 (lhs.x / rhs.x, lhs.y / rhs.y); }
/// <summary>Returns the result of a componentwise division operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator / (double2 lhs, double rhs) { return new double2 (lhs.x / rhs, lhs.y / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator / (double lhs, double2 rhs) { return new double2 (lhs / rhs.x, lhs / rhs.y); }
/// <summary>Returns the result of a componentwise modulus operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator % (double2 lhs, double2 rhs) { return new double2 (lhs.x % rhs.x, lhs.y % rhs.y); }
/// <summary>Returns the result of a componentwise modulus operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator % (double2 lhs, double rhs) { return new double2 (lhs.x % rhs, lhs.y % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator % (double lhs, double2 rhs) { return new double2 (lhs % rhs.x, lhs % rhs.y); }
/// <summary>Returns the result of a componentwise increment operation on a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator ++ (double2 val) { return new double2 (++val.x, ++val.y); }
/// <summary>Returns the result of a componentwise decrement operation on a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator -- (double2 val) { return new double2 (--val.x, --val.y); }
/// <summary>Returns the result of a componentwise less than operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (double2 lhs, double2 rhs) { return new bool2 (lhs.x < rhs.x, lhs.y < rhs.y); }
/// <summary>Returns the result of a componentwise less than operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (double2 lhs, double rhs) { return new bool2 (lhs.x < rhs, lhs.y < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (double lhs, double2 rhs) { return new bool2 (lhs < rhs.x, lhs < rhs.y); }
/// <summary>Returns the result of a componentwise less or equal operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (double2 lhs, double2 rhs) { return new bool2 (lhs.x <= rhs.x, lhs.y <= rhs.y); }
/// <summary>Returns the result of a componentwise less or equal operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (double2 lhs, double rhs) { return new bool2 (lhs.x <= rhs, lhs.y <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (double lhs, double2 rhs) { return new bool2 (lhs <= rhs.x, lhs <= rhs.y); }
/// <summary>Returns the result of a componentwise greater than operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (double2 lhs, double2 rhs) { return new bool2 (lhs.x > rhs.x, lhs.y > rhs.y); }
/// <summary>Returns the result of a componentwise greater than operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (double2 lhs, double rhs) { return new bool2 (lhs.x > rhs, lhs.y > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (double lhs, double2 rhs) { return new bool2 (lhs > rhs.x, lhs > rhs.y); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (double2 lhs, double2 rhs) { return new bool2 (lhs.x >= rhs.x, lhs.y >= rhs.y); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (double2 lhs, double rhs) { return new bool2 (lhs.x >= rhs, lhs.y >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (double lhs, double2 rhs) { return new bool2 (lhs >= rhs.x, lhs >= rhs.y); }
/// <summary>Returns the result of a componentwise unary minus operation on a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator - (double2 val) { return new double2 (-val.x, -val.y); }
/// <summary>Returns the result of a componentwise unary plus operation on a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 operator + (double2 val) { return new double2 (+val.x, +val.y); }
/// <summary>Returns the result of a componentwise equality operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (double2 lhs, double2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
/// <summary>Returns the result of a componentwise equality operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (double2 lhs, double rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (double lhs, double2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (double2 lhs, double2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on a double2 vector and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (double2 lhs, double rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (double lhs, double2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 xyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(x, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double4 yyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double4(y, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 xxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 xxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 xyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 xyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 yxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 yxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 yyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double3 yyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double3(y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double2 xx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double2(x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double2 xy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double2(x, y); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { x = value.x; y = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double2 yx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double2(y, x); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { y = value.x; x = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public double2 yy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new double2(y, y); }
}
/// <summary>Returns the double element at a specified index.</summary>
unsafe public double this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (double2* array = &this) { return ((double*)array)[index]; }
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (double* array = &x) { array[index] = value; }
}
}
/// <summary>Returns true if the double2 is equal to a given double2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double2 rhs) { return x == rhs.x && y == rhs.y; }
/// <summary>Returns true if the double2 is equal to a given double2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double2)o); }
/// <summary>Returns a hash code for the double2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double2({0}, {1})", x, y);
}
/// <summary>Returns a string representation of the double2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double2({0}, {1})", x.ToString(format, formatProvider), y.ToString(format, formatProvider));
}
internal sealed class DebuggerProxy
{
public double x;
public double y;
public DebuggerProxy(double2 v)
{
x = v.x;
y = v.y;
}
}
}
public static partial class math
{
/// <summary>Returns a double2 vector constructed from two double values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(double x, double y) { return new double2(x, y); }
/// <summary>Returns a double2 vector constructed from a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(double2 xy) { return new double2(xy); }
/// <summary>Returns a double2 vector constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(double v) { return new double2(v); }
/// <summary>Returns a double2 vector constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(bool v) { return new double2(v); }
/// <summary>Return a double2 vector constructed from a bool2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(bool2 v) { return new double2(v); }
/// <summary>Returns a double2 vector constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(int v) { return new double2(v); }
/// <summary>Return a double2 vector constructed from a int2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(int2 v) { return new double2(v); }
/// <summary>Returns a double2 vector constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(uint v) { return new double2(v); }
/// <summary>Return a double2 vector constructed from a uint2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(uint2 v) { return new double2(v); }
/// <summary>Returns a double2 vector constructed from a single half value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(half v) { return new double2(v); }
/// <summary>Return a double2 vector constructed from a half2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(half2 v) { return new double2(v); }
/// <summary>Returns a double2 vector constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(float v) { return new double2(v); }
/// <summary>Return a double2 vector constructed from a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 double2(float2 v) { return new double2(v); }
/// <summary>Returns a uint hash code of a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double2 v)
{
return csum(fold_to_uint(v) * uint2(0x9536A0F5u, 0xAF816615u)) + 0x9AF8D62Du;
}
/// <summary>
/// Returns a uint2 vector hash code of a double2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(double2 v)
{
return (fold_to_uint(v) * uint2(0xE3600729u, 0x5F17300Du)) + 0x670D6809u;
}
/// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double shuffle(double2 a, double2 b, ShuffleComponent x)
{
return select_shuffle_component(a, b, x);
}
/// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2 shuffle(double2 a, double2 b, ShuffleComponent x, ShuffleComponent y)
{
return double2(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y));
}
/// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3 shuffle(double2 a, double2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
{
return double3(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z));
}
/// <summary>Returns the result of specified shuffling of the components from two double2 vectors into a double4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4 shuffle(double2 a, double2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
{
return double4(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z),
select_shuffle_component(a, b, w));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static double select_shuffle_component(double2 a, double2 b, ShuffleComponent component)
{
switch(component)
{
case ShuffleComponent.LeftX:
return a.x;
case ShuffleComponent.LeftY:
return a.y;
case ShuffleComponent.RightX:
return b.x;
case ShuffleComponent.RightY:
return b.y;
default:
throw new System.ArgumentException("Invalid shuffle component: " + component);
}
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8df28422e0a0640c1896e8de330e2640
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

468
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x2.gen.cs Normal file
View file

@ -0,0 +1,468 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double2x2 : System.IEquatable<double2x2>, IFormattable
{
public double2 c0;
public double2 c1;
/// <summary>double2x2 identity transform.</summary>
public static readonly double2x2 identity = new double2x2(1.0, 0.0, 0.0, 1.0);
/// <summary>double2x2 zero value.</summary>
public static readonly double2x2 zero;
/// <summary>Constructs a double2x2 matrix from two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(double2 c0, double2 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a double2x2 matrix from 4 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(double m00, double m01,
double m10, double m11)
{
this.c0 = new double2(m00, m10);
this.c1 = new double2(m01, m11);
}
/// <summary>Constructs a double2x2 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(double v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double2x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(bool v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v);
this.c1 = math.select(new double2(0.0), new double2(1.0), v);
}
/// <summary>Constructs a double2x2 matrix from a bool2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(bool2x2 v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
}
/// <summary>Constructs a double2x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(int v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double2x2 matrix from a int2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(int2x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double2x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double2x2 matrix from a uint2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(uint2x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double2x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(float v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double2x2 matrix from a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x2(float2x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Implicitly converts a single double value to a double2x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(double v) { return new double2x2(v); }
/// <summary>Explicitly converts a single bool value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x2(bool v) { return new double2x2(v); }
/// <summary>Explicitly converts a bool2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x2(bool2x2 v) { return new double2x2(v); }
/// <summary>Implicitly converts a single int value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(int v) { return new double2x2(v); }
/// <summary>Implicitly converts a int2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(int2x2 v) { return new double2x2(v); }
/// <summary>Implicitly converts a single uint value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(uint v) { return new double2x2(v); }
/// <summary>Implicitly converts a uint2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(uint2x2 v) { return new double2x2(v); }
/// <summary>Implicitly converts a single float value to a double2x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(float v) { return new double2x2(v); }
/// <summary>Implicitly converts a float2x2 matrix to a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x2(float2x2 v) { return new double2x2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator * (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
/// <summary>Returns the result of a componentwise multiplication operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator * (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator * (double lhs, double2x2 rhs) { return new double2x2 (lhs * rhs.c0, lhs * rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator + (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator + (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator + (double lhs, double2x2 rhs) { return new double2x2 (lhs + rhs.c0, lhs + rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator - (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator - (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator - (double lhs, double2x2 rhs) { return new double2x2 (lhs - rhs.c0, lhs - rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator / (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator / (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator / (double lhs, double2x2 rhs) { return new double2x2 (lhs / rhs.c0, lhs / rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator % (double2x2 lhs, double2x2 rhs) { return new double2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator % (double2x2 lhs, double rhs) { return new double2x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator % (double lhs, double2x2 rhs) { return new double2x2 (lhs % rhs.c0, lhs % rhs.c1); }
/// <summary>Returns the result of a componentwise increment operation on a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator ++ (double2x2 val) { return new double2x2 (++val.c0, ++val.c1); }
/// <summary>Returns the result of a componentwise decrement operation on a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator -- (double2x2 val) { return new double2x2 (--val.c0, --val.c1); }
/// <summary>Returns the result of a componentwise less than operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
/// <summary>Returns the result of a componentwise less than operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (double lhs, double2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (double lhs, double2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (double lhs, double2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (double lhs, double2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
/// <summary>Returns the result of a componentwise unary minus operation on a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator - (double2x2 val) { return new double2x2 (-val.c0, -val.c1); }
/// <summary>Returns the result of a componentwise unary plus operation on a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 operator + (double2x2 val) { return new double2x2 (+val.c0, +val.c1); }
/// <summary>Returns the result of a componentwise equality operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (double lhs, double2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two double2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (double2x2 lhs, double2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a double2x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (double2x2 lhs, double rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (double lhs, double2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the double2 element at a specified index.</summary>
unsafe public ref double2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (double2x2* array = &this) { return ref ((double2*)array)[index]; }
}
}
/// <summary>Returns true if the double2x2 is equal to a given double2x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the double2x2 is equal to a given double2x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double2x2)o); }
/// <summary>Returns a hash code for the double2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double2x2({0}, {1}, {2}, {3})", c0.x, c1.x, c0.y, c1.y);
}
/// <summary>Returns a string representation of the double2x2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double2x2({0}, {1}, {2}, {3})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double2x2 matrix constructed from two double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(double2 c0, double2 c1) { return new double2x2(c0, c1); }
/// <summary>Returns a double2x2 matrix constructed from from 4 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(double m00, double m01,
double m10, double m11)
{
return new double2x2(m00, m01,
m10, m11);
}
/// <summary>Returns a double2x2 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(double v) { return new double2x2(v); }
/// <summary>Returns a double2x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(bool v) { return new double2x2(v); }
/// <summary>Return a double2x2 matrix constructed from a bool2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(bool2x2 v) { return new double2x2(v); }
/// <summary>Returns a double2x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(int v) { return new double2x2(v); }
/// <summary>Return a double2x2 matrix constructed from a int2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(int2x2 v) { return new double2x2(v); }
/// <summary>Returns a double2x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(uint v) { return new double2x2(v); }
/// <summary>Return a double2x2 matrix constructed from a uint2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(uint2x2 v) { return new double2x2(v); }
/// <summary>Returns a double2x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(float v) { return new double2x2(v); }
/// <summary>Return a double2x2 matrix constructed from a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 double2x2(float2x2 v) { return new double2x2(v); }
/// <summary>Return the double2x2 transpose of a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 transpose(double2x2 v)
{
return double2x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y);
}
/// <summary>Returns the double2x2 full inverse of a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x2 inverse(double2x2 m)
{
double a = m.c0.x;
double b = m.c1.x;
double c = m.c0.y;
double d = m.c1.y;
double det = a * d - b * c;
return double2x2(d, -b, -c, a) * (1.0 / det);
}
/// <summary>Returns the determinant of a double2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double determinant(double2x2 m)
{
double a = m.c0.x;
double b = m.c1.x;
double c = m.c0.y;
double d = m.c1.y;
return a * d - b * c;
}
/// <summary>Returns a uint hash code of a double2x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double2x2 v)
{
return csum(fold_to_uint(v.c0) * uint2(0xFD80290Bu, 0x8B65ADB7u) +
fold_to_uint(v.c1) * uint2(0xDFF4F563u, 0x7069770Du)) + 0xD1224537u;
}
/// <summary>
/// Returns a uint2 vector hash code of a double2x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(double2x2 v)
{
return (fold_to_uint(v.c0) * uint2(0xE99ED6F3u, 0x48125549u) +
fold_to_uint(v.c1) * uint2(0xEEE2123Bu, 0xE3AD9FE5u)) + 0xCE1CF8BFu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3faab235f9f6845bbbd1d94d1376d896
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

454
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x3.gen.cs Normal file
View file

@ -0,0 +1,454 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double2x3 : System.IEquatable<double2x3>, IFormattable
{
public double2 c0;
public double2 c1;
public double2 c2;
/// <summary>double2x3 zero value.</summary>
public static readonly double2x3 zero;
/// <summary>Constructs a double2x3 matrix from three double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(double2 c0, double2 c1, double2 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a double2x3 matrix from 6 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(double m00, double m01, double m02,
double m10, double m11, double m12)
{
this.c0 = new double2(m00, m10);
this.c1 = new double2(m01, m11);
this.c2 = new double2(m02, m12);
}
/// <summary>Constructs a double2x3 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double2x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(bool v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v);
this.c1 = math.select(new double2(0.0), new double2(1.0), v);
this.c2 = math.select(new double2(0.0), new double2(1.0), v);
}
/// <summary>Constructs a double2x3 matrix from a bool2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(bool2x3 v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
this.c2 = math.select(new double2(0.0), new double2(1.0), v.c2);
}
/// <summary>Constructs a double2x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double2x3 matrix from a int2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(int2x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double2x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double2x3 matrix from a uint2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(uint2x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double2x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double2x3 matrix from a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x3(float2x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Implicitly converts a single double value to a double2x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(double v) { return new double2x3(v); }
/// <summary>Explicitly converts a single bool value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x3(bool v) { return new double2x3(v); }
/// <summary>Explicitly converts a bool2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x3(bool2x3 v) { return new double2x3(v); }
/// <summary>Implicitly converts a single int value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(int v) { return new double2x3(v); }
/// <summary>Implicitly converts a int2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(int2x3 v) { return new double2x3(v); }
/// <summary>Implicitly converts a single uint value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(uint v) { return new double2x3(v); }
/// <summary>Implicitly converts a uint2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(uint2x3 v) { return new double2x3(v); }
/// <summary>Implicitly converts a single float value to a double2x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(float v) { return new double2x3(v); }
/// <summary>Implicitly converts a float2x3 matrix to a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x3(float2x3 v) { return new double2x3(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator * (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
/// <summary>Returns the result of a componentwise multiplication operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator * (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator * (double lhs, double2x3 rhs) { return new double2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator + (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator + (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator + (double lhs, double2x3 rhs) { return new double2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator - (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator - (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator - (double lhs, double2x3 rhs) { return new double2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator / (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator / (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator / (double lhs, double2x3 rhs) { return new double2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator % (double2x3 lhs, double2x3 rhs) { return new double2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator % (double2x3 lhs, double rhs) { return new double2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator % (double lhs, double2x3 rhs) { return new double2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
/// <summary>Returns the result of a componentwise increment operation on a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator ++ (double2x3 val) { return new double2x3 (++val.c0, ++val.c1, ++val.c2); }
/// <summary>Returns the result of a componentwise decrement operation on a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator -- (double2x3 val) { return new double2x3 (--val.c0, --val.c1, --val.c2); }
/// <summary>Returns the result of a componentwise less than operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
/// <summary>Returns the result of a componentwise less than operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (double lhs, double2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (double lhs, double2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (double lhs, double2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (double lhs, double2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
/// <summary>Returns the result of a componentwise unary minus operation on a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator - (double2x3 val) { return new double2x3 (-val.c0, -val.c1, -val.c2); }
/// <summary>Returns the result of a componentwise unary plus operation on a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 operator + (double2x3 val) { return new double2x3 (+val.c0, +val.c1, +val.c2); }
/// <summary>Returns the result of a componentwise equality operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (double lhs, double2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two double2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (double2x3 lhs, double2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a double2x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (double2x3 lhs, double rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (double lhs, double2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the double2 element at a specified index.</summary>
unsafe public ref double2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (double2x3* array = &this) { return ref ((double2*)array)[index]; }
}
}
/// <summary>Returns true if the double2x3 is equal to a given double2x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the double2x3 is equal to a given double2x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double2x3)o); }
/// <summary>Returns a hash code for the double2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double2x3({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
}
/// <summary>Returns a string representation of the double2x3 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double2x3({0}, {1}, {2}, {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double2x3 matrix constructed from three double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(double2 c0, double2 c1, double2 c2) { return new double2x3(c0, c1, c2); }
/// <summary>Returns a double2x3 matrix constructed from from 6 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(double m00, double m01, double m02,
double m10, double m11, double m12)
{
return new double2x3(m00, m01, m02,
m10, m11, m12);
}
/// <summary>Returns a double2x3 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(double v) { return new double2x3(v); }
/// <summary>Returns a double2x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(bool v) { return new double2x3(v); }
/// <summary>Return a double2x3 matrix constructed from a bool2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(bool2x3 v) { return new double2x3(v); }
/// <summary>Returns a double2x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(int v) { return new double2x3(v); }
/// <summary>Return a double2x3 matrix constructed from a int2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(int2x3 v) { return new double2x3(v); }
/// <summary>Returns a double2x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(uint v) { return new double2x3(v); }
/// <summary>Return a double2x3 matrix constructed from a uint2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(uint2x3 v) { return new double2x3(v); }
/// <summary>Returns a double2x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(float v) { return new double2x3(v); }
/// <summary>Return a double2x3 matrix constructed from a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 double2x3(float2x3 v) { return new double2x3(v); }
/// <summary>Return the double3x2 transpose of a double2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 transpose(double2x3 v)
{
return double3x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y);
}
/// <summary>Returns a uint hash code of a double2x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double2x3 v)
{
return csum(fold_to_uint(v.c0) * uint2(0xF25BE857u, 0x9BC17CE7u) +
fold_to_uint(v.c1) * uint2(0xC8B86851u, 0x64095221u) +
fold_to_uint(v.c2) * uint2(0xADF428FFu, 0xA3977109u)) + 0x745ED837u;
}
/// <summary>
/// Returns a uint2 vector hash code of a double2x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(double2x3 v)
{
return (fold_to_uint(v.c0) * uint2(0x9CDC88F5u, 0xFA62D721u) +
fold_to_uint(v.c1) * uint2(0x7E4DB1CFu, 0x68EEE0F5u) +
fold_to_uint(v.c2) * uint2(0xBC3B0A59u, 0x816EFB5Du)) + 0xA24E82B7u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 5c05b76c6656d48b1a5a25086c9277c7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

469
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x4.gen.cs Normal file
View file

@ -0,0 +1,469 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double2x4 : System.IEquatable<double2x4>, IFormattable
{
public double2 c0;
public double2 c1;
public double2 c2;
public double2 c3;
/// <summary>double2x4 zero value.</summary>
public static readonly double2x4 zero;
/// <summary>Constructs a double2x4 matrix from four double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(double2 c0, double2 c1, double2 c2, double2 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a double2x4 matrix from 8 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13)
{
this.c0 = new double2(m00, m10);
this.c1 = new double2(m01, m11);
this.c2 = new double2(m02, m12);
this.c3 = new double2(m03, m13);
}
/// <summary>Constructs a double2x4 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double2x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(bool v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v);
this.c1 = math.select(new double2(0.0), new double2(1.0), v);
this.c2 = math.select(new double2(0.0), new double2(1.0), v);
this.c3 = math.select(new double2(0.0), new double2(1.0), v);
}
/// <summary>Constructs a double2x4 matrix from a bool2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(bool2x4 v)
{
this.c0 = math.select(new double2(0.0), new double2(1.0), v.c0);
this.c1 = math.select(new double2(0.0), new double2(1.0), v.c1);
this.c2 = math.select(new double2(0.0), new double2(1.0), v.c2);
this.c3 = math.select(new double2(0.0), new double2(1.0), v.c3);
}
/// <summary>Constructs a double2x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double2x4 matrix from a int2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(int2x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double2x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double2x4 matrix from a uint2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(uint2x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double2x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double2x4 matrix from a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double2x4(float2x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Implicitly converts a single double value to a double2x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(double v) { return new double2x4(v); }
/// <summary>Explicitly converts a single bool value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x4(bool v) { return new double2x4(v); }
/// <summary>Explicitly converts a bool2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double2x4(bool2x4 v) { return new double2x4(v); }
/// <summary>Implicitly converts a single int value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(int v) { return new double2x4(v); }
/// <summary>Implicitly converts a int2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(int2x4 v) { return new double2x4(v); }
/// <summary>Implicitly converts a single uint value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(uint v) { return new double2x4(v); }
/// <summary>Implicitly converts a uint2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(uint2x4 v) { return new double2x4(v); }
/// <summary>Implicitly converts a single float value to a double2x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(float v) { return new double2x4(v); }
/// <summary>Implicitly converts a float2x4 matrix to a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double2x4(float2x4 v) { return new double2x4(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator * (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
/// <summary>Returns the result of a componentwise multiplication operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator * (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator * (double lhs, double2x4 rhs) { return new double2x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator + (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator + (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator + (double lhs, double2x4 rhs) { return new double2x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator - (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator - (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator - (double lhs, double2x4 rhs) { return new double2x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator / (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator / (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator / (double lhs, double2x4 rhs) { return new double2x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator % (double2x4 lhs, double2x4 rhs) { return new double2x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator % (double2x4 lhs, double rhs) { return new double2x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator % (double lhs, double2x4 rhs) { return new double2x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
/// <summary>Returns the result of a componentwise increment operation on a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator ++ (double2x4 val) { return new double2x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
/// <summary>Returns the result of a componentwise decrement operation on a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator -- (double2x4 val) { return new double2x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
/// <summary>Returns the result of a componentwise less than operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
/// <summary>Returns the result of a componentwise less than operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (double lhs, double2x4 rhs) { return new bool2x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (double lhs, double2x4 rhs) { return new bool2x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (double lhs, double2x4 rhs) { return new bool2x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (double lhs, double2x4 rhs) { return new bool2x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
/// <summary>Returns the result of a componentwise unary minus operation on a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator - (double2x4 val) { return new double2x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
/// <summary>Returns the result of a componentwise unary plus operation on a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 operator + (double2x4 val) { return new double2x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
/// <summary>Returns the result of a componentwise equality operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (double lhs, double2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two double2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (double2x4 lhs, double2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a double2x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (double2x4 lhs, double rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (double lhs, double2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the double2 element at a specified index.</summary>
unsafe public ref double2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (double2x4* array = &this) { return ref ((double2*)array)[index]; }
}
}
/// <summary>Returns true if the double2x4 is equal to a given double2x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the double2x4 is equal to a given double2x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double2x4)o); }
/// <summary>Returns a hash code for the double2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double2x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y);
}
/// <summary>Returns a string representation of the double2x4 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double2x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double2x4 matrix constructed from four double2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(double2 c0, double2 c1, double2 c2, double2 c3) { return new double2x4(c0, c1, c2, c3); }
/// <summary>Returns a double2x4 matrix constructed from from 8 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13)
{
return new double2x4(m00, m01, m02, m03,
m10, m11, m12, m13);
}
/// <summary>Returns a double2x4 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(double v) { return new double2x4(v); }
/// <summary>Returns a double2x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(bool v) { return new double2x4(v); }
/// <summary>Return a double2x4 matrix constructed from a bool2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(bool2x4 v) { return new double2x4(v); }
/// <summary>Returns a double2x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(int v) { return new double2x4(v); }
/// <summary>Return a double2x4 matrix constructed from a int2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(int2x4 v) { return new double2x4(v); }
/// <summary>Returns a double2x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(uint v) { return new double2x4(v); }
/// <summary>Return a double2x4 matrix constructed from a uint2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(uint2x4 v) { return new double2x4(v); }
/// <summary>Returns a double2x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(float v) { return new double2x4(v); }
/// <summary>Return a double2x4 matrix constructed from a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 double2x4(float2x4 v) { return new double2x4(v); }
/// <summary>Return the double4x2 transpose of a double2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 transpose(double2x4 v)
{
return double4x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y,
v.c3.x, v.c3.y);
}
/// <summary>Returns a uint hash code of a double2x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double2x4 v)
{
return csum(fold_to_uint(v.c0) * uint2(0x91475DF7u, 0x55E84827u) +
fold_to_uint(v.c1) * uint2(0x90A285BBu, 0x5D19E1D5u) +
fold_to_uint(v.c2) * uint2(0xFAAF07DDu, 0x625C45BDu) +
fold_to_uint(v.c3) * uint2(0xC9F27FCBu, 0x6D2523B1u)) + 0x6E2BF6A9u;
}
/// <summary>
/// Returns a uint2 vector hash code of a double2x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(double2x4 v)
{
return (fold_to_uint(v.c0) * uint2(0xCC74B3B7u, 0x83B58237u) +
fold_to_uint(v.c1) * uint2(0x833E3E29u, 0xA9D919BFu) +
fold_to_uint(v.c2) * uint2(0xC3EC1D97u, 0xB8B208C7u) +
fold_to_uint(v.c3) * uint2(0x5D3ED947u, 0x4473BBB1u)) + 0xCBA11D5Fu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double2x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3e21dd148ae3e4bf98a4042d4756c4db
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

1538
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8532598f495324d779593b36c90c7f7c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

442
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x2.gen.cs Normal file
View file

@ -0,0 +1,442 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double3x2 : System.IEquatable<double3x2>, IFormattable
{
public double3 c0;
public double3 c1;
/// <summary>double3x2 zero value.</summary>
public static readonly double3x2 zero;
/// <summary>Constructs a double3x2 matrix from two double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(double3 c0, double3 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a double3x2 matrix from 6 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(double m00, double m01,
double m10, double m11,
double m20, double m21)
{
this.c0 = new double3(m00, m10, m20);
this.c1 = new double3(m01, m11, m21);
}
/// <summary>Constructs a double3x2 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(double v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double3x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(bool v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v);
this.c1 = math.select(new double3(0.0), new double3(1.0), v);
}
/// <summary>Constructs a double3x2 matrix from a bool3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(bool3x2 v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
}
/// <summary>Constructs a double3x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(int v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double3x2 matrix from a int3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(int3x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double3x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double3x2 matrix from a uint3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(uint3x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double3x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(float v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double3x2 matrix from a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x2(float3x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Implicitly converts a single double value to a double3x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(double v) { return new double3x2(v); }
/// <summary>Explicitly converts a single bool value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x2(bool v) { return new double3x2(v); }
/// <summary>Explicitly converts a bool3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x2(bool3x2 v) { return new double3x2(v); }
/// <summary>Implicitly converts a single int value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(int v) { return new double3x2(v); }
/// <summary>Implicitly converts a int3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(int3x2 v) { return new double3x2(v); }
/// <summary>Implicitly converts a single uint value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(uint v) { return new double3x2(v); }
/// <summary>Implicitly converts a uint3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(uint3x2 v) { return new double3x2(v); }
/// <summary>Implicitly converts a single float value to a double3x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(float v) { return new double3x2(v); }
/// <summary>Implicitly converts a float3x2 matrix to a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x2(float3x2 v) { return new double3x2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator * (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
/// <summary>Returns the result of a componentwise multiplication operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator * (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator * (double lhs, double3x2 rhs) { return new double3x2 (lhs * rhs.c0, lhs * rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator + (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator + (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator + (double lhs, double3x2 rhs) { return new double3x2 (lhs + rhs.c0, lhs + rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator - (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator - (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator - (double lhs, double3x2 rhs) { return new double3x2 (lhs - rhs.c0, lhs - rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator / (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator / (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator / (double lhs, double3x2 rhs) { return new double3x2 (lhs / rhs.c0, lhs / rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator % (double3x2 lhs, double3x2 rhs) { return new double3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator % (double3x2 lhs, double rhs) { return new double3x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator % (double lhs, double3x2 rhs) { return new double3x2 (lhs % rhs.c0, lhs % rhs.c1); }
/// <summary>Returns the result of a componentwise increment operation on a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator ++ (double3x2 val) { return new double3x2 (++val.c0, ++val.c1); }
/// <summary>Returns the result of a componentwise decrement operation on a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator -- (double3x2 val) { return new double3x2 (--val.c0, --val.c1); }
/// <summary>Returns the result of a componentwise less than operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
/// <summary>Returns the result of a componentwise less than operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (double lhs, double3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (double lhs, double3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (double lhs, double3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (double lhs, double3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
/// <summary>Returns the result of a componentwise unary minus operation on a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator - (double3x2 val) { return new double3x2 (-val.c0, -val.c1); }
/// <summary>Returns the result of a componentwise unary plus operation on a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 operator + (double3x2 val) { return new double3x2 (+val.c0, +val.c1); }
/// <summary>Returns the result of a componentwise equality operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (double lhs, double3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two double3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (double3x2 lhs, double3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a double3x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (double3x2 lhs, double rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (double lhs, double3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the double3 element at a specified index.</summary>
unsafe public ref double3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (double3x2* array = &this) { return ref ((double3*)array)[index]; }
}
}
/// <summary>Returns true if the double3x2 is equal to a given double3x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the double3x2 is equal to a given double3x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double3x2)o); }
/// <summary>Returns a hash code for the double3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z);
}
/// <summary>Returns a string representation of the double3x2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double3x2({0}, {1}, {2}, {3}, {4}, {5})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double3x2 matrix constructed from two double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(double3 c0, double3 c1) { return new double3x2(c0, c1); }
/// <summary>Returns a double3x2 matrix constructed from from 6 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(double m00, double m01,
double m10, double m11,
double m20, double m21)
{
return new double3x2(m00, m01,
m10, m11,
m20, m21);
}
/// <summary>Returns a double3x2 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(double v) { return new double3x2(v); }
/// <summary>Returns a double3x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(bool v) { return new double3x2(v); }
/// <summary>Return a double3x2 matrix constructed from a bool3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(bool3x2 v) { return new double3x2(v); }
/// <summary>Returns a double3x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(int v) { return new double3x2(v); }
/// <summary>Return a double3x2 matrix constructed from a int3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(int3x2 v) { return new double3x2(v); }
/// <summary>Returns a double3x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(uint v) { return new double3x2(v); }
/// <summary>Return a double3x2 matrix constructed from a uint3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(uint3x2 v) { return new double3x2(v); }
/// <summary>Returns a double3x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(float v) { return new double3x2(v); }
/// <summary>Return a double3x2 matrix constructed from a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x2 double3x2(float3x2 v) { return new double3x2(v); }
/// <summary>Return the double2x3 transpose of a double3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x3 transpose(double3x2 v)
{
return double2x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z);
}
/// <summary>Returns a uint hash code of a double3x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double3x2 v)
{
return csum(fold_to_uint(v.c0) * uint3(0xEE390C97u, 0x9C8A2F05u, 0x4DDC6509u) +
fold_to_uint(v.c1) * uint3(0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u)) + 0xE857DCE1u;
}
/// <summary>
/// Returns a uint3 vector hash code of a double3x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(double3x2 v)
{
return (fold_to_uint(v.c0) * uint3(0xF62213C5u, 0x9CDAA959u, 0xAA269ABFu) +
fold_to_uint(v.c1) * uint3(0xD54BA36Fu, 0xFD0847B9u, 0x8189A683u)) + 0xB139D651u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: dbb081701c605492aa7bca8b0dcd80d7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

494
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x3.gen.cs Normal file
View file

@ -0,0 +1,494 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double3x3 : System.IEquatable<double3x3>, IFormattable
{
public double3 c0;
public double3 c1;
public double3 c2;
/// <summary>double3x3 identity transform.</summary>
public static readonly double3x3 identity = new double3x3(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0);
/// <summary>double3x3 zero value.</summary>
public static readonly double3x3 zero;
/// <summary>Constructs a double3x3 matrix from three double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(double3 c0, double3 c1, double3 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a double3x3 matrix from 9 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(double m00, double m01, double m02,
double m10, double m11, double m12,
double m20, double m21, double m22)
{
this.c0 = new double3(m00, m10, m20);
this.c1 = new double3(m01, m11, m21);
this.c2 = new double3(m02, m12, m22);
}
/// <summary>Constructs a double3x3 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double3x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(bool v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v);
this.c1 = math.select(new double3(0.0), new double3(1.0), v);
this.c2 = math.select(new double3(0.0), new double3(1.0), v);
}
/// <summary>Constructs a double3x3 matrix from a bool3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(bool3x3 v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
this.c2 = math.select(new double3(0.0), new double3(1.0), v.c2);
}
/// <summary>Constructs a double3x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double3x3 matrix from a int3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(int3x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double3x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double3x3 matrix from a uint3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(uint3x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double3x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double3x3 matrix from a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x3(float3x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Implicitly converts a single double value to a double3x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(double v) { return new double3x3(v); }
/// <summary>Explicitly converts a single bool value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x3(bool v) { return new double3x3(v); }
/// <summary>Explicitly converts a bool3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x3(bool3x3 v) { return new double3x3(v); }
/// <summary>Implicitly converts a single int value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(int v) { return new double3x3(v); }
/// <summary>Implicitly converts a int3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(int3x3 v) { return new double3x3(v); }
/// <summary>Implicitly converts a single uint value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(uint v) { return new double3x3(v); }
/// <summary>Implicitly converts a uint3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(uint3x3 v) { return new double3x3(v); }
/// <summary>Implicitly converts a single float value to a double3x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(float v) { return new double3x3(v); }
/// <summary>Implicitly converts a float3x3 matrix to a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x3(float3x3 v) { return new double3x3(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator * (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
/// <summary>Returns the result of a componentwise multiplication operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator * (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator * (double lhs, double3x3 rhs) { return new double3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator + (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator + (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator + (double lhs, double3x3 rhs) { return new double3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator - (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator - (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator - (double lhs, double3x3 rhs) { return new double3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator / (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator / (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator / (double lhs, double3x3 rhs) { return new double3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator % (double3x3 lhs, double3x3 rhs) { return new double3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator % (double3x3 lhs, double rhs) { return new double3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator % (double lhs, double3x3 rhs) { return new double3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
/// <summary>Returns the result of a componentwise increment operation on a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator ++ (double3x3 val) { return new double3x3 (++val.c0, ++val.c1, ++val.c2); }
/// <summary>Returns the result of a componentwise decrement operation on a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator -- (double3x3 val) { return new double3x3 (--val.c0, --val.c1, --val.c2); }
/// <summary>Returns the result of a componentwise less than operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
/// <summary>Returns the result of a componentwise less than operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (double lhs, double3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (double lhs, double3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (double lhs, double3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (double lhs, double3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
/// <summary>Returns the result of a componentwise unary minus operation on a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator - (double3x3 val) { return new double3x3 (-val.c0, -val.c1, -val.c2); }
/// <summary>Returns the result of a componentwise unary plus operation on a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 operator + (double3x3 val) { return new double3x3 (+val.c0, +val.c1, +val.c2); }
/// <summary>Returns the result of a componentwise equality operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (double lhs, double3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two double3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (double3x3 lhs, double3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a double3x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (double3x3 lhs, double rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (double lhs, double3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the double3 element at a specified index.</summary>
unsafe public ref double3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (double3x3* array = &this) { return ref ((double3*)array)[index]; }
}
}
/// <summary>Returns true if the double3x3 is equal to a given double3x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the double3x3 is equal to a given double3x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double3x3)o); }
/// <summary>Returns a hash code for the double3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z);
}
/// <summary>Returns a string representation of the double3x3 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double3x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double3x3 matrix constructed from three double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(double3 c0, double3 c1, double3 c2) { return new double3x3(c0, c1, c2); }
/// <summary>Returns a double3x3 matrix constructed from from 9 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(double m00, double m01, double m02,
double m10, double m11, double m12,
double m20, double m21, double m22)
{
return new double3x3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
/// <summary>Returns a double3x3 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(double v) { return new double3x3(v); }
/// <summary>Returns a double3x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(bool v) { return new double3x3(v); }
/// <summary>Return a double3x3 matrix constructed from a bool3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(bool3x3 v) { return new double3x3(v); }
/// <summary>Returns a double3x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(int v) { return new double3x3(v); }
/// <summary>Return a double3x3 matrix constructed from a int3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(int3x3 v) { return new double3x3(v); }
/// <summary>Returns a double3x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(uint v) { return new double3x3(v); }
/// <summary>Return a double3x3 matrix constructed from a uint3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(uint3x3 v) { return new double3x3(v); }
/// <summary>Returns a double3x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(float v) { return new double3x3(v); }
/// <summary>Return a double3x3 matrix constructed from a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 double3x3(float3x3 v) { return new double3x3(v); }
/// <summary>Return the double3x3 transpose of a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x3 transpose(double3x3 v)
{
return double3x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z);
}
/// <summary>Returns the double3x3 full inverse of a double3x3 matrix.</summary>
public static double3x3 inverse(double3x3 m)
{
double3 c0 = m.c0;
double3 c1 = m.c1;
double3 c2 = m.c2;
double3 t0 = double3(c1.x, c2.x, c0.x);
double3 t1 = double3(c1.y, c2.y, c0.y);
double3 t2 = double3(c1.z, c2.z, c0.z);
double3 m0 = t1 * t2.yzx - t1.yzx * t2;
double3 m1 = t0.yzx * t2 - t0 * t2.yzx;
double3 m2 = t0 * t1.yzx - t0.yzx * t1;
double rcpDet = 1.0 / csum(t0.zxy * m0);
return double3x3(m0, m1, m2) * rcpDet;
}
/// <summary>Returns the determinant of a double3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double determinant(double3x3 m)
{
double3 c0 = m.c0;
double3 c1 = m.c1;
double3 c2 = m.c2;
double m00 = c1.y * c2.z - c1.z * c2.y;
double m01 = c0.y * c2.z - c0.z * c2.y;
double m02 = c0.y * c1.z - c0.z * c1.y;
return c0.x * m00 - c1.x * m01 + c2.x * m02;
}
/// <summary>Returns a uint hash code of a double3x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double3x3 v)
{
return csum(fold_to_uint(v.c0) * uint3(0xAC5DB57Bu, 0xA91A02EDu, 0xB3C49313u) +
fold_to_uint(v.c1) * uint3(0xF43A9ABBu, 0x84E7E01Bu, 0x8E055BE5u) +
fold_to_uint(v.c2) * uint3(0x6E624EB7u, 0x7383ED49u, 0xDD49C23Bu)) + 0xEBD0D005u;
}
/// <summary>
/// Returns a uint3 vector hash code of a double3x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(double3x3 v)
{
return (fold_to_uint(v.c0) * uint3(0x91475DF7u, 0x55E84827u, 0x90A285BBu) +
fold_to_uint(v.c1) * uint3(0x5D19E1D5u, 0xFAAF07DDu, 0x625C45BDu) +
fold_to_uint(v.c2) * uint3(0xC9F27FCBu, 0x6D2523B1u, 0x6E2BF6A9u)) + 0xCC74B3B7u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f1e8e688d7f354f92a78d4d78697150d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

489
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x4.gen.cs Normal file
View file

@ -0,0 +1,489 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double3x4 : System.IEquatable<double3x4>, IFormattable
{
public double3 c0;
public double3 c1;
public double3 c2;
public double3 c3;
/// <summary>double3x4 zero value.</summary>
public static readonly double3x4 zero;
/// <summary>Constructs a double3x4 matrix from four double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(double3 c0, double3 c1, double3 c2, double3 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a double3x4 matrix from 12 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23)
{
this.c0 = new double3(m00, m10, m20);
this.c1 = new double3(m01, m11, m21);
this.c2 = new double3(m02, m12, m22);
this.c3 = new double3(m03, m13, m23);
}
/// <summary>Constructs a double3x4 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double3x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(bool v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v);
this.c1 = math.select(new double3(0.0), new double3(1.0), v);
this.c2 = math.select(new double3(0.0), new double3(1.0), v);
this.c3 = math.select(new double3(0.0), new double3(1.0), v);
}
/// <summary>Constructs a double3x4 matrix from a bool3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(bool3x4 v)
{
this.c0 = math.select(new double3(0.0), new double3(1.0), v.c0);
this.c1 = math.select(new double3(0.0), new double3(1.0), v.c1);
this.c2 = math.select(new double3(0.0), new double3(1.0), v.c2);
this.c3 = math.select(new double3(0.0), new double3(1.0), v.c3);
}
/// <summary>Constructs a double3x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double3x4 matrix from a int3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(int3x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double3x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double3x4 matrix from a uint3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(uint3x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double3x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double3x4 matrix from a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double3x4(float3x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Implicitly converts a single double value to a double3x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(double v) { return new double3x4(v); }
/// <summary>Explicitly converts a single bool value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x4(bool v) { return new double3x4(v); }
/// <summary>Explicitly converts a bool3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double3x4(bool3x4 v) { return new double3x4(v); }
/// <summary>Implicitly converts a single int value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(int v) { return new double3x4(v); }
/// <summary>Implicitly converts a int3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(int3x4 v) { return new double3x4(v); }
/// <summary>Implicitly converts a single uint value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(uint v) { return new double3x4(v); }
/// <summary>Implicitly converts a uint3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(uint3x4 v) { return new double3x4(v); }
/// <summary>Implicitly converts a single float value to a double3x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(float v) { return new double3x4(v); }
/// <summary>Implicitly converts a float3x4 matrix to a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double3x4(float3x4 v) { return new double3x4(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator * (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
/// <summary>Returns the result of a componentwise multiplication operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator * (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator * (double lhs, double3x4 rhs) { return new double3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator + (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator + (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator + (double lhs, double3x4 rhs) { return new double3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator - (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator - (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator - (double lhs, double3x4 rhs) { return new double3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator / (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator / (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator / (double lhs, double3x4 rhs) { return new double3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator % (double3x4 lhs, double3x4 rhs) { return new double3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator % (double3x4 lhs, double rhs) { return new double3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator % (double lhs, double3x4 rhs) { return new double3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
/// <summary>Returns the result of a componentwise increment operation on a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator ++ (double3x4 val) { return new double3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
/// <summary>Returns the result of a componentwise decrement operation on a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator -- (double3x4 val) { return new double3x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
/// <summary>Returns the result of a componentwise less than operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
/// <summary>Returns the result of a componentwise less than operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (double lhs, double3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (double lhs, double3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (double lhs, double3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (double lhs, double3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
/// <summary>Returns the result of a componentwise unary minus operation on a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator - (double3x4 val) { return new double3x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
/// <summary>Returns the result of a componentwise unary plus operation on a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 operator + (double3x4 val) { return new double3x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
/// <summary>Returns the result of a componentwise equality operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (double lhs, double3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two double3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (double3x4 lhs, double3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a double3x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (double3x4 lhs, double rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (double lhs, double3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the double3 element at a specified index.</summary>
unsafe public ref double3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (double3x4* array = &this) { return ref ((double3*)array)[index]; }
}
}
/// <summary>Returns true if the double3x4 is equal to a given double3x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the double3x4 is equal to a given double3x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double3x4)o); }
/// <summary>Returns a hash code for the double3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z);
}
/// <summary>Returns a string representation of the double3x4 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double3x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double3x4 matrix constructed from four double3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(double3 c0, double3 c1, double3 c2, double3 c3) { return new double3x4(c0, c1, c2, c3); }
/// <summary>Returns a double3x4 matrix constructed from from 12 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23)
{
return new double3x4(m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23);
}
/// <summary>Returns a double3x4 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(double v) { return new double3x4(v); }
/// <summary>Returns a double3x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(bool v) { return new double3x4(v); }
/// <summary>Return a double3x4 matrix constructed from a bool3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(bool3x4 v) { return new double3x4(v); }
/// <summary>Returns a double3x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(int v) { return new double3x4(v); }
/// <summary>Return a double3x4 matrix constructed from a int3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(int3x4 v) { return new double3x4(v); }
/// <summary>Returns a double3x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(uint v) { return new double3x4(v); }
/// <summary>Return a double3x4 matrix constructed from a uint3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(uint3x4 v) { return new double3x4(v); }
/// <summary>Returns a double3x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(float v) { return new double3x4(v); }
/// <summary>Return a double3x4 matrix constructed from a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 double3x4(float3x4 v) { return new double3x4(v); }
/// <summary>Return the double4x3 transpose of a double3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 transpose(double3x4 v)
{
return double4x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z,
v.c3.x, v.c3.y, v.c3.z);
}
// Fast matrix inverse for rigid transforms (Orthonormal basis and translation)
public static double3x4 fastinverse(double3x4 m)
{
double3 c0 = m.c0;
double3 c1 = m.c1;
double3 c2 = m.c2;
double3 pos = m.c3;
double3 r0 = double3(c0.x, c1.x, c2.x);
double3 r1 = double3(c0.y, c1.y, c2.y);
double3 r2 = double3(c0.z, c1.z, c2.z);
pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
return double3x4(r0, r1, r2, pos);
}
/// <summary>Returns a uint hash code of a double3x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double3x4 v)
{
return csum(fold_to_uint(v.c0) * uint3(0xEE390C97u, 0x9C8A2F05u, 0x4DDC6509u) +
fold_to_uint(v.c1) * uint3(0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u) +
fold_to_uint(v.c2) * uint3(0xE857DCE1u, 0xF62213C5u, 0x9CDAA959u) +
fold_to_uint(v.c3) * uint3(0xAA269ABFu, 0xD54BA36Fu, 0xFD0847B9u)) + 0x8189A683u;
}
/// <summary>
/// Returns a uint3 vector hash code of a double3x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(double3x4 v)
{
return (fold_to_uint(v.c0) * uint3(0xB139D651u, 0xE7579997u, 0xEF7D56C7u) +
fold_to_uint(v.c1) * uint3(0x66F38F0Bu, 0x624256A3u, 0x5292ADE1u) +
fold_to_uint(v.c2) * uint3(0xD2E590E5u, 0xF25BE857u, 0x9BC17CE7u) +
fold_to_uint(v.c3) * uint3(0xC8B86851u, 0x64095221u, 0xADF428FFu)) + 0xA3977109u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double3x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 419ac95b4026548c39e12d2aa34922d6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

3464
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8d041bf430fc14f4787b6f89d3326147
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

445
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x2.gen.cs Normal file
View file

@ -0,0 +1,445 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double4x2 : System.IEquatable<double4x2>, IFormattable
{
public double4 c0;
public double4 c1;
/// <summary>double4x2 zero value.</summary>
public static readonly double4x2 zero;
/// <summary>Constructs a double4x2 matrix from two double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(double4 c0, double4 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a double4x2 matrix from 8 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(double m00, double m01,
double m10, double m11,
double m20, double m21,
double m30, double m31)
{
this.c0 = new double4(m00, m10, m20, m30);
this.c1 = new double4(m01, m11, m21, m31);
}
/// <summary>Constructs a double4x2 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(double v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double4x2 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(bool v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v);
this.c1 = math.select(new double4(0.0), new double4(1.0), v);
}
/// <summary>Constructs a double4x2 matrix from a bool4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(bool4x2 v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
}
/// <summary>Constructs a double4x2 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(int v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double4x2 matrix from a int4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(int4x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double4x2 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double4x2 matrix from a uint4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(uint4x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a double4x2 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(float v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a double4x2 matrix from a float4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x2(float4x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Implicitly converts a single double value to a double4x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(double v) { return new double4x2(v); }
/// <summary>Explicitly converts a single bool value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x2(bool v) { return new double4x2(v); }
/// <summary>Explicitly converts a bool4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x2(bool4x2 v) { return new double4x2(v); }
/// <summary>Implicitly converts a single int value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(int v) { return new double4x2(v); }
/// <summary>Implicitly converts a int4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(int4x2 v) { return new double4x2(v); }
/// <summary>Implicitly converts a single uint value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(uint v) { return new double4x2(v); }
/// <summary>Implicitly converts a uint4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(uint4x2 v) { return new double4x2(v); }
/// <summary>Implicitly converts a single float value to a double4x2 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(float v) { return new double4x2(v); }
/// <summary>Implicitly converts a float4x2 matrix to a double4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x2(float4x2 v) { return new double4x2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator * (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
/// <summary>Returns the result of a componentwise multiplication operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator * (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator * (double lhs, double4x2 rhs) { return new double4x2 (lhs * rhs.c0, lhs * rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator + (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator + (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator + (double lhs, double4x2 rhs) { return new double4x2 (lhs + rhs.c0, lhs + rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator - (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator - (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator - (double lhs, double4x2 rhs) { return new double4x2 (lhs - rhs.c0, lhs - rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator / (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator / (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator / (double lhs, double4x2 rhs) { return new double4x2 (lhs / rhs.c0, lhs / rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator % (double4x2 lhs, double4x2 rhs) { return new double4x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator % (double4x2 lhs, double rhs) { return new double4x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator % (double lhs, double4x2 rhs) { return new double4x2 (lhs % rhs.c0, lhs % rhs.c1); }
/// <summary>Returns the result of a componentwise increment operation on a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator ++ (double4x2 val) { return new double4x2 (++val.c0, ++val.c1); }
/// <summary>Returns the result of a componentwise decrement operation on a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator -- (double4x2 val) { return new double4x2 (--val.c0, --val.c1); }
/// <summary>Returns the result of a componentwise less than operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator < (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
/// <summary>Returns the result of a componentwise less than operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator < (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator < (double lhs, double4x2 rhs) { return new bool4x2 (lhs < rhs.c0, lhs < rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator <= (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator <= (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator <= (double lhs, double4x2 rhs) { return new bool4x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator > (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator > (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator > (double lhs, double4x2 rhs) { return new bool4x2 (lhs > rhs.c0, lhs > rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator >= (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator >= (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator >= (double lhs, double4x2 rhs) { return new bool4x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
/// <summary>Returns the result of a componentwise unary minus operation on a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator - (double4x2 val) { return new double4x2 (-val.c0, -val.c1); }
/// <summary>Returns the result of a componentwise unary plus operation on a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 operator + (double4x2 val) { return new double4x2 (+val.c0, +val.c1); }
/// <summary>Returns the result of a componentwise equality operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator == (double lhs, double4x2 rhs) { return new bool4x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two double4x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (double4x2 lhs, double4x2 rhs) { return new bool4x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a double4x2 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (double4x2 lhs, double rhs) { return new bool4x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x2 operator != (double lhs, double4x2 rhs) { return new bool4x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the double4 element at a specified index.</summary>
unsafe public ref double4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (double4x2* array = &this) { return ref ((double4*)array)[index]; }
}
}
/// <summary>Returns true if the double4x2 is equal to a given double4x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double4x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the double4x2 is equal to a given double4x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double4x2)o); }
/// <summary>Returns a hash code for the double4x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double4x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z, c0.w, c1.w);
}
/// <summary>Returns a string representation of the double4x2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double4x2({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double4x2 matrix constructed from two double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(double4 c0, double4 c1) { return new double4x2(c0, c1); }
/// <summary>Returns a double4x2 matrix constructed from from 8 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(double m00, double m01,
double m10, double m11,
double m20, double m21,
double m30, double m31)
{
return new double4x2(m00, m01,
m10, m11,
m20, m21,
m30, m31);
}
/// <summary>Returns a double4x2 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(double v) { return new double4x2(v); }
/// <summary>Returns a double4x2 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(bool v) { return new double4x2(v); }
/// <summary>Return a double4x2 matrix constructed from a bool4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(bool4x2 v) { return new double4x2(v); }
/// <summary>Returns a double4x2 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(int v) { return new double4x2(v); }
/// <summary>Return a double4x2 matrix constructed from a int4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(int4x2 v) { return new double4x2(v); }
/// <summary>Returns a double4x2 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(uint v) { return new double4x2(v); }
/// <summary>Return a double4x2 matrix constructed from a uint4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(uint4x2 v) { return new double4x2(v); }
/// <summary>Returns a double4x2 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(float v) { return new double4x2(v); }
/// <summary>Return a double4x2 matrix constructed from a float4x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x2 double4x2(float4x2 v) { return new double4x2(v); }
/// <summary>Return the double2x4 transpose of a double4x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double2x4 transpose(double4x2 v)
{
return double2x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w);
}
/// <summary>Returns a uint hash code of a double4x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double4x2 v)
{
return csum(fold_to_uint(v.c0) * uint4(0x5AB3E8CDu, 0x676E8407u, 0xB36DE767u, 0x6FCA387Du) +
fold_to_uint(v.c1) * uint4(0xAF0F3103u, 0xE4A056C7u, 0x841D8225u, 0xC9393C7Du)) + 0xD42EAFA3u;
}
/// <summary>
/// Returns a uint4 vector hash code of a double4x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(double4x2 v)
{
return (fold_to_uint(v.c0) * uint4(0xD9AFD06Du, 0x97A65421u, 0x7809205Fu, 0x9C9F0823u) +
fold_to_uint(v.c1) * uint4(0x5A9CA13Bu, 0xAFCDD5EFu, 0xA88D187Du, 0xCF6EBA1Du)) + 0x9D88E5A1u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 2780651a7c8e8413da73612cb720fbac
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

460
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x3.gen.cs Normal file
View file

@ -0,0 +1,460 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double4x3 : System.IEquatable<double4x3>, IFormattable
{
public double4 c0;
public double4 c1;
public double4 c2;
/// <summary>double4x3 zero value.</summary>
public static readonly double4x3 zero;
/// <summary>Constructs a double4x3 matrix from three double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(double4 c0, double4 c1, double4 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a double4x3 matrix from 12 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(double m00, double m01, double m02,
double m10, double m11, double m12,
double m20, double m21, double m22,
double m30, double m31, double m32)
{
this.c0 = new double4(m00, m10, m20, m30);
this.c1 = new double4(m01, m11, m21, m31);
this.c2 = new double4(m02, m12, m22, m32);
}
/// <summary>Constructs a double4x3 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double4x3 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(bool v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v);
this.c1 = math.select(new double4(0.0), new double4(1.0), v);
this.c2 = math.select(new double4(0.0), new double4(1.0), v);
}
/// <summary>Constructs a double4x3 matrix from a bool4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(bool4x3 v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
this.c2 = math.select(new double4(0.0), new double4(1.0), v.c2);
}
/// <summary>Constructs a double4x3 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double4x3 matrix from a int4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(int4x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double4x3 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double4x3 matrix from a uint4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(uint4x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a double4x3 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a double4x3 matrix from a float4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x3(float4x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Implicitly converts a single double value to a double4x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(double v) { return new double4x3(v); }
/// <summary>Explicitly converts a single bool value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x3(bool v) { return new double4x3(v); }
/// <summary>Explicitly converts a bool4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x3(bool4x3 v) { return new double4x3(v); }
/// <summary>Implicitly converts a single int value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(int v) { return new double4x3(v); }
/// <summary>Implicitly converts a int4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(int4x3 v) { return new double4x3(v); }
/// <summary>Implicitly converts a single uint value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(uint v) { return new double4x3(v); }
/// <summary>Implicitly converts a uint4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(uint4x3 v) { return new double4x3(v); }
/// <summary>Implicitly converts a single float value to a double4x3 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(float v) { return new double4x3(v); }
/// <summary>Implicitly converts a float4x3 matrix to a double4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x3(float4x3 v) { return new double4x3(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator * (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
/// <summary>Returns the result of a componentwise multiplication operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator * (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator * (double lhs, double4x3 rhs) { return new double4x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator + (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator + (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator + (double lhs, double4x3 rhs) { return new double4x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator - (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator - (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator - (double lhs, double4x3 rhs) { return new double4x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator / (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator / (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator / (double lhs, double4x3 rhs) { return new double4x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator % (double4x3 lhs, double4x3 rhs) { return new double4x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator % (double4x3 lhs, double rhs) { return new double4x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator % (double lhs, double4x3 rhs) { return new double4x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
/// <summary>Returns the result of a componentwise increment operation on a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator ++ (double4x3 val) { return new double4x3 (++val.c0, ++val.c1, ++val.c2); }
/// <summary>Returns the result of a componentwise decrement operation on a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator -- (double4x3 val) { return new double4x3 (--val.c0, --val.c1, --val.c2); }
/// <summary>Returns the result of a componentwise less than operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator < (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
/// <summary>Returns the result of a componentwise less than operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator < (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator < (double lhs, double4x3 rhs) { return new bool4x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator <= (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator <= (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator <= (double lhs, double4x3 rhs) { return new bool4x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator > (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator > (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator > (double lhs, double4x3 rhs) { return new bool4x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator >= (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator >= (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator >= (double lhs, double4x3 rhs) { return new bool4x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
/// <summary>Returns the result of a componentwise unary minus operation on a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator - (double4x3 val) { return new double4x3 (-val.c0, -val.c1, -val.c2); }
/// <summary>Returns the result of a componentwise unary plus operation on a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 operator + (double4x3 val) { return new double4x3 (+val.c0, +val.c1, +val.c2); }
/// <summary>Returns the result of a componentwise equality operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator == (double lhs, double4x3 rhs) { return new bool4x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two double4x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (double4x3 lhs, double4x3 rhs) { return new bool4x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a double4x3 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (double4x3 lhs, double rhs) { return new bool4x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x3 operator != (double lhs, double4x3 rhs) { return new bool4x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the double4 element at a specified index.</summary>
unsafe public ref double4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (double4x3* array = &this) { return ref ((double4*)array)[index]; }
}
}
/// <summary>Returns true if the double4x3 is equal to a given double4x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double4x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the double4x3 is equal to a given double4x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double4x3)o); }
/// <summary>Returns a hash code for the double4x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double4x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z, c0.w, c1.w, c2.w);
}
/// <summary>Returns a string representation of the double4x3 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double4x3({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double4x3 matrix constructed from three double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(double4 c0, double4 c1, double4 c2) { return new double4x3(c0, c1, c2); }
/// <summary>Returns a double4x3 matrix constructed from from 12 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(double m00, double m01, double m02,
double m10, double m11, double m12,
double m20, double m21, double m22,
double m30, double m31, double m32)
{
return new double4x3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22,
m30, m31, m32);
}
/// <summary>Returns a double4x3 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(double v) { return new double4x3(v); }
/// <summary>Returns a double4x3 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(bool v) { return new double4x3(v); }
/// <summary>Return a double4x3 matrix constructed from a bool4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(bool4x3 v) { return new double4x3(v); }
/// <summary>Returns a double4x3 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(int v) { return new double4x3(v); }
/// <summary>Return a double4x3 matrix constructed from a int4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(int4x3 v) { return new double4x3(v); }
/// <summary>Returns a double4x3 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(uint v) { return new double4x3(v); }
/// <summary>Return a double4x3 matrix constructed from a uint4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(uint4x3 v) { return new double4x3(v); }
/// <summary>Returns a double4x3 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(float v) { return new double4x3(v); }
/// <summary>Return a double4x3 matrix constructed from a float4x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x3 double4x3(float4x3 v) { return new double4x3(v); }
/// <summary>Return the double3x4 transpose of a double4x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3x4 transpose(double4x3 v)
{
return double3x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w,
v.c2.x, v.c2.y, v.c2.z, v.c2.w);
}
/// <summary>Returns a uint hash code of a double4x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double4x3 v)
{
return csum(fold_to_uint(v.c0) * uint4(0x7AA07CD3u, 0xAF642BA9u, 0xA8F2213Bu, 0x9F3FDC37u) +
fold_to_uint(v.c1) * uint4(0xAC60D0C3u, 0x9263662Fu, 0xE69626FFu, 0xBD010EEBu) +
fold_to_uint(v.c2) * uint4(0x9CEDE1D1u, 0x43BE0B51u, 0xAF836EE1u, 0xB130C137u)) + 0x54834775u;
}
/// <summary>
/// Returns a uint4 vector hash code of a double4x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(double4x3 v)
{
return (fold_to_uint(v.c0) * uint4(0x7C022221u, 0xA2D00EDFu, 0xA8977779u, 0x9F1C739Bu) +
fold_to_uint(v.c1) * uint4(0x4B1BD187u, 0x9DF50593u, 0xF18EEB85u, 0x9E19BFC3u) +
fold_to_uint(v.c2) * uint4(0x8196B06Fu, 0xD24EFA19u, 0x7D8048BBu, 0x713BD06Fu)) + 0x753AD6ADu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 673ff09d67f254e00a538d7bbb41618e
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

596
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x4.gen.cs Normal file
View file

@ -0,0 +1,596 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct double4x4 : System.IEquatable<double4x4>, IFormattable
{
public double4 c0;
public double4 c1;
public double4 c2;
public double4 c3;
/// <summary>double4x4 identity transform.</summary>
public static readonly double4x4 identity = new double4x4(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0);
/// <summary>double4x4 zero value.</summary>
public static readonly double4x4 zero;
/// <summary>Constructs a double4x4 matrix from four double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(double4 c0, double4 c1, double4 c2, double4 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a double4x4 matrix from 16 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23,
double m30, double m31, double m32, double m33)
{
this.c0 = new double4(m00, m10, m20, m30);
this.c1 = new double4(m01, m11, m21, m31);
this.c2 = new double4(m02, m12, m22, m32);
this.c3 = new double4(m03, m13, m23, m33);
}
/// <summary>Constructs a double4x4 matrix from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(double v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double4x4 matrix from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(bool v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v);
this.c1 = math.select(new double4(0.0), new double4(1.0), v);
this.c2 = math.select(new double4(0.0), new double4(1.0), v);
this.c3 = math.select(new double4(0.0), new double4(1.0), v);
}
/// <summary>Constructs a double4x4 matrix from a bool4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(bool4x4 v)
{
this.c0 = math.select(new double4(0.0), new double4(1.0), v.c0);
this.c1 = math.select(new double4(0.0), new double4(1.0), v.c1);
this.c2 = math.select(new double4(0.0), new double4(1.0), v.c2);
this.c3 = math.select(new double4(0.0), new double4(1.0), v.c3);
}
/// <summary>Constructs a double4x4 matrix from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double4x4 matrix from a int4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(int4x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double4x4 matrix from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double4x4 matrix from a uint4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(uint4x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a double4x4 matrix from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a double4x4 matrix from a float4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public double4x4(float4x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Implicitly converts a single double value to a double4x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(double v) { return new double4x4(v); }
/// <summary>Explicitly converts a single bool value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x4(bool v) { return new double4x4(v); }
/// <summary>Explicitly converts a bool4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator double4x4(bool4x4 v) { return new double4x4(v); }
/// <summary>Implicitly converts a single int value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(int v) { return new double4x4(v); }
/// <summary>Implicitly converts a int4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(int4x4 v) { return new double4x4(v); }
/// <summary>Implicitly converts a single uint value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(uint v) { return new double4x4(v); }
/// <summary>Implicitly converts a uint4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(uint4x4 v) { return new double4x4(v); }
/// <summary>Implicitly converts a single float value to a double4x4 matrix by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(float v) { return new double4x4(v); }
/// <summary>Implicitly converts a float4x4 matrix to a double4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator double4x4(float4x4 v) { return new double4x4(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator * (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
/// <summary>Returns the result of a componentwise multiplication operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator * (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator * (double lhs, double4x4 rhs) { return new double4x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator + (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator + (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator + (double lhs, double4x4 rhs) { return new double4x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator - (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator - (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator - (double lhs, double4x4 rhs) { return new double4x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator / (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator / (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator / (double lhs, double4x4 rhs) { return new double4x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator % (double4x4 lhs, double4x4 rhs) { return new double4x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator % (double4x4 lhs, double rhs) { return new double4x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator % (double lhs, double4x4 rhs) { return new double4x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
/// <summary>Returns the result of a componentwise increment operation on a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator ++ (double4x4 val) { return new double4x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
/// <summary>Returns the result of a componentwise decrement operation on a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator -- (double4x4 val) { return new double4x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
/// <summary>Returns the result of a componentwise less than operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator < (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
/// <summary>Returns the result of a componentwise less than operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator < (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator < (double lhs, double4x4 rhs) { return new bool4x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator <= (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator <= (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator <= (double lhs, double4x4 rhs) { return new bool4x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator > (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator > (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator > (double lhs, double4x4 rhs) { return new bool4x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator >= (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator >= (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator >= (double lhs, double4x4 rhs) { return new bool4x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
/// <summary>Returns the result of a componentwise unary minus operation on a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator - (double4x4 val) { return new double4x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
/// <summary>Returns the result of a componentwise unary plus operation on a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 operator + (double4x4 val) { return new double4x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
/// <summary>Returns the result of a componentwise equality operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator == (double lhs, double4x4 rhs) { return new bool4x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two double4x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (double4x4 lhs, double4x4 rhs) { return new bool4x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a double4x4 matrix and a double value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (double4x4 lhs, double rhs) { return new bool4x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a double value and a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool4x4 operator != (double lhs, double4x4 rhs) { return new bool4x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the double4 element at a specified index.</summary>
unsafe public ref double4 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (double4x4* array = &this) { return ref ((double4*)array)[index]; }
}
}
/// <summary>Returns true if the double4x4 is equal to a given double4x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(double4x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the double4x4 is equal to a given double4x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((double4x4)o); }
/// <summary>Returns a hash code for the double4x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the double4x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("double4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z, c0.w, c1.w, c2.w, c3.w);
}
/// <summary>Returns a string representation of the double4x4 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("double4x4({0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, {13}, {14}, {15})", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider), c0.w.ToString(format, formatProvider), c1.w.ToString(format, formatProvider), c2.w.ToString(format, formatProvider), c3.w.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a double4x4 matrix constructed from four double4 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(double4 c0, double4 c1, double4 c2, double4 c3) { return new double4x4(c0, c1, c2, c3); }
/// <summary>Returns a double4x4 matrix constructed from from 16 double values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(double m00, double m01, double m02, double m03,
double m10, double m11, double m12, double m13,
double m20, double m21, double m22, double m23,
double m30, double m31, double m32, double m33)
{
return new double4x4(m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23,
m30, m31, m32, m33);
}
/// <summary>Returns a double4x4 matrix constructed from a single double value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(double v) { return new double4x4(v); }
/// <summary>Returns a double4x4 matrix constructed from a single bool value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(bool v) { return new double4x4(v); }
/// <summary>Return a double4x4 matrix constructed from a bool4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(bool4x4 v) { return new double4x4(v); }
/// <summary>Returns a double4x4 matrix constructed from a single int value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(int v) { return new double4x4(v); }
/// <summary>Return a double4x4 matrix constructed from a int4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(int4x4 v) { return new double4x4(v); }
/// <summary>Returns a double4x4 matrix constructed from a single uint value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(uint v) { return new double4x4(v); }
/// <summary>Return a double4x4 matrix constructed from a uint4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(uint4x4 v) { return new double4x4(v); }
/// <summary>Returns a double4x4 matrix constructed from a single float value by converting it to double and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(float v) { return new double4x4(v); }
/// <summary>Return a double4x4 matrix constructed from a float4x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 double4x4(float4x4 v) { return new double4x4(v); }
/// <summary>Return the result of rotating a double3 vector by a double4x4 matrix</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3 rotate(double4x4 a, double3 b)
{
return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z).xyz;
}
/// <summary>Return the result of transforming a double3 point by a double4x4 matrix</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double3 transform(double4x4 a, double3 b)
{
return (a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3).xyz;
}
/// <summary>Return the double4x4 transpose of a double4x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static double4x4 transpose(double4x4 v)
{
return double4x4(
v.c0.x, v.c0.y, v.c0.z, v.c0.w,
v.c1.x, v.c1.y, v.c1.z, v.c1.w,
v.c2.x, v.c2.y, v.c2.z, v.c2.w,
v.c3.x, v.c3.y, v.c3.z, v.c3.w);
}
/// <summary>Returns the double4x4 full inverse of a double4x4 matrix.</summary>
public static double4x4 inverse(double4x4 m)
{
double4 c0 = m.c0;
double4 c1 = m.c1;
double4 c2 = m.c2;
double4 c3 = m.c3;
double4 r0y_r1y_r0x_r1x = movelh(c1, c0);
double4 r0z_r1z_r0w_r1w = movelh(c2, c3);
double4 r2y_r3y_r2x_r3x = movehl(c0, c1);
double4 r2z_r3z_r2w_r3w = movehl(c3, c2);
double4 r1y_r2y_r1x_r2x = shuffle(c1, c0, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
double4 r1z_r2z_r1w_r2w = shuffle(c2, c3, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightZ);
double4 r3y_r0y_r3x_r0x = shuffle(c1, c0, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
double4 r3z_r0z_r3w_r0w = shuffle(c2, c3, ShuffleComponent.LeftW, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightX);
double4 r0_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
double4 r1_wzyx = shuffle(r0z_r1z_r0w_r1w, r0y_r1y_r0x_r1x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
double4 r2_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
double4 r3_wzyx = shuffle(r2z_r3z_r2w_r3w, r2y_r3y_r2x_r3x, ShuffleComponent.LeftW, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightW);
double4 r0_xyzw = shuffle(r0y_r1y_r0x_r1x, r0z_r1z_r0w_r1w, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.RightX, ShuffleComponent.RightZ);
// Calculate remaining inner term pairs. inner terms have zw=-xy, so we only have to calculate xy and can pack two pairs per vector.
double4 inner12_23 = r1y_r2y_r1x_r2x * r2z_r3z_r2w_r3w - r1z_r2z_r1w_r2w * r2y_r3y_r2x_r3x;
double4 inner02_13 = r0y_r1y_r0x_r1x * r2z_r3z_r2w_r3w - r0z_r1z_r0w_r1w * r2y_r3y_r2x_r3x;
double4 inner30_01 = r3z_r0z_r3w_r0w * r0y_r1y_r0x_r1x - r3y_r0y_r3x_r0x * r0z_r1z_r0w_r1w;
// Expand inner terms back to 4 components. zw signs still need to be flipped
double4 inner12 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
double4 inner23 = shuffle(inner12_23, inner12_23, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
double4 inner02 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
double4 inner13 = shuffle(inner02_13, inner02_13, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
// Calculate minors
double4 minors0 = r3_wzyx * inner12 - r2_wzyx * inner13 + r1_wzyx * inner23;
double4 denom = r0_xyzw * minors0;
// Horizontal sum of denominator. Free sign flip of z and w compensates for missing flip in inner terms.
denom = denom + shuffle(denom, denom, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightW, ShuffleComponent.RightZ); // x+y x+y z+w z+w
denom = denom - shuffle(denom, denom, ShuffleComponent.LeftZ, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightX); // x+y-z-w x+y-z-w z+w-x-y z+w-x-y
double4 rcp_denom_ppnn = double4(1.0) / denom;
double4x4 res;
res.c0 = minors0 * rcp_denom_ppnn;
double4 inner30 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX);
double4 inner01 = shuffle(inner30_01, inner30_01, ShuffleComponent.LeftY, ShuffleComponent.LeftW, ShuffleComponent.RightW, ShuffleComponent.RightY);
double4 minors1 = r2_wzyx * inner30 - r0_wzyx * inner23 - r3_wzyx * inner02;
res.c1 = minors1 * rcp_denom_ppnn;
double4 minors2 = r0_wzyx * inner13 - r1_wzyx * inner30 - r3_wzyx * inner01;
res.c2 = minors2 * rcp_denom_ppnn;
double4 minors3 = r1_wzyx * inner02 - r0_wzyx * inner12 + r2_wzyx * inner01;
res.c3 = minors3 * rcp_denom_ppnn;
return res;
}
// Fast matrix inverse for rigid transforms (Orthonormal basis and translation)
public static double4x4 fastinverse(double4x4 m)
{
double4 c0 = m.c0;
double4 c1 = m.c1;
double4 c2 = m.c2;
double4 pos = m.c3;
double4 zero = double4(0);
double4 t0 = unpacklo(c0, c2);
double4 t1 = unpacklo(c1, zero);
double4 t2 = unpackhi(c0, c2);
double4 t3 = unpackhi(c1, zero);
double4 r0 = unpacklo(t0, t1);
double4 r1 = unpackhi(t0, t1);
double4 r2 = unpacklo(t2, t3);
pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
pos.w = 1.0f;
return double4x4(r0, r1, r2, pos);
}
/// <summary>Returns the determinant of a double4x4 matrix.</summary>
public static double determinant(double4x4 m)
{
double4 c0 = m.c0;
double4 c1 = m.c1;
double4 c2 = m.c2;
double4 c3 = m.c3;
double m00 = c1.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c1.z * c3.w - c1.w * c3.z) + c3.y * (c1.z * c2.w - c1.w * c2.z);
double m01 = c0.y * (c2.z * c3.w - c2.w * c3.z) - c2.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c2.w - c0.w * c2.z);
double m02 = c0.y * (c1.z * c3.w - c1.w * c3.z) - c1.y * (c0.z * c3.w - c0.w * c3.z) + c3.y * (c0.z * c1.w - c0.w * c1.z);
double m03 = c0.y * (c1.z * c2.w - c1.w * c2.z) - c1.y * (c0.z * c2.w - c0.w * c2.z) + c2.y * (c0.z * c1.w - c0.w * c1.z);
return c0.x * m00 - c1.x * m01 + c2.x * m02 - c3.x * m03;
}
/// <summary>Returns a uint hash code of a double4x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(double4x4 v)
{
return csum(fold_to_uint(v.c0) * uint4(0x4DDC6509u, 0x7CF083CBu, 0x5C4D6CEDu, 0xF9137117u) +
fold_to_uint(v.c1) * uint4(0xE857DCE1u, 0xF62213C5u, 0x9CDAA959u, 0xAA269ABFu) +
fold_to_uint(v.c2) * uint4(0xD54BA36Fu, 0xFD0847B9u, 0x8189A683u, 0xB139D651u) +
fold_to_uint(v.c3) * uint4(0xE7579997u, 0xEF7D56C7u, 0x66F38F0Bu, 0x624256A3u)) + 0x5292ADE1u;
}
/// <summary>
/// Returns a uint4 vector hash code of a double4x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint4 hashwide(double4x4 v)
{
return (fold_to_uint(v.c0) * uint4(0xD2E590E5u, 0xF25BE857u, 0x9BC17CE7u, 0xC8B86851u) +
fold_to_uint(v.c1) * uint4(0x64095221u, 0xADF428FFu, 0xA3977109u, 0x745ED837u) +
fold_to_uint(v.c2) * uint4(0x9CDC88F5u, 0xFA62D721u, 0x7E4DB1CFu, 0x68EEE0F5u) +
fold_to_uint(v.c3) * uint4(0xBC3B0A59u, 0x816EFB5Du, 0xA24E82B7u, 0x45A22087u)) + 0xFC104C3Bu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/double4x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e000b5ccaea0345d8b4686220f3307ed
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

760
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2.gen.cs Normal file
View file

@ -0,0 +1,760 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
using System.Diagnostics;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[DebuggerTypeProxy(typeof(float2.DebuggerProxy))]
[System.Serializable]
public partial struct float2 : System.IEquatable<float2>, IFormattable
{
public float x;
public float y;
/// <summary>float2 zero value.</summary>
public static readonly float2 zero;
/// <summary>Constructs a float2 vector from two float values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(float x, float y)
{
this.x = x;
this.y = y;
}
/// <summary>Constructs a float2 vector from a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(float2 xy)
{
this.x = xy.x;
this.y = xy.y;
}
/// <summary>Constructs a float2 vector from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(float v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a float2 vector from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(bool v)
{
this.x = v ? 1.0f : 0.0f;
this.y = v ? 1.0f : 0.0f;
}
/// <summary>Constructs a float2 vector from a bool2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(bool2 v)
{
this.x = v.x ? 1.0f : 0.0f;
this.y = v.y ? 1.0f : 0.0f;
}
/// <summary>Constructs a float2 vector from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(int v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a float2 vector from a int2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(int2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a float2 vector from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(uint v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a float2 vector from a uint2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(uint2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a float2 vector from a single half value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(half v)
{
this.x = v;
this.y = v;
}
/// <summary>Constructs a float2 vector from a half2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(half2 v)
{
this.x = v.x;
this.y = v.y;
}
/// <summary>Constructs a float2 vector from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(double v)
{
this.x = (float)v;
this.y = (float)v;
}
/// <summary>Constructs a float2 vector from a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2(double2 v)
{
this.x = (float)v.x;
this.y = (float)v.y;
}
/// <summary>Implicitly converts a single float value to a float2 vector by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(float v) { return new float2(v); }
/// <summary>Explicitly converts a single bool value to a float2 vector by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2(bool v) { return new float2(v); }
/// <summary>Explicitly converts a bool2 vector to a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2(bool2 v) { return new float2(v); }
/// <summary>Implicitly converts a single int value to a float2 vector by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(int v) { return new float2(v); }
/// <summary>Implicitly converts a int2 vector to a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(int2 v) { return new float2(v); }
/// <summary>Implicitly converts a single uint value to a float2 vector by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(uint v) { return new float2(v); }
/// <summary>Implicitly converts a uint2 vector to a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(uint2 v) { return new float2(v); }
/// <summary>Implicitly converts a single half value to a float2 vector by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(half v) { return new float2(v); }
/// <summary>Implicitly converts a half2 vector to a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2(half2 v) { return new float2(v); }
/// <summary>Explicitly converts a single double value to a float2 vector by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2(double v) { return new float2(v); }
/// <summary>Explicitly converts a double2 vector to a float2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2(double2 v) { return new float2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator * (float2 lhs, float2 rhs) { return new float2 (lhs.x * rhs.x, lhs.y * rhs.y); }
/// <summary>Returns the result of a componentwise multiplication operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator * (float2 lhs, float rhs) { return new float2 (lhs.x * rhs, lhs.y * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator * (float lhs, float2 rhs) { return new float2 (lhs * rhs.x, lhs * rhs.y); }
/// <summary>Returns the result of a componentwise addition operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator + (float2 lhs, float2 rhs) { return new float2 (lhs.x + rhs.x, lhs.y + rhs.y); }
/// <summary>Returns the result of a componentwise addition operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator + (float2 lhs, float rhs) { return new float2 (lhs.x + rhs, lhs.y + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator + (float lhs, float2 rhs) { return new float2 (lhs + rhs.x, lhs + rhs.y); }
/// <summary>Returns the result of a componentwise subtraction operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator - (float2 lhs, float2 rhs) { return new float2 (lhs.x - rhs.x, lhs.y - rhs.y); }
/// <summary>Returns the result of a componentwise subtraction operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator - (float2 lhs, float rhs) { return new float2 (lhs.x - rhs, lhs.y - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator - (float lhs, float2 rhs) { return new float2 (lhs - rhs.x, lhs - rhs.y); }
/// <summary>Returns the result of a componentwise division operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator / (float2 lhs, float2 rhs) { return new float2 (lhs.x / rhs.x, lhs.y / rhs.y); }
/// <summary>Returns the result of a componentwise division operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator / (float2 lhs, float rhs) { return new float2 (lhs.x / rhs, lhs.y / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator / (float lhs, float2 rhs) { return new float2 (lhs / rhs.x, lhs / rhs.y); }
/// <summary>Returns the result of a componentwise modulus operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator % (float2 lhs, float2 rhs) { return new float2 (lhs.x % rhs.x, lhs.y % rhs.y); }
/// <summary>Returns the result of a componentwise modulus operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator % (float2 lhs, float rhs) { return new float2 (lhs.x % rhs, lhs.y % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator % (float lhs, float2 rhs) { return new float2 (lhs % rhs.x, lhs % rhs.y); }
/// <summary>Returns the result of a componentwise increment operation on a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator ++ (float2 val) { return new float2 (++val.x, ++val.y); }
/// <summary>Returns the result of a componentwise decrement operation on a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator -- (float2 val) { return new float2 (--val.x, --val.y); }
/// <summary>Returns the result of a componentwise less than operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (float2 lhs, float2 rhs) { return new bool2 (lhs.x < rhs.x, lhs.y < rhs.y); }
/// <summary>Returns the result of a componentwise less than operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (float2 lhs, float rhs) { return new bool2 (lhs.x < rhs, lhs.y < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator < (float lhs, float2 rhs) { return new bool2 (lhs < rhs.x, lhs < rhs.y); }
/// <summary>Returns the result of a componentwise less or equal operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (float2 lhs, float2 rhs) { return new bool2 (lhs.x <= rhs.x, lhs.y <= rhs.y); }
/// <summary>Returns the result of a componentwise less or equal operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (float2 lhs, float rhs) { return new bool2 (lhs.x <= rhs, lhs.y <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator <= (float lhs, float2 rhs) { return new bool2 (lhs <= rhs.x, lhs <= rhs.y); }
/// <summary>Returns the result of a componentwise greater than operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (float2 lhs, float2 rhs) { return new bool2 (lhs.x > rhs.x, lhs.y > rhs.y); }
/// <summary>Returns the result of a componentwise greater than operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (float2 lhs, float rhs) { return new bool2 (lhs.x > rhs, lhs.y > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator > (float lhs, float2 rhs) { return new bool2 (lhs > rhs.x, lhs > rhs.y); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (float2 lhs, float2 rhs) { return new bool2 (lhs.x >= rhs.x, lhs.y >= rhs.y); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (float2 lhs, float rhs) { return new bool2 (lhs.x >= rhs, lhs.y >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator >= (float lhs, float2 rhs) { return new bool2 (lhs >= rhs.x, lhs >= rhs.y); }
/// <summary>Returns the result of a componentwise unary minus operation on a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator - (float2 val) { return new float2 (-val.x, -val.y); }
/// <summary>Returns the result of a componentwise unary plus operation on a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 operator + (float2 val) { return new float2 (+val.x, +val.y); }
/// <summary>Returns the result of a componentwise equality operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (float2 lhs, float2 rhs) { return new bool2 (lhs.x == rhs.x, lhs.y == rhs.y); }
/// <summary>Returns the result of a componentwise equality operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (float2 lhs, float rhs) { return new bool2 (lhs.x == rhs, lhs.y == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator == (float lhs, float2 rhs) { return new bool2 (lhs == rhs.x, lhs == rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (float2 lhs, float2 rhs) { return new bool2 (lhs.x != rhs.x, lhs.y != rhs.y); }
/// <summary>Returns the result of a componentwise not equal operation on a float2 vector and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (float2 lhs, float rhs) { return new bool2 (lhs.x != rhs, lhs.y != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2 operator != (float lhs, float2 rhs) { return new bool2 (lhs != rhs.x, lhs != rhs.y); }
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 xyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(x, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yxxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yxxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yxyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yxyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yyxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yyxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yyyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float4 yyyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float4(y, y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 xxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(x, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 xxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(x, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 xyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(x, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 xyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(x, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 yxx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(y, x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 yxy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(y, x, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 yyx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(y, y, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float3 yyy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float3(y, y, y); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float2 xx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float2(x, x); }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float2 xy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float2(x, y); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { x = value.x; y = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float2 yx
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float2(y, x); }
[MethodImpl(MethodImplOptions.AggressiveInlining)]
set { y = value.x; x = value.y; }
}
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
public float2 yy
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get { return new float2(y, y); }
}
/// <summary>Returns the float element at a specified index.</summary>
unsafe public float this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (float2* array = &this) { return ((float*)array)[index]; }
}
set
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (float* array = &x) { array[index] = value; }
}
}
/// <summary>Returns true if the float2 is equal to a given float2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float2 rhs) { return x == rhs.x && y == rhs.y; }
/// <summary>Returns true if the float2 is equal to a given float2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float2)o); }
/// <summary>Returns a hash code for the float2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float2({0}f, {1}f)", x, y);
}
/// <summary>Returns a string representation of the float2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float2({0}f, {1}f)", x.ToString(format, formatProvider), y.ToString(format, formatProvider));
}
internal sealed class DebuggerProxy
{
public float x;
public float y;
public DebuggerProxy(float2 v)
{
x = v.x;
y = v.y;
}
}
}
public static partial class math
{
/// <summary>Returns a float2 vector constructed from two float values.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(float x, float y) { return new float2(x, y); }
/// <summary>Returns a float2 vector constructed from a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(float2 xy) { return new float2(xy); }
/// <summary>Returns a float2 vector constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(float v) { return new float2(v); }
/// <summary>Returns a float2 vector constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(bool v) { return new float2(v); }
/// <summary>Return a float2 vector constructed from a bool2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(bool2 v) { return new float2(v); }
/// <summary>Returns a float2 vector constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(int v) { return new float2(v); }
/// <summary>Return a float2 vector constructed from a int2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(int2 v) { return new float2(v); }
/// <summary>Returns a float2 vector constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(uint v) { return new float2(v); }
/// <summary>Return a float2 vector constructed from a uint2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(uint2 v) { return new float2(v); }
/// <summary>Returns a float2 vector constructed from a single half value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(half v) { return new float2(v); }
/// <summary>Return a float2 vector constructed from a half2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(half2 v) { return new float2(v); }
/// <summary>Returns a float2 vector constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(double v) { return new float2(v); }
/// <summary>Return a float2 vector constructed from a double2 vector by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 float2(double2 v) { return new float2(v); }
/// <summary>Returns a uint hash code of a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float2 v)
{
return csum(asuint(v) * uint2(0xFA3A3285u, 0xAD55999Du)) + 0xDCDD5341u;
}
/// <summary>
/// Returns a uint2 vector hash code of a float2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(float2 v)
{
return (asuint(v) * uint2(0x94DDD769u, 0xA1E92D39u)) + 0x4583C801u;
}
/// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float shuffle(float2 a, float2 b, ShuffleComponent x)
{
return select_shuffle_component(a, b, x);
}
/// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2 shuffle(float2 a, float2 b, ShuffleComponent x, ShuffleComponent y)
{
return float2(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y));
}
/// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3 shuffle(float2 a, float2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z)
{
return float3(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z));
}
/// <summary>Returns the result of specified shuffling of the components from two float2 vectors into a float4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float4 shuffle(float2 a, float2 b, ShuffleComponent x, ShuffleComponent y, ShuffleComponent z, ShuffleComponent w)
{
return float4(
select_shuffle_component(a, b, x),
select_shuffle_component(a, b, y),
select_shuffle_component(a, b, z),
select_shuffle_component(a, b, w));
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static float select_shuffle_component(float2 a, float2 b, ShuffleComponent component)
{
switch(component)
{
case ShuffleComponent.LeftX:
return a.x;
case ShuffleComponent.LeftY:
return a.y;
case ShuffleComponent.RightX:
return b.x;
case ShuffleComponent.RightY:
return b.y;
default:
throw new System.ArgumentException("Invalid shuffle component: " + component);
}
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 4319f4482dc5b5b44a7f99c8725ef211
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

468
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs Normal file
View file

@ -0,0 +1,468 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float2x2 : System.IEquatable<float2x2>, IFormattable
{
public float2 c0;
public float2 c1;
/// <summary>float2x2 identity transform.</summary>
public static readonly float2x2 identity = new float2x2(1.0f, 0.0f, 0.0f, 1.0f);
/// <summary>float2x2 zero value.</summary>
public static readonly float2x2 zero;
/// <summary>Constructs a float2x2 matrix from two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(float2 c0, float2 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a float2x2 matrix from 4 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(float m00, float m01,
float m10, float m11)
{
this.c0 = new float2(m00, m10);
this.c1 = new float2(m01, m11);
}
/// <summary>Constructs a float2x2 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(float v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float2x2 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(bool v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v);
}
/// <summary>Constructs a float2x2 matrix from a bool2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(bool2x2 v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1);
}
/// <summary>Constructs a float2x2 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(int v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float2x2 matrix from a int2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(int2x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a float2x2 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float2x2 matrix from a uint2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(uint2x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a float2x2 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(double v)
{
this.c0 = (float2)v;
this.c1 = (float2)v;
}
/// <summary>Constructs a float2x2 matrix from a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x2(double2x2 v)
{
this.c0 = (float2)v.c0;
this.c1 = (float2)v.c1;
}
/// <summary>Implicitly converts a single float value to a float2x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x2(float v) { return new float2x2(v); }
/// <summary>Explicitly converts a single bool value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x2(bool v) { return new float2x2(v); }
/// <summary>Explicitly converts a bool2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x2(bool2x2 v) { return new float2x2(v); }
/// <summary>Implicitly converts a single int value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x2(int v) { return new float2x2(v); }
/// <summary>Implicitly converts a int2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x2(int2x2 v) { return new float2x2(v); }
/// <summary>Implicitly converts a single uint value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x2(uint v) { return new float2x2(v); }
/// <summary>Implicitly converts a uint2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x2(uint2x2 v) { return new float2x2(v); }
/// <summary>Explicitly converts a single double value to a float2x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x2(double v) { return new float2x2(v); }
/// <summary>Explicitly converts a double2x2 matrix to a float2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x2(double2x2 v) { return new float2x2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator * (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
/// <summary>Returns the result of a componentwise multiplication operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator * (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator * (float lhs, float2x2 rhs) { return new float2x2 (lhs * rhs.c0, lhs * rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator + (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator + (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator + (float lhs, float2x2 rhs) { return new float2x2 (lhs + rhs.c0, lhs + rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator - (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator - (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator - (float lhs, float2x2 rhs) { return new float2x2 (lhs - rhs.c0, lhs - rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator / (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator / (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator / (float lhs, float2x2 rhs) { return new float2x2 (lhs / rhs.c0, lhs / rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator % (float2x2 lhs, float2x2 rhs) { return new float2x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator % (float2x2 lhs, float rhs) { return new float2x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator % (float lhs, float2x2 rhs) { return new float2x2 (lhs % rhs.c0, lhs % rhs.c1); }
/// <summary>Returns the result of a componentwise increment operation on a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator ++ (float2x2 val) { return new float2x2 (++val.c0, ++val.c1); }
/// <summary>Returns the result of a componentwise decrement operation on a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator -- (float2x2 val) { return new float2x2 (--val.c0, --val.c1); }
/// <summary>Returns the result of a componentwise less than operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
/// <summary>Returns the result of a componentwise less than operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator < (float lhs, float2x2 rhs) { return new bool2x2 (lhs < rhs.c0, lhs < rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator <= (float lhs, float2x2 rhs) { return new bool2x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator > (float lhs, float2x2 rhs) { return new bool2x2 (lhs > rhs.c0, lhs > rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator >= (float lhs, float2x2 rhs) { return new bool2x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
/// <summary>Returns the result of a componentwise unary minus operation on a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator - (float2x2 val) { return new float2x2 (-val.c0, -val.c1); }
/// <summary>Returns the result of a componentwise unary plus operation on a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 operator + (float2x2 val) { return new float2x2 (+val.c0, +val.c1); }
/// <summary>Returns the result of a componentwise equality operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator == (float lhs, float2x2 rhs) { return new bool2x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two float2x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (float2x2 lhs, float2x2 rhs) { return new bool2x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a float2x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (float2x2 lhs, float rhs) { return new bool2x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x2 operator != (float lhs, float2x2 rhs) { return new bool2x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the float2 element at a specified index.</summary>
unsafe public ref float2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (float2x2* array = &this) { return ref ((float2*)array)[index]; }
}
}
/// <summary>Returns true if the float2x2 is equal to a given float2x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float2x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the float2x2 is equal to a given float2x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float2x2)o); }
/// <summary>Returns a hash code for the float2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float2x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float2x2({0}f, {1}f, {2}f, {3}f)", c0.x, c1.x, c0.y, c1.y);
}
/// <summary>Returns a string representation of the float2x2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float2x2({0}f, {1}f, {2}f, {3}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float2x2 matrix constructed from two float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(float2 c0, float2 c1) { return new float2x2(c0, c1); }
/// <summary>Returns a float2x2 matrix constructed from from 4 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(float m00, float m01,
float m10, float m11)
{
return new float2x2(m00, m01,
m10, m11);
}
/// <summary>Returns a float2x2 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(float v) { return new float2x2(v); }
/// <summary>Returns a float2x2 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(bool v) { return new float2x2(v); }
/// <summary>Return a float2x2 matrix constructed from a bool2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(bool2x2 v) { return new float2x2(v); }
/// <summary>Returns a float2x2 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(int v) { return new float2x2(v); }
/// <summary>Return a float2x2 matrix constructed from a int2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(int2x2 v) { return new float2x2(v); }
/// <summary>Returns a float2x2 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(uint v) { return new float2x2(v); }
/// <summary>Return a float2x2 matrix constructed from a uint2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(uint2x2 v) { return new float2x2(v); }
/// <summary>Returns a float2x2 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(double v) { return new float2x2(v); }
/// <summary>Return a float2x2 matrix constructed from a double2x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 float2x2(double2x2 v) { return new float2x2(v); }
/// <summary>Return the float2x2 transpose of a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 transpose(float2x2 v)
{
return float2x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y);
}
/// <summary>Returns the float2x2 full inverse of a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x2 inverse(float2x2 m)
{
float a = m.c0.x;
float b = m.c1.x;
float c = m.c0.y;
float d = m.c1.y;
float det = a * d - b * c;
return float2x2(d, -b, -c, a) * (1.0f / det);
}
/// <summary>Returns the determinant of a float2x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float determinant(float2x2 m)
{
float a = m.c0.x;
float b = m.c1.x;
float c = m.c0.y;
float d = m.c1.y;
return a * d - b * c;
}
/// <summary>Returns a uint hash code of a float2x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float2x2 v)
{
return csum(asuint(v.c0) * uint2(0x9C9F0823u, 0x5A9CA13Bu) +
asuint(v.c1) * uint2(0xAFCDD5EFu, 0xA88D187Du)) + 0xCF6EBA1Du;
}
/// <summary>
/// Returns a uint2 vector hash code of a float2x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(float2x2 v)
{
return (asuint(v.c0) * uint2(0x9D88E5A1u, 0xEADF0775u) +
asuint(v.c1) * uint2(0x747A9D7Bu, 0x4111F799u)) + 0xB5F05AF1u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 93080f7a13fd743e3aaaac6fee9f12b6
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

454
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs Normal file
View file

@ -0,0 +1,454 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float2x3 : System.IEquatable<float2x3>, IFormattable
{
public float2 c0;
public float2 c1;
public float2 c2;
/// <summary>float2x3 zero value.</summary>
public static readonly float2x3 zero;
/// <summary>Constructs a float2x3 matrix from three float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(float2 c0, float2 c1, float2 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a float2x3 matrix from 6 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(float m00, float m01, float m02,
float m10, float m11, float m12)
{
this.c0 = new float2(m00, m10);
this.c1 = new float2(m01, m11);
this.c2 = new float2(m02, m12);
}
/// <summary>Constructs a float2x3 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float2x3 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(bool v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c2 = math.select(new float2(0.0f), new float2(1.0f), v);
}
/// <summary>Constructs a float2x3 matrix from a bool2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(bool2x3 v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1);
this.c2 = math.select(new float2(0.0f), new float2(1.0f), v.c2);
}
/// <summary>Constructs a float2x3 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float2x3 matrix from a int2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(int2x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a float2x3 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float2x3 matrix from a uint2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(uint2x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a float2x3 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(double v)
{
this.c0 = (float2)v;
this.c1 = (float2)v;
this.c2 = (float2)v;
}
/// <summary>Constructs a float2x3 matrix from a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x3(double2x3 v)
{
this.c0 = (float2)v.c0;
this.c1 = (float2)v.c1;
this.c2 = (float2)v.c2;
}
/// <summary>Implicitly converts a single float value to a float2x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x3(float v) { return new float2x3(v); }
/// <summary>Explicitly converts a single bool value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x3(bool v) { return new float2x3(v); }
/// <summary>Explicitly converts a bool2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x3(bool2x3 v) { return new float2x3(v); }
/// <summary>Implicitly converts a single int value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x3(int v) { return new float2x3(v); }
/// <summary>Implicitly converts a int2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x3(int2x3 v) { return new float2x3(v); }
/// <summary>Implicitly converts a single uint value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x3(uint v) { return new float2x3(v); }
/// <summary>Implicitly converts a uint2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x3(uint2x3 v) { return new float2x3(v); }
/// <summary>Explicitly converts a single double value to a float2x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x3(double v) { return new float2x3(v); }
/// <summary>Explicitly converts a double2x3 matrix to a float2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x3(double2x3 v) { return new float2x3(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator * (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
/// <summary>Returns the result of a componentwise multiplication operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator * (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator * (float lhs, float2x3 rhs) { return new float2x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator + (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator + (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator + (float lhs, float2x3 rhs) { return new float2x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator - (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator - (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator - (float lhs, float2x3 rhs) { return new float2x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator / (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator / (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator / (float lhs, float2x3 rhs) { return new float2x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator % (float2x3 lhs, float2x3 rhs) { return new float2x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator % (float2x3 lhs, float rhs) { return new float2x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator % (float lhs, float2x3 rhs) { return new float2x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
/// <summary>Returns the result of a componentwise increment operation on a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator ++ (float2x3 val) { return new float2x3 (++val.c0, ++val.c1, ++val.c2); }
/// <summary>Returns the result of a componentwise decrement operation on a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator -- (float2x3 val) { return new float2x3 (--val.c0, --val.c1, --val.c2); }
/// <summary>Returns the result of a componentwise less than operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
/// <summary>Returns the result of a componentwise less than operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator < (float lhs, float2x3 rhs) { return new bool2x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator <= (float lhs, float2x3 rhs) { return new bool2x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator > (float lhs, float2x3 rhs) { return new bool2x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator >= (float lhs, float2x3 rhs) { return new bool2x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
/// <summary>Returns the result of a componentwise unary minus operation on a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator - (float2x3 val) { return new float2x3 (-val.c0, -val.c1, -val.c2); }
/// <summary>Returns the result of a componentwise unary plus operation on a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 operator + (float2x3 val) { return new float2x3 (+val.c0, +val.c1, +val.c2); }
/// <summary>Returns the result of a componentwise equality operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator == (float lhs, float2x3 rhs) { return new bool2x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two float2x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (float2x3 lhs, float2x3 rhs) { return new bool2x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a float2x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (float2x3 lhs, float rhs) { return new bool2x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x3 operator != (float lhs, float2x3 rhs) { return new bool2x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the float2 element at a specified index.</summary>
unsafe public ref float2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (float2x3* array = &this) { return ref ((float2*)array)[index]; }
}
}
/// <summary>Returns true if the float2x3 is equal to a given float2x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float2x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the float2x3 is equal to a given float2x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float2x3)o); }
/// <summary>Returns a hash code for the float2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float2x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float2x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y);
}
/// <summary>Returns a string representation of the float2x3 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float2x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float2x3 matrix constructed from three float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(float2 c0, float2 c1, float2 c2) { return new float2x3(c0, c1, c2); }
/// <summary>Returns a float2x3 matrix constructed from from 6 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(float m00, float m01, float m02,
float m10, float m11, float m12)
{
return new float2x3(m00, m01, m02,
m10, m11, m12);
}
/// <summary>Returns a float2x3 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(float v) { return new float2x3(v); }
/// <summary>Returns a float2x3 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(bool v) { return new float2x3(v); }
/// <summary>Return a float2x3 matrix constructed from a bool2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(bool2x3 v) { return new float2x3(v); }
/// <summary>Returns a float2x3 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(int v) { return new float2x3(v); }
/// <summary>Return a float2x3 matrix constructed from a int2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(int2x3 v) { return new float2x3(v); }
/// <summary>Returns a float2x3 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(uint v) { return new float2x3(v); }
/// <summary>Return a float2x3 matrix constructed from a uint2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(uint2x3 v) { return new float2x3(v); }
/// <summary>Returns a float2x3 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(double v) { return new float2x3(v); }
/// <summary>Return a float2x3 matrix constructed from a double2x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 float2x3(double2x3 v) { return new float2x3(v); }
/// <summary>Return the float3x2 transpose of a float2x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 transpose(float2x3 v)
{
return float3x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y);
}
/// <summary>Returns a uint hash code of a float2x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float2x3 v)
{
return csum(asuint(v.c0) * uint2(0xE857DCE1u, 0xF62213C5u) +
asuint(v.c1) * uint2(0x9CDAA959u, 0xAA269ABFu) +
asuint(v.c2) * uint2(0xD54BA36Fu, 0xFD0847B9u)) + 0x8189A683u;
}
/// <summary>
/// Returns a uint2 vector hash code of a float2x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(float2x3 v)
{
return (asuint(v.c0) * uint2(0xB139D651u, 0xE7579997u) +
asuint(v.c1) * uint2(0xEF7D56C7u, 0x66F38F0Bu) +
asuint(v.c2) * uint2(0x624256A3u, 0x5292ADE1u)) + 0xD2E590E5u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: f6047b8d8f85d4465b798320ea146853
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

469
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs Normal file
View file

@ -0,0 +1,469 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float2x4 : System.IEquatable<float2x4>, IFormattable
{
public float2 c0;
public float2 c1;
public float2 c2;
public float2 c3;
/// <summary>float2x4 zero value.</summary>
public static readonly float2x4 zero;
/// <summary>Constructs a float2x4 matrix from four float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(float2 c0, float2 c1, float2 c2, float2 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a float2x4 matrix from 8 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(float m00, float m01, float m02, float m03,
float m10, float m11, float m12, float m13)
{
this.c0 = new float2(m00, m10);
this.c1 = new float2(m01, m11);
this.c2 = new float2(m02, m12);
this.c3 = new float2(m03, m13);
}
/// <summary>Constructs a float2x4 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float2x4 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(bool v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c2 = math.select(new float2(0.0f), new float2(1.0f), v);
this.c3 = math.select(new float2(0.0f), new float2(1.0f), v);
}
/// <summary>Constructs a float2x4 matrix from a bool2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(bool2x4 v)
{
this.c0 = math.select(new float2(0.0f), new float2(1.0f), v.c0);
this.c1 = math.select(new float2(0.0f), new float2(1.0f), v.c1);
this.c2 = math.select(new float2(0.0f), new float2(1.0f), v.c2);
this.c3 = math.select(new float2(0.0f), new float2(1.0f), v.c3);
}
/// <summary>Constructs a float2x4 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float2x4 matrix from a int2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(int2x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a float2x4 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float2x4 matrix from a uint2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(uint2x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a float2x4 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(double v)
{
this.c0 = (float2)v;
this.c1 = (float2)v;
this.c2 = (float2)v;
this.c3 = (float2)v;
}
/// <summary>Constructs a float2x4 matrix from a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float2x4(double2x4 v)
{
this.c0 = (float2)v.c0;
this.c1 = (float2)v.c1;
this.c2 = (float2)v.c2;
this.c3 = (float2)v.c3;
}
/// <summary>Implicitly converts a single float value to a float2x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x4(float v) { return new float2x4(v); }
/// <summary>Explicitly converts a single bool value to a float2x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x4(bool v) { return new float2x4(v); }
/// <summary>Explicitly converts a bool2x4 matrix to a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x4(bool2x4 v) { return new float2x4(v); }
/// <summary>Implicitly converts a single int value to a float2x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x4(int v) { return new float2x4(v); }
/// <summary>Implicitly converts a int2x4 matrix to a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x4(int2x4 v) { return new float2x4(v); }
/// <summary>Implicitly converts a single uint value to a float2x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x4(uint v) { return new float2x4(v); }
/// <summary>Implicitly converts a uint2x4 matrix to a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float2x4(uint2x4 v) { return new float2x4(v); }
/// <summary>Explicitly converts a single double value to a float2x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x4(double v) { return new float2x4(v); }
/// <summary>Explicitly converts a double2x4 matrix to a float2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float2x4(double2x4 v) { return new float2x4(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator * (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
/// <summary>Returns the result of a componentwise multiplication operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator * (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator * (float lhs, float2x4 rhs) { return new float2x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator + (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator + (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator + (float lhs, float2x4 rhs) { return new float2x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator - (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator - (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator - (float lhs, float2x4 rhs) { return new float2x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator / (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator / (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator / (float lhs, float2x4 rhs) { return new float2x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator % (float2x4 lhs, float2x4 rhs) { return new float2x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator % (float2x4 lhs, float rhs) { return new float2x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator % (float lhs, float2x4 rhs) { return new float2x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
/// <summary>Returns the result of a componentwise increment operation on a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator ++ (float2x4 val) { return new float2x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
/// <summary>Returns the result of a componentwise decrement operation on a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator -- (float2x4 val) { return new float2x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
/// <summary>Returns the result of a componentwise less than operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
/// <summary>Returns the result of a componentwise less than operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator < (float lhs, float2x4 rhs) { return new bool2x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator <= (float lhs, float2x4 rhs) { return new bool2x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator > (float lhs, float2x4 rhs) { return new bool2x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator >= (float lhs, float2x4 rhs) { return new bool2x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
/// <summary>Returns the result of a componentwise unary minus operation on a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator - (float2x4 val) { return new float2x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
/// <summary>Returns the result of a componentwise unary plus operation on a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 operator + (float2x4 val) { return new float2x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
/// <summary>Returns the result of a componentwise equality operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator == (float lhs, float2x4 rhs) { return new bool2x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two float2x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (float2x4 lhs, float2x4 rhs) { return new bool2x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a float2x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (float2x4 lhs, float rhs) { return new bool2x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool2x4 operator != (float lhs, float2x4 rhs) { return new bool2x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the float2 element at a specified index.</summary>
unsafe public ref float2 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (float2x4* array = &this) { return ref ((float2*)array)[index]; }
}
}
/// <summary>Returns true if the float2x4 is equal to a given float2x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float2x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the float2x4 is equal to a given float2x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float2x4)o); }
/// <summary>Returns a hash code for the float2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float2x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float2x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y);
}
/// <summary>Returns a string representation of the float2x4 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float2x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float2x4 matrix constructed from four float2 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(float2 c0, float2 c1, float2 c2, float2 c3) { return new float2x4(c0, c1, c2, c3); }
/// <summary>Returns a float2x4 matrix constructed from from 8 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(float m00, float m01, float m02, float m03,
float m10, float m11, float m12, float m13)
{
return new float2x4(m00, m01, m02, m03,
m10, m11, m12, m13);
}
/// <summary>Returns a float2x4 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(float v) { return new float2x4(v); }
/// <summary>Returns a float2x4 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(bool v) { return new float2x4(v); }
/// <summary>Return a float2x4 matrix constructed from a bool2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(bool2x4 v) { return new float2x4(v); }
/// <summary>Returns a float2x4 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(int v) { return new float2x4(v); }
/// <summary>Return a float2x4 matrix constructed from a int2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(int2x4 v) { return new float2x4(v); }
/// <summary>Returns a float2x4 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(uint v) { return new float2x4(v); }
/// <summary>Return a float2x4 matrix constructed from a uint2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(uint2x4 v) { return new float2x4(v); }
/// <summary>Returns a float2x4 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(double v) { return new float2x4(v); }
/// <summary>Return a float2x4 matrix constructed from a double2x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x4 float2x4(double2x4 v) { return new float2x4(v); }
/// <summary>Return the float4x2 transpose of a float2x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float4x2 transpose(float2x4 v)
{
return float4x2(
v.c0.x, v.c0.y,
v.c1.x, v.c1.y,
v.c2.x, v.c2.y,
v.c3.x, v.c3.y);
}
/// <summary>Returns a uint hash code of a float2x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float2x4 v)
{
return csum(asuint(v.c0) * uint2(0xD35C9B2Du, 0xA10D9E27u) +
asuint(v.c1) * uint2(0x568DAAA9u, 0x7530254Fu) +
asuint(v.c2) * uint2(0x9F090439u, 0x5E9F85C9u) +
asuint(v.c3) * uint2(0x8C4CA03Fu, 0xB8D969EDu)) + 0xAC5DB57Bu;
}
/// <summary>
/// Returns a uint2 vector hash code of a float2x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint2 hashwide(float2x4 v)
{
return (asuint(v.c0) * uint2(0xA91A02EDu, 0xB3C49313u) +
asuint(v.c1) * uint2(0xF43A9ABBu, 0x84E7E01Bu) +
asuint(v.c2) * uint2(0x8E055BE5u, 0x6E624EB7u) +
asuint(v.c3) * uint2(0x7383ED49u, 0xDD49C23Bu)) + 0xEBD0D005u;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float2x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 70c2d51ac2a824bdb88b239c4fa6122c
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

1538
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6e8e5da9e769595428f8f1f51e642dd3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

442
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs Normal file
View file

@ -0,0 +1,442 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float3x2 : System.IEquatable<float3x2>, IFormattable
{
public float3 c0;
public float3 c1;
/// <summary>float3x2 zero value.</summary>
public static readonly float3x2 zero;
/// <summary>Constructs a float3x2 matrix from two float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(float3 c0, float3 c1)
{
this.c0 = c0;
this.c1 = c1;
}
/// <summary>Constructs a float3x2 matrix from 6 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(float m00, float m01,
float m10, float m11,
float m20, float m21)
{
this.c0 = new float3(m00, m10, m20);
this.c1 = new float3(m01, m11, m21);
}
/// <summary>Constructs a float3x2 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(float v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float3x2 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(bool v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v);
}
/// <summary>Constructs a float3x2 matrix from a bool3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(bool3x2 v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1);
}
/// <summary>Constructs a float3x2 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(int v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float3x2 matrix from a int3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(int3x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a float3x2 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(uint v)
{
this.c0 = v;
this.c1 = v;
}
/// <summary>Constructs a float3x2 matrix from a uint3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(uint3x2 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
}
/// <summary>Constructs a float3x2 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(double v)
{
this.c0 = (float3)v;
this.c1 = (float3)v;
}
/// <summary>Constructs a float3x2 matrix from a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x2(double3x2 v)
{
this.c0 = (float3)v.c0;
this.c1 = (float3)v.c1;
}
/// <summary>Implicitly converts a single float value to a float3x2 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x2(float v) { return new float3x2(v); }
/// <summary>Explicitly converts a single bool value to a float3x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x2(bool v) { return new float3x2(v); }
/// <summary>Explicitly converts a bool3x2 matrix to a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x2(bool3x2 v) { return new float3x2(v); }
/// <summary>Implicitly converts a single int value to a float3x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x2(int v) { return new float3x2(v); }
/// <summary>Implicitly converts a int3x2 matrix to a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x2(int3x2 v) { return new float3x2(v); }
/// <summary>Implicitly converts a single uint value to a float3x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x2(uint v) { return new float3x2(v); }
/// <summary>Implicitly converts a uint3x2 matrix to a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x2(uint3x2 v) { return new float3x2(v); }
/// <summary>Explicitly converts a single double value to a float3x2 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x2(double v) { return new float3x2(v); }
/// <summary>Explicitly converts a double3x2 matrix to a float3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x2(double3x2 v) { return new float3x2(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator * (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1); }
/// <summary>Returns the result of a componentwise multiplication operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator * (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 * rhs, lhs.c1 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator * (float lhs, float3x2 rhs) { return new float3x2 (lhs * rhs.c0, lhs * rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator + (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1); }
/// <summary>Returns the result of a componentwise addition operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator + (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 + rhs, lhs.c1 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator + (float lhs, float3x2 rhs) { return new float3x2 (lhs + rhs.c0, lhs + rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator - (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1); }
/// <summary>Returns the result of a componentwise subtraction operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator - (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 - rhs, lhs.c1 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator - (float lhs, float3x2 rhs) { return new float3x2 (lhs - rhs.c0, lhs - rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator / (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1); }
/// <summary>Returns the result of a componentwise division operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator / (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 / rhs, lhs.c1 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator / (float lhs, float3x2 rhs) { return new float3x2 (lhs / rhs.c0, lhs / rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator % (float3x2 lhs, float3x2 rhs) { return new float3x2 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1); }
/// <summary>Returns the result of a componentwise modulus operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator % (float3x2 lhs, float rhs) { return new float3x2 (lhs.c0 % rhs, lhs.c1 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator % (float lhs, float3x2 rhs) { return new float3x2 (lhs % rhs.c0, lhs % rhs.c1); }
/// <summary>Returns the result of a componentwise increment operation on a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator ++ (float3x2 val) { return new float3x2 (++val.c0, ++val.c1); }
/// <summary>Returns the result of a componentwise decrement operation on a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator -- (float3x2 val) { return new float3x2 (--val.c0, --val.c1); }
/// <summary>Returns the result of a componentwise less than operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1); }
/// <summary>Returns the result of a componentwise less than operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 < rhs, lhs.c1 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator < (float lhs, float3x2 rhs) { return new bool3x2 (lhs < rhs.c0, lhs < rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1); }
/// <summary>Returns the result of a componentwise less or equal operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 <= rhs, lhs.c1 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator <= (float lhs, float3x2 rhs) { return new bool3x2 (lhs <= rhs.c0, lhs <= rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1); }
/// <summary>Returns the result of a componentwise greater than operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 > rhs, lhs.c1 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator > (float lhs, float3x2 rhs) { return new bool3x2 (lhs > rhs.c0, lhs > rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 >= rhs, lhs.c1 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator >= (float lhs, float3x2 rhs) { return new bool3x2 (lhs >= rhs.c0, lhs >= rhs.c1); }
/// <summary>Returns the result of a componentwise unary minus operation on a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator - (float3x2 val) { return new float3x2 (-val.c0, -val.c1); }
/// <summary>Returns the result of a componentwise unary plus operation on a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 operator + (float3x2 val) { return new float3x2 (+val.c0, +val.c1); }
/// <summary>Returns the result of a componentwise equality operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1); }
/// <summary>Returns the result of a componentwise equality operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 == rhs, lhs.c1 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator == (float lhs, float3x2 rhs) { return new bool3x2 (lhs == rhs.c0, lhs == rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on two float3x2 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (float3x2 lhs, float3x2 rhs) { return new bool3x2 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1); }
/// <summary>Returns the result of a componentwise not equal operation on a float3x2 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (float3x2 lhs, float rhs) { return new bool3x2 (lhs.c0 != rhs, lhs.c1 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x2 operator != (float lhs, float3x2 rhs) { return new bool3x2 (lhs != rhs.c0, lhs != rhs.c1); }
/// <summary>Returns the float3 element at a specified index.</summary>
unsafe public ref float3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 2)
throw new System.ArgumentException("index must be between[0...1]");
#endif
fixed (float3x2* array = &this) { return ref ((float3*)array)[index]; }
}
}
/// <summary>Returns true if the float3x2 is equal to a given float3x2, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float3x2 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1); }
/// <summary>Returns true if the float3x2 is equal to a given float3x2, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float3x2)o); }
/// <summary>Returns a hash code for the float3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float3x2.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float3x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x, c1.x, c0.y, c1.y, c0.z, c1.z);
}
/// <summary>Returns a string representation of the float3x2 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float3x2({0}f, {1}f, {2}f, {3}f, {4}f, {5}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float3x2 matrix constructed from two float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(float3 c0, float3 c1) { return new float3x2(c0, c1); }
/// <summary>Returns a float3x2 matrix constructed from from 6 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(float m00, float m01,
float m10, float m11,
float m20, float m21)
{
return new float3x2(m00, m01,
m10, m11,
m20, m21);
}
/// <summary>Returns a float3x2 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(float v) { return new float3x2(v); }
/// <summary>Returns a float3x2 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(bool v) { return new float3x2(v); }
/// <summary>Return a float3x2 matrix constructed from a bool3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(bool3x2 v) { return new float3x2(v); }
/// <summary>Returns a float3x2 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(int v) { return new float3x2(v); }
/// <summary>Return a float3x2 matrix constructed from a int3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(int3x2 v) { return new float3x2(v); }
/// <summary>Returns a float3x2 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(uint v) { return new float3x2(v); }
/// <summary>Return a float3x2 matrix constructed from a uint3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(uint3x2 v) { return new float3x2(v); }
/// <summary>Returns a float3x2 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(double v) { return new float3x2(v); }
/// <summary>Return a float3x2 matrix constructed from a double3x2 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x2 float3x2(double3x2 v) { return new float3x2(v); }
/// <summary>Return the float2x3 transpose of a float3x2 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float2x3 transpose(float3x2 v)
{
return float2x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z);
}
/// <summary>Returns a uint hash code of a float3x2 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float3x2 v)
{
return csum(asuint(v.c0) * uint3(0xE121E6ADu, 0xC9CA1249u, 0x69B60C81u) +
asuint(v.c1) * uint3(0xE0EB6C25u, 0xF648BEABu, 0x6BDB2B07u)) + 0xEF63C699u;
}
/// <summary>
/// Returns a uint3 vector hash code of a float3x2 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(float3x2 v)
{
return (asuint(v.c0) * uint3(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u) +
asuint(v.c1) * uint3(0x4B01D3E1u, 0x7461CA0Du, 0x79725379u)) + 0xD6258E5Bu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x2.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: d20ff0b41ab5f4071b3d6ec3442fb2f7
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

494
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs Normal file
View file

@ -0,0 +1,494 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float3x3 : System.IEquatable<float3x3>, IFormattable
{
public float3 c0;
public float3 c1;
public float3 c2;
/// <summary>float3x3 identity transform.</summary>
public static readonly float3x3 identity = new float3x3(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
/// <summary>float3x3 zero value.</summary>
public static readonly float3x3 zero;
/// <summary>Constructs a float3x3 matrix from three float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(float3 c0, float3 c1, float3 c2)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
}
/// <summary>Constructs a float3x3 matrix from 9 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(float m00, float m01, float m02,
float m10, float m11, float m12,
float m20, float m21, float m22)
{
this.c0 = new float3(m00, m10, m20);
this.c1 = new float3(m01, m11, m21);
this.c2 = new float3(m02, m12, m22);
}
/// <summary>Constructs a float3x3 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float3x3 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(bool v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c2 = math.select(new float3(0.0f), new float3(1.0f), v);
}
/// <summary>Constructs a float3x3 matrix from a bool3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(bool3x3 v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1);
this.c2 = math.select(new float3(0.0f), new float3(1.0f), v.c2);
}
/// <summary>Constructs a float3x3 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float3x3 matrix from a int3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(int3x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a float3x3 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
}
/// <summary>Constructs a float3x3 matrix from a uint3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(uint3x3 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
}
/// <summary>Constructs a float3x3 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(double v)
{
this.c0 = (float3)v;
this.c1 = (float3)v;
this.c2 = (float3)v;
}
/// <summary>Constructs a float3x3 matrix from a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x3(double3x3 v)
{
this.c0 = (float3)v.c0;
this.c1 = (float3)v.c1;
this.c2 = (float3)v.c2;
}
/// <summary>Implicitly converts a single float value to a float3x3 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x3(float v) { return new float3x3(v); }
/// <summary>Explicitly converts a single bool value to a float3x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x3(bool v) { return new float3x3(v); }
/// <summary>Explicitly converts a bool3x3 matrix to a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x3(bool3x3 v) { return new float3x3(v); }
/// <summary>Implicitly converts a single int value to a float3x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x3(int v) { return new float3x3(v); }
/// <summary>Implicitly converts a int3x3 matrix to a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x3(int3x3 v) { return new float3x3(v); }
/// <summary>Implicitly converts a single uint value to a float3x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x3(uint v) { return new float3x3(v); }
/// <summary>Implicitly converts a uint3x3 matrix to a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x3(uint3x3 v) { return new float3x3(v); }
/// <summary>Explicitly converts a single double value to a float3x3 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x3(double v) { return new float3x3(v); }
/// <summary>Explicitly converts a double3x3 matrix to a float3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x3(double3x3 v) { return new float3x3(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator * (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2); }
/// <summary>Returns the result of a componentwise multiplication operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator * (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator * (float lhs, float3x3 rhs) { return new float3x3 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator + (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2); }
/// <summary>Returns the result of a componentwise addition operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator + (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator + (float lhs, float3x3 rhs) { return new float3x3 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator - (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2); }
/// <summary>Returns the result of a componentwise subtraction operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator - (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator - (float lhs, float3x3 rhs) { return new float3x3 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator / (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2); }
/// <summary>Returns the result of a componentwise division operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator / (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator / (float lhs, float3x3 rhs) { return new float3x3 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator % (float3x3 lhs, float3x3 rhs) { return new float3x3 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2); }
/// <summary>Returns the result of a componentwise modulus operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator % (float3x3 lhs, float rhs) { return new float3x3 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator % (float lhs, float3x3 rhs) { return new float3x3 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2); }
/// <summary>Returns the result of a componentwise increment operation on a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator ++ (float3x3 val) { return new float3x3 (++val.c0, ++val.c1, ++val.c2); }
/// <summary>Returns the result of a componentwise decrement operation on a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator -- (float3x3 val) { return new float3x3 (--val.c0, --val.c1, --val.c2); }
/// <summary>Returns the result of a componentwise less than operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2); }
/// <summary>Returns the result of a componentwise less than operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator < (float lhs, float3x3 rhs) { return new bool3x3 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2); }
/// <summary>Returns the result of a componentwise less or equal operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator <= (float lhs, float3x3 rhs) { return new bool3x3 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2); }
/// <summary>Returns the result of a componentwise greater than operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator > (float lhs, float3x3 rhs) { return new bool3x3 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator >= (float lhs, float3x3 rhs) { return new bool3x3 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2); }
/// <summary>Returns the result of a componentwise unary minus operation on a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator - (float3x3 val) { return new float3x3 (-val.c0, -val.c1, -val.c2); }
/// <summary>Returns the result of a componentwise unary plus operation on a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 operator + (float3x3 val) { return new float3x3 (+val.c0, +val.c1, +val.c2); }
/// <summary>Returns the result of a componentwise equality operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2); }
/// <summary>Returns the result of a componentwise equality operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator == (float lhs, float3x3 rhs) { return new bool3x3 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on two float3x3 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (float3x3 lhs, float3x3 rhs) { return new bool3x3 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2); }
/// <summary>Returns the result of a componentwise not equal operation on a float3x3 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (float3x3 lhs, float rhs) { return new bool3x3 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x3 operator != (float lhs, float3x3 rhs) { return new bool3x3 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2); }
/// <summary>Returns the float3 element at a specified index.</summary>
unsafe public ref float3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 3)
throw new System.ArgumentException("index must be between[0...2]");
#endif
fixed (float3x3* array = &this) { return ref ((float3*)array)[index]; }
}
}
/// <summary>Returns true if the float3x3 is equal to a given float3x3, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float3x3 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2); }
/// <summary>Returns true if the float3x3 is equal to a given float3x3, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float3x3)o); }
/// <summary>Returns a hash code for the float3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float3x3.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float3x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f)", c0.x, c1.x, c2.x, c0.y, c1.y, c2.y, c0.z, c1.z, c2.z);
}
/// <summary>Returns a string representation of the float3x3 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float3x3({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float3x3 matrix constructed from three float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(float3 c0, float3 c1, float3 c2) { return new float3x3(c0, c1, c2); }
/// <summary>Returns a float3x3 matrix constructed from from 9 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(float m00, float m01, float m02,
float m10, float m11, float m12,
float m20, float m21, float m22)
{
return new float3x3(m00, m01, m02,
m10, m11, m12,
m20, m21, m22);
}
/// <summary>Returns a float3x3 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(float v) { return new float3x3(v); }
/// <summary>Returns a float3x3 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(bool v) { return new float3x3(v); }
/// <summary>Return a float3x3 matrix constructed from a bool3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(bool3x3 v) { return new float3x3(v); }
/// <summary>Returns a float3x3 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(int v) { return new float3x3(v); }
/// <summary>Return a float3x3 matrix constructed from a int3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(int3x3 v) { return new float3x3(v); }
/// <summary>Returns a float3x3 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(uint v) { return new float3x3(v); }
/// <summary>Return a float3x3 matrix constructed from a uint3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(uint3x3 v) { return new float3x3(v); }
/// <summary>Returns a float3x3 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(double v) { return new float3x3(v); }
/// <summary>Return a float3x3 matrix constructed from a double3x3 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 float3x3(double3x3 v) { return new float3x3(v); }
/// <summary>Return the float3x3 transpose of a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x3 transpose(float3x3 v)
{
return float3x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z);
}
/// <summary>Returns the float3x3 full inverse of a float3x3 matrix.</summary>
public static float3x3 inverse(float3x3 m)
{
float3 c0 = m.c0;
float3 c1 = m.c1;
float3 c2 = m.c2;
float3 t0 = float3(c1.x, c2.x, c0.x);
float3 t1 = float3(c1.y, c2.y, c0.y);
float3 t2 = float3(c1.z, c2.z, c0.z);
float3 m0 = t1 * t2.yzx - t1.yzx * t2;
float3 m1 = t0.yzx * t2 - t0 * t2.yzx;
float3 m2 = t0 * t1.yzx - t0.yzx * t1;
float rcpDet = 1.0f / csum(t0.zxy * m0);
return float3x3(m0, m1, m2) * rcpDet;
}
/// <summary>Returns the determinant of a float3x3 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float determinant(float3x3 m)
{
float3 c0 = m.c0;
float3 c1 = m.c1;
float3 c2 = m.c2;
float m00 = c1.y * c2.z - c1.z * c2.y;
float m01 = c0.y * c2.z - c0.z * c2.y;
float m02 = c0.y * c1.z - c0.z * c1.y;
return c0.x * m00 - c1.x * m01 + c2.x * m02;
}
/// <summary>Returns a uint hash code of a float3x3 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float3x3 v)
{
return csum(asuint(v.c0) * uint3(0x713BD06Fu, 0x753AD6ADu, 0xD19764C7u) +
asuint(v.c1) * uint3(0xB5D0BF63u, 0xF9102C5Fu, 0x9881FB9Fu) +
asuint(v.c2) * uint3(0x56A1530Du, 0x804B722Du, 0x738E50E5u)) + 0x4FC93C25u;
}
/// <summary>
/// Returns a uint3 vector hash code of a float3x3 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(float3x3 v)
{
return (asuint(v.c0) * uint3(0xCD0445A5u, 0xD2B90D9Bu, 0xD35C9B2Du) +
asuint(v.c1) * uint3(0xA10D9E27u, 0x568DAAA9u, 0x7530254Fu) +
asuint(v.c2) * uint3(0x9F090439u, 0x5E9F85C9u, 0x8C4CA03Fu)) + 0xB8D969EDu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x3.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3ad77e7310a1e44499f09a51a558bb01
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

489
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs Normal file
View file

@ -0,0 +1,489 @@
//------------------------------------------------------------------------------
// <auto-generated>
// This code was generated by a tool.
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
#pragma warning disable 0660, 0661
namespace Unity.Mathematics
{
[System.Serializable]
public partial struct float3x4 : System.IEquatable<float3x4>, IFormattable
{
public float3 c0;
public float3 c1;
public float3 c2;
public float3 c3;
/// <summary>float3x4 zero value.</summary>
public static readonly float3x4 zero;
/// <summary>Constructs a float3x4 matrix from four float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(float3 c0, float3 c1, float3 c2, float3 c3)
{
this.c0 = c0;
this.c1 = c1;
this.c2 = c2;
this.c3 = c3;
}
/// <summary>Constructs a float3x4 matrix from 12 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(float m00, float m01, float m02, float m03,
float m10, float m11, float m12, float m13,
float m20, float m21, float m22, float m23)
{
this.c0 = new float3(m00, m10, m20);
this.c1 = new float3(m01, m11, m21);
this.c2 = new float3(m02, m12, m22);
this.c3 = new float3(m03, m13, m23);
}
/// <summary>Constructs a float3x4 matrix from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(float v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float3x4 matrix from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(bool v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c2 = math.select(new float3(0.0f), new float3(1.0f), v);
this.c3 = math.select(new float3(0.0f), new float3(1.0f), v);
}
/// <summary>Constructs a float3x4 matrix from a bool3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(bool3x4 v)
{
this.c0 = math.select(new float3(0.0f), new float3(1.0f), v.c0);
this.c1 = math.select(new float3(0.0f), new float3(1.0f), v.c1);
this.c2 = math.select(new float3(0.0f), new float3(1.0f), v.c2);
this.c3 = math.select(new float3(0.0f), new float3(1.0f), v.c3);
}
/// <summary>Constructs a float3x4 matrix from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(int v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float3x4 matrix from a int3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(int3x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a float3x4 matrix from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(uint v)
{
this.c0 = v;
this.c1 = v;
this.c2 = v;
this.c3 = v;
}
/// <summary>Constructs a float3x4 matrix from a uint3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(uint3x4 v)
{
this.c0 = v.c0;
this.c1 = v.c1;
this.c2 = v.c2;
this.c3 = v.c3;
}
/// <summary>Constructs a float3x4 matrix from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(double v)
{
this.c0 = (float3)v;
this.c1 = (float3)v;
this.c2 = (float3)v;
this.c3 = (float3)v;
}
/// <summary>Constructs a float3x4 matrix from a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public float3x4(double3x4 v)
{
this.c0 = (float3)v.c0;
this.c1 = (float3)v.c1;
this.c2 = (float3)v.c2;
this.c3 = (float3)v.c3;
}
/// <summary>Implicitly converts a single float value to a float3x4 matrix by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x4(float v) { return new float3x4(v); }
/// <summary>Explicitly converts a single bool value to a float3x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x4(bool v) { return new float3x4(v); }
/// <summary>Explicitly converts a bool3x4 matrix to a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x4(bool3x4 v) { return new float3x4(v); }
/// <summary>Implicitly converts a single int value to a float3x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x4(int v) { return new float3x4(v); }
/// <summary>Implicitly converts a int3x4 matrix to a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x4(int3x4 v) { return new float3x4(v); }
/// <summary>Implicitly converts a single uint value to a float3x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x4(uint v) { return new float3x4(v); }
/// <summary>Implicitly converts a uint3x4 matrix to a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static implicit operator float3x4(uint3x4 v) { return new float3x4(v); }
/// <summary>Explicitly converts a single double value to a float3x4 matrix by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x4(double v) { return new float3x4(v); }
/// <summary>Explicitly converts a double3x4 matrix to a float3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static explicit operator float3x4(double3x4 v) { return new float3x4(v); }
/// <summary>Returns the result of a componentwise multiplication operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator * (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 * rhs.c0, lhs.c1 * rhs.c1, lhs.c2 * rhs.c2, lhs.c3 * rhs.c3); }
/// <summary>Returns the result of a componentwise multiplication operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator * (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 * rhs, lhs.c1 * rhs, lhs.c2 * rhs, lhs.c3 * rhs); }
/// <summary>Returns the result of a componentwise multiplication operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator * (float lhs, float3x4 rhs) { return new float3x4 (lhs * rhs.c0, lhs * rhs.c1, lhs * rhs.c2, lhs * rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator + (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 + rhs.c0, lhs.c1 + rhs.c1, lhs.c2 + rhs.c2, lhs.c3 + rhs.c3); }
/// <summary>Returns the result of a componentwise addition operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator + (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 + rhs, lhs.c1 + rhs, lhs.c2 + rhs, lhs.c3 + rhs); }
/// <summary>Returns the result of a componentwise addition operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator + (float lhs, float3x4 rhs) { return new float3x4 (lhs + rhs.c0, lhs + rhs.c1, lhs + rhs.c2, lhs + rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator - (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 - rhs.c0, lhs.c1 - rhs.c1, lhs.c2 - rhs.c2, lhs.c3 - rhs.c3); }
/// <summary>Returns the result of a componentwise subtraction operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator - (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 - rhs, lhs.c1 - rhs, lhs.c2 - rhs, lhs.c3 - rhs); }
/// <summary>Returns the result of a componentwise subtraction operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator - (float lhs, float3x4 rhs) { return new float3x4 (lhs - rhs.c0, lhs - rhs.c1, lhs - rhs.c2, lhs - rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator / (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 / rhs.c0, lhs.c1 / rhs.c1, lhs.c2 / rhs.c2, lhs.c3 / rhs.c3); }
/// <summary>Returns the result of a componentwise division operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator / (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 / rhs, lhs.c1 / rhs, lhs.c2 / rhs, lhs.c3 / rhs); }
/// <summary>Returns the result of a componentwise division operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator / (float lhs, float3x4 rhs) { return new float3x4 (lhs / rhs.c0, lhs / rhs.c1, lhs / rhs.c2, lhs / rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator % (float3x4 lhs, float3x4 rhs) { return new float3x4 (lhs.c0 % rhs.c0, lhs.c1 % rhs.c1, lhs.c2 % rhs.c2, lhs.c3 % rhs.c3); }
/// <summary>Returns the result of a componentwise modulus operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator % (float3x4 lhs, float rhs) { return new float3x4 (lhs.c0 % rhs, lhs.c1 % rhs, lhs.c2 % rhs, lhs.c3 % rhs); }
/// <summary>Returns the result of a componentwise modulus operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator % (float lhs, float3x4 rhs) { return new float3x4 (lhs % rhs.c0, lhs % rhs.c1, lhs % rhs.c2, lhs % rhs.c3); }
/// <summary>Returns the result of a componentwise increment operation on a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator ++ (float3x4 val) { return new float3x4 (++val.c0, ++val.c1, ++val.c2, ++val.c3); }
/// <summary>Returns the result of a componentwise decrement operation on a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator -- (float3x4 val) { return new float3x4 (--val.c0, --val.c1, --val.c2, --val.c3); }
/// <summary>Returns the result of a componentwise less than operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 < rhs.c0, lhs.c1 < rhs.c1, lhs.c2 < rhs.c2, lhs.c3 < rhs.c3); }
/// <summary>Returns the result of a componentwise less than operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 < rhs, lhs.c1 < rhs, lhs.c2 < rhs, lhs.c3 < rhs); }
/// <summary>Returns the result of a componentwise less than operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator < (float lhs, float3x4 rhs) { return new bool3x4 (lhs < rhs.c0, lhs < rhs.c1, lhs < rhs.c2, lhs < rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 <= rhs.c0, lhs.c1 <= rhs.c1, lhs.c2 <= rhs.c2, lhs.c3 <= rhs.c3); }
/// <summary>Returns the result of a componentwise less or equal operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 <= rhs, lhs.c1 <= rhs, lhs.c2 <= rhs, lhs.c3 <= rhs); }
/// <summary>Returns the result of a componentwise less or equal operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator <= (float lhs, float3x4 rhs) { return new bool3x4 (lhs <= rhs.c0, lhs <= rhs.c1, lhs <= rhs.c2, lhs <= rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 > rhs.c0, lhs.c1 > rhs.c1, lhs.c2 > rhs.c2, lhs.c3 > rhs.c3); }
/// <summary>Returns the result of a componentwise greater than operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 > rhs, lhs.c1 > rhs, lhs.c2 > rhs, lhs.c3 > rhs); }
/// <summary>Returns the result of a componentwise greater than operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator > (float lhs, float3x4 rhs) { return new bool3x4 (lhs > rhs.c0, lhs > rhs.c1, lhs > rhs.c2, lhs > rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 >= rhs.c0, lhs.c1 >= rhs.c1, lhs.c2 >= rhs.c2, lhs.c3 >= rhs.c3); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 >= rhs, lhs.c1 >= rhs, lhs.c2 >= rhs, lhs.c3 >= rhs); }
/// <summary>Returns the result of a componentwise greater or equal operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator >= (float lhs, float3x4 rhs) { return new bool3x4 (lhs >= rhs.c0, lhs >= rhs.c1, lhs >= rhs.c2, lhs >= rhs.c3); }
/// <summary>Returns the result of a componentwise unary minus operation on a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator - (float3x4 val) { return new float3x4 (-val.c0, -val.c1, -val.c2, -val.c3); }
/// <summary>Returns the result of a componentwise unary plus operation on a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 operator + (float3x4 val) { return new float3x4 (+val.c0, +val.c1, +val.c2, +val.c3); }
/// <summary>Returns the result of a componentwise equality operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 == rhs.c0, lhs.c1 == rhs.c1, lhs.c2 == rhs.c2, lhs.c3 == rhs.c3); }
/// <summary>Returns the result of a componentwise equality operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 == rhs, lhs.c1 == rhs, lhs.c2 == rhs, lhs.c3 == rhs); }
/// <summary>Returns the result of a componentwise equality operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator == (float lhs, float3x4 rhs) { return new bool3x4 (lhs == rhs.c0, lhs == rhs.c1, lhs == rhs.c2, lhs == rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on two float3x4 matrices.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (float3x4 lhs, float3x4 rhs) { return new bool3x4 (lhs.c0 != rhs.c0, lhs.c1 != rhs.c1, lhs.c2 != rhs.c2, lhs.c3 != rhs.c3); }
/// <summary>Returns the result of a componentwise not equal operation on a float3x4 matrix and a float value.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (float3x4 lhs, float rhs) { return new bool3x4 (lhs.c0 != rhs, lhs.c1 != rhs, lhs.c2 != rhs, lhs.c3 != rhs); }
/// <summary>Returns the result of a componentwise not equal operation on a float value and a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool3x4 operator != (float lhs, float3x4 rhs) { return new bool3x4 (lhs != rhs.c0, lhs != rhs.c1, lhs != rhs.c2, lhs != rhs.c3); }
/// <summary>Returns the float3 element at a specified index.</summary>
unsafe public ref float3 this[int index]
{
get
{
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((uint)index >= 4)
throw new System.ArgumentException("index must be between[0...3]");
#endif
fixed (float3x4* array = &this) { return ref ((float3*)array)[index]; }
}
}
/// <summary>Returns true if the float3x4 is equal to a given float3x4, false otherwise.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public bool Equals(float3x4 rhs) { return c0.Equals(rhs.c0) && c1.Equals(rhs.c1) && c2.Equals(rhs.c2) && c3.Equals(rhs.c3); }
/// <summary>Returns true if the float3x4 is equal to a given float3x4, false otherwise.</summary>
public override bool Equals(object o) { return Equals((float3x4)o); }
/// <summary>Returns a hash code for the float3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override int GetHashCode() { return (int)math.hash(this); }
/// <summary>Returns a string representation of the float3x4.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString()
{
return string.Format("float3x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x, c1.x, c2.x, c3.x, c0.y, c1.y, c2.y, c3.y, c0.z, c1.z, c2.z, c3.z);
}
/// <summary>Returns a string representation of the float3x4 using a specified format and culture-specific format information.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public string ToString(string format, IFormatProvider formatProvider)
{
return string.Format("float3x4({0}f, {1}f, {2}f, {3}f, {4}f, {5}f, {6}f, {7}f, {8}f, {9}f, {10}f, {11}f)", c0.x.ToString(format, formatProvider), c1.x.ToString(format, formatProvider), c2.x.ToString(format, formatProvider), c3.x.ToString(format, formatProvider), c0.y.ToString(format, formatProvider), c1.y.ToString(format, formatProvider), c2.y.ToString(format, formatProvider), c3.y.ToString(format, formatProvider), c0.z.ToString(format, formatProvider), c1.z.ToString(format, formatProvider), c2.z.ToString(format, formatProvider), c3.z.ToString(format, formatProvider));
}
}
public static partial class math
{
/// <summary>Returns a float3x4 matrix constructed from four float3 vectors.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(float3 c0, float3 c1, float3 c2, float3 c3) { return new float3x4(c0, c1, c2, c3); }
/// <summary>Returns a float3x4 matrix constructed from from 12 float values given in row-major order.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(float m00, float m01, float m02, float m03,
float m10, float m11, float m12, float m13,
float m20, float m21, float m22, float m23)
{
return new float3x4(m00, m01, m02, m03,
m10, m11, m12, m13,
m20, m21, m22, m23);
}
/// <summary>Returns a float3x4 matrix constructed from a single float value by assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(float v) { return new float3x4(v); }
/// <summary>Returns a float3x4 matrix constructed from a single bool value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(bool v) { return new float3x4(v); }
/// <summary>Return a float3x4 matrix constructed from a bool3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(bool3x4 v) { return new float3x4(v); }
/// <summary>Returns a float3x4 matrix constructed from a single int value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(int v) { return new float3x4(v); }
/// <summary>Return a float3x4 matrix constructed from a int3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(int3x4 v) { return new float3x4(v); }
/// <summary>Returns a float3x4 matrix constructed from a single uint value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(uint v) { return new float3x4(v); }
/// <summary>Return a float3x4 matrix constructed from a uint3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(uint3x4 v) { return new float3x4(v); }
/// <summary>Returns a float3x4 matrix constructed from a single double value by converting it to float and assigning it to every component.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(double v) { return new float3x4(v); }
/// <summary>Return a float3x4 matrix constructed from a double3x4 matrix by componentwise conversion.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float3x4 float3x4(double3x4 v) { return new float3x4(v); }
/// <summary>Return the float4x3 transpose of a float3x4 matrix.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static float4x3 transpose(float3x4 v)
{
return float4x3(
v.c0.x, v.c0.y, v.c0.z,
v.c1.x, v.c1.y, v.c1.z,
v.c2.x, v.c2.y, v.c2.z,
v.c3.x, v.c3.y, v.c3.z);
}
// Fast matrix inverse for rigid transforms (Orthonormal basis and translation)
public static float3x4 fastinverse(float3x4 m)
{
float3 c0 = m.c0;
float3 c1 = m.c1;
float3 c2 = m.c2;
float3 pos = m.c3;
float3 r0 = float3(c0.x, c1.x, c2.x);
float3 r1 = float3(c0.y, c1.y, c2.y);
float3 r2 = float3(c0.z, c1.z, c2.z);
pos = -(r0 * pos.x + r1 * pos.y + r2 * pos.z);
return float3x4(r0, r1, r2, pos);
}
/// <summary>Returns a uint hash code of a float3x4 vector.</summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint hash(float3x4 v)
{
return csum(asuint(v.c0) * uint3(0xF9EA92D5u, 0xC2FAFCB9u, 0x616E9CA1u) +
asuint(v.c1) * uint3(0xC5C5394Bu, 0xCAE78587u, 0x7A1541C9u) +
asuint(v.c2) * uint3(0xF83BD927u, 0x6A243BCBu, 0x509B84C9u) +
asuint(v.c3) * uint3(0x91D13847u, 0x52F7230Fu, 0xCF286E83u)) + 0xE121E6ADu;
}
/// <summary>
/// Returns a uint3 vector hash code of a float3x4 vector.
/// When multiple elements are to be hashes together, it can more efficient to calculate and combine wide hash
/// that are only reduced to a narrow uint hash at the very end instead of at every step.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static uint3 hashwide(float3x4 v)
{
return (asuint(v.c0) * uint3(0xC9CA1249u, 0x69B60C81u, 0xE0EB6C25u) +
asuint(v.c1) * uint3(0xF648BEABu, 0x6BDB2B07u, 0xEF63C699u) +
asuint(v.c2) * uint3(0x9001903Fu, 0xA895B9CDu, 0x9D23B201u) +
asuint(v.c3) * uint3(0x4B01D3E1u, 0x7461CA0Du, 0x79725379u)) + 0xD6258E5Bu;
}
}
}

11
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float3x4.gen.cs.meta Normal file
View file

@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8e85ad7d883b9468da066c1ad9de70d0
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

3464
Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/float4.gen.cs Normal file
View file

File diff suppressed because it is too large Load diff

Some files were not shown because too many files have changed in this diff Show more