(step(0, 1) returns 0 while it should return 1

Not really a biggy, but currently I can't devide an int3 by a float directly, without explicitly casting the int3 to a float3 first. (Is true for int2 and int4 aswell).

So basically, what I would like is this operator.

public static float3 operator / (int3 lhs, float rhs)
{ return new float3 (lhs.x / rhs, lhs.y / rhs, lhs.z / rhs); }

So that when I want to devide my int3 by a float, I don't have to explicitly cast my int3 to a float3 first.

Requesting that bounds and ray types be added. (single- AND double-precision versions) with intersection functions. See:

Types:

• https://github.com/tbg10101/Unity.Mathematics/blob/extension/src/Unity.Mathematics/ray.cs
• https://github.com/tbg10101/Unity.Mathematics/blob/extension/src/Unity.Mathematics/bounds.cs

Intersection functions:

• https://github.com/tbg10101/Unity.Mathematics/blob/extension/src/Unity.Mathematics/math.cs#L184
• https://github.com/tbg10101/Unity.Mathematics/blob/extension/src/Unity.Mathematics/math.cs#L210

The Rotate functions detail returning a float4x4 matrix when instead they are returning a quaternion.

(Sorry if this is an incorrect place to report docs issues, I'd love to know how best to report issues with package docs)

Intrinsic types should use custom PropertyDrawers, at least to match corresponding UnityEngine types (e.g., float3 -> Vector3, float4 -> Vector4), as opposed to using default tree view for structs.

The "bool" type disappear at some point while updating the package.

Is this desired? Boolean is quite convenient and since there are bool4 and etc. I don't see why we can't have bool1 :)

Cheers!

See https://forum.unity.com/threads/inspector-entity-half4-missing-properties.550990/

Adding this item here so that it can be tracked and dealt with when/if it is decided to remove or stick with half types.

This forced my project to upgrade .NET to 4.5. But I think this is minor issue, anyway.

Consider the following code:

for (uint i = 1; i < 10; i++)
	Debug.Log(new Unity.Mathematics.Random(i).NextFloat());

It outputs the following:

6.29425E-05
0.000125885
0.0001888275
0.00025177
0.0003147125
0.000377655
0.0004405975
0.00050354
0.0005664825

This output does not look random. This is because the Xorshift PRNG Random() uses is supposed to be initialized with different type of PRNG, such as SplitMix. Wikipedia has an example: https://en.wikipedia.org/wiki/Xorshift#Initialization.

When the mathematics package is included as source in a project and the project is opened in Rider, Rider will run inspections on the generated files. This is probably not very useful, as these files are not intended to be maintained by hand, or modified by the end user.

The analysis can be automatically disabled by using the well known header:

//------------------------------------------------------------------------------
// <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>
//------------------------------------------------------------------------------

Rider will recognise this comment and treat the file as generated. This means it's not user code, so Rider doesn't run or show inspections in this file. Alternatively, Rider will also recognise files that match the filename pattern *.generated.cs as being generated.

Our project has -warnaserror+ set in mcs.rsp.

Because of the following warning, we can not include the current release of Unity Mathematics as a dependency in our project (the warning gets converted to an error and the compile fails):

/packages/packages.unity.com/[email protected]/Unity.Mathematics/Noise/psrdnoise2D.cs(100,20): error CS0219: Warning as Error: The variable `i2' is assigned but its value is never used

since Mathf.Sign returns -1 or 1, and sign() returns -1, 0 or 1 it creates problems for code
where the result sign is then multiplied by something, effectively setting that value to zero.

This probably wont change as it's how it should be in shaders (probably) but still
having a classic (-1, 1) would be very nice.

Example of what current sign leads to

float num2 = sign(normalized.x * normalized2.y - normalized.y * normalized2.x);
float result = num * (num2 >= 0f ? 1f : -1f);

row by row mul instead of row by column

Currently functions redirect to System.Math, casting the input to a double and output to float. In .Net Core MathF is available to do native floating point math and speed this up.

I imagine System.MathF cannot be used in unity currently, but if this is possible at some point it might be impossible to switch without breaking code relying on exact precision.

I'm not sure what Burst compiles eg System.Math.Cos too anyway - would it internally already use 32 bit cosf routine?

There is currently no helper methods exposed to compare two floating points that are approximately the same

What needs to be determined:

• name of these methods (e.g near_equal...)
• what kind of implementation do we want? (taking into account ULP or not? one version with more parameters?...)

I would like to see implicit casting for:

• int2 <=> Vector2Int
• int3 <=> Vector3Int

(I have no idea why those don't exist)

• Vector3 <=> float2
  (usefull when using vector functions like Camera.WorldToScreenPoint in 2D)

Second one will make my code a lot easier to read, instead of
(Vector2)camera.WorldToScreenPoint(float3(currentWorldspaceAimCentre, 0));
I will be able to just do
camera.WorldToScreenPoint(currentWorldspaceAimCentre)

The package manager doc tools expect your documentation folder to have a ~ character at the end: Documentation~. (This is so it ignores the doc files when looking for resources actually used by a program importing the package.)

FromToRotation is a useful utility in the classic Quaternion class but it is missing from Mathematics.quaternion.

I wonder if there is any specific reason why no vector types for long and ulong were added.
I'm currently working with bit operations and a ulong4 would allow me to do more operations in parallel.

Frequently, I will attempt to compare a float2 and a float2 in an if statement, only to find that the comparison yields a bool2 rather than a bool.

This seems like logical behavior, now that I'm used to it--but there doesn't seem to be any elegant way to convert bool2 to bool so it can be used like this.

I would expect one of the following:

• Bool2 has methods And(), Or(), Xor() that can be called directly and return bools. Perhaps syntactically ugly--if ((myPos != otherPos).And())--but this would be my preferred behavior.
• Bool2 automatically converts to bool by performing AND or some such on its components. I can understand why this is not done, given that no default behavior would work for every case.
• Comparing bool2 and bool2 returns true if all components are equal, false otherwise, the same way Vector2 == Vector2 works.

But none of these appears to be the case.

At present, I am forced either to cache the bool2 in a variable and compare its components in the if (...) statement, or to directly compare the components of the float2s. Functional ways to code, certainly, but unpleasant to look at, especially given the prior compactness and understandibility of comparing Vector2 and Vector2.

Any thoughts on this? Am I missing some existing method to do this? And are these unpleasantly lengthy methods superior in some way, or at least intended?

Hi there!
I noticed two problems that reduce performance and can easily be fixed 😄

1. Not using throw helpers

The jit will never inline a method if it throws an exception, even if you add the AgressiveInlining attribute.

Example: int2.gen.cs line:775

The common fix for this is very simple, just use a "throw helper", like this:

[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static int select_shuffle_component(int2 a, int2 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:
            ThrowInvalidArgument();
    }
}

static void ThrowInvalidArgument()
{
    throw new System.ArgumentException("Invalid shuffle component: " + component);
}

2. Using the "fixed" statement instead of a reinterpret cast

The code used for indexers can be improved a lot!
Example: int2.gen.cs line:616

The fixed statement is horrible because just like throwing exceptions, it prevents a ton of optimizations (it is implemented that way on all runtimes I tested!).

Take a look at the asm it generates:

Code:

(z = test1[6] is there on purpose, not a typo)

Assembly:

This should instead be done using a reinterpret cast.

Keep in mind that even though the syntax of Unsafe can sometimes (fortunately not here) become really unwieldy, it pretty much always compiles down to very simple instructions. (In fact methods like Unsafe.As<TFrom, TTo>(ref source) are literally a nop because they only trick the C# compiler into accepting the type change).
It's really just the C# name for reinterpret_cast.

By simply casting ref this to a little helper struct all overhead is gone.

Btw Unsafe is defined in System.Runtime.CompilerServices.Unsafe. The As() method I'm using here has an extremely simple definition (in this case it does literally nothing as you can see). All other functions in there are just as trivial, so they should be really easy for Unity to add 👍

Here is what I did instead:

struct int2
{
	public int x;
	public int y;

	public unsafe int this[int index]
	{
		get
		{
			return Unsafe.As<int2, ArrayUnion>(ref this).ints[index];
		}
		set
		{
			Unsafe.As<int2, ArrayUnion>(ref this).ints[index] = value;
		}
	}
}

[StructLayout(LayoutKind.Explicit)]
internal unsafe struct ArrayUnion
{
	// The fixed array sizes are assuming a float4(x,y,z,w) as maximum
	// but their size doesn't even actually matter because we're only using
	// it to reinterpret the bits anyway!
	[FieldOffset(0)]
	public fixed int ints[4];
	[FieldOffset(0)]
	public fixed uint uints[4];
	[FieldOffset(0)]
	public fixed float floats[4];
	[FieldOffset(0)]
	public fixed short shorts[2 * 4]; // 2 shorts per field, 4 times
	[FieldOffset(0)]
	public fixed bool bools[4 * 4]; // 4 bools per field, 4 times
	// ...
}

And with the exact same C# code, this time the disassembly looks like this:

This time the jit was able to absolutely decimate the code! Nice! Let me know what you think 😄

So, math.select() essentially maps to a ternary operator. Is there a design reason why the parameters are exactly in the reverse order of a ternary operator? It was really counter intuitive to me when I first saw that.

I'm not sure I understand why it wouldn't use the same ordering as the ternary operator. Something like

select(condition, a, b) //a if true, otherwise b

It seems a lot more intuitive to follow the established order of the ternary since it's exactly what it does anyway.

example:
int3 val1 = new int3(3, 9,7);
int3 val2 = new int3(7, 3,9);
creates the same hash, I don't exactly know how the default hash code implementation looks like but from what I know it is really bad for structs and should never be used whenever Equals has been overridden.

the old Vector2Int and Vector3Int classes have overridden the GetHashCode methods:

Vector3Int: return x.GetHashCode() ^ (y.GetHashCode() << 2) ^ (z.GetHashCode() >> 2);
Vector2Int: return x.GetHashCode() ^ (y.GetHashCode() << 2);

those however also are rather bad implementations as they have tons of collisions too:
for example all these Vector3Int have a hash value of 12 (there are definitely even more than those)
(2, 3, 9)
(2, 3, 10)
(2, 3, 11)
(4, 2, 2)
(4, 2, 3)

The "snoise(float3 v)" function has artefacts in a line exactly at x=y=z.
This artefact seems to repeat in multiple places (always along the line x=y=z relative to a noise cell maybe?).

This produces obvious artefacts when used in my voxel engine in Unity3D,
which currently uses marching cubes to display the isosurface at value 0 of the 3d noise.

The relevant code is this:
valueForMarchingCubes = Unity.Mathematics.noise.snoise(pos3d / 100f) + 0.42f;

A reproduceable Unity3D script:

using UnityEngine;
using Unity.Mathematics;
using static Unity.Mathematics.math;

public class NoiseBugRepro : MonoBehaviour {
    // Start is called before the first frame update
    void Start () {
        string output = "";
        for (int i = 0; i<20; ++i) {
            float x = lerp(1.8f, 2.2f, i / 20f);
            float3 pos = float3(x, 2f, 2f);

            float val = noise.snoise(pos / 20f);

            output += string.Format("noise.snoise({0:F2}, {1:F2}, {2:F2}) -> {3:F6}\n", pos.x, pos.y, pos.z, val);
        }

        Debug.Log(output);
    }
}

Output that shows the artefact when exactly on the x=y=z line:

noise.snoise(1.80, 2.00, 2.00) -> -0.373848
noise.snoise(1.82, 2.00, 2.00) -> -0.372971
noise.snoise(1.84, 2.00, 2.00) -> -0.372090
noise.snoise(1.86, 2.00, 2.00) -> -0.371204
noise.snoise(1.88, 2.00, 2.00) -> -0.370314
noise.snoise(1.90, 2.00, 2.00) -> -0.369420
noise.snoise(1.92, 2.00, 2.00) -> -0.368521
noise.snoise(1.94, 2.00, 2.00) -> -0.367619
noise.snoise(1.96, 2.00, 2.00) -> -0.366712
noise.snoise(1.98, 2.00, 2.00) -> -0.365801
noise.snoise(2.00, 2.00, 2.00) -> -0.571772
noise.snoise(2.02, 2.00, 2.00) -> -0.363966
noise.snoise(2.04, 2.00, 2.00) -> -0.363043
noise.snoise(2.06, 2.00, 2.00) -> -0.362115
noise.snoise(2.08, 2.00, 2.00) -> -0.361184
noise.snoise(2.10, 2.00, 2.00) -> -0.360248
noise.snoise(2.12, 2.00, 2.00) -> -0.359309
noise.snoise(2.14, 2.00, 2.00) -> -0.358365
noise.snoise(2.16, 2.00, 2.00) -> -0.357418
noise.snoise(2.18, 2.00, 2.00) -> -0.356467

Hi, I'm currently in the process of rewriting my game's math, and I'm using Unity.Mathematics to do so. Since my game requires the same formulas to be implemented in C# and HLSL, having a consistent syntax helps immensely.

My game is multiplayer, however, and I'd like to be able to use the same code on the server side, which is in a Linux environment. I've been implementing the server side code in .NET Core to ensure portability. Is there a way to use Unity.Mathematics in that project? Since Unity does support Linux, I'm assuming there's a workflow. Would I have to switch to Mono?

With the upcoming changes on our handling of static readonly, it is preferred to use only struct constructors instead of function calls to initialize static readonly.

Typically, these should be changed (they are in tests, so it's not a huge issue, but better keep it in mind for other cases through the codebase)

At time of writing, this is the whole of the package manual for Mathematics

Unity's C# SIMD math library providing vector types and math functions with a shader like syntax. This package is still in experimental phase.

We need some examples on how to do basic common operations. Some ideas:

• using Random
• using Noise
• quaternion multiplication

Hi guys,

I'm the creator of this library https://github.com/proyecto26/RestClient
I was wondering if you could me suggestions, recommendations or any documentation to use HPC in my code in order to generate a better dll? And what happen if I have dependencies in my project?

Thanks in advance,
Nicholls

I'd find it handy to have zeroed swizzle operators that would let me do something like this:

float3 first = new float3(1f, 2f, 3f);
float3 second = new float3(7f, 8f, 9f);

float3 combined = first.x_z + second._y_; // == new float3(1f, 8f, 3f)

For me, this sometimes seems easier to understand at a glance than having something like:

float3 first = new float3(1f, 2f, 3f);
float3 second = new float3(7f, 8f, 9f);

float3 combined = new float3(first.x, second.y, first.z); // == new float3(1f, 8f, 3f)

There is no explicit conversion from euler to quaternion, we need to convert to float3x3 first and then to quaternion.

As a first iteration we could only provide a methods that does the implicit conversion and improve it later.

public quaternion FromEuler(float3 xyz, RotationOrder order = RotationOrder.Default)
{
    return new quaternion( float3x3.Euler(xyz, order));
}

Using both UnityEngine code and an online calculator shows that the values given by quaternion.EulerXYZ() are so fundamentally wrong that it is hard to believe that I'm not making some terrible mistake.

For example, quaternion.EulerXYZ(45, 0, 0) = {-0.4871745, 0, 0, -0.8733047}, which converting back to eulers, gives {58.31, 0, 0} -- and that's closer than most comparisons, well, except {0,0,0} => {0,0,0,1} which seems right on.

using UnityEngine;
using Unity.Mathematics;

public class QTester : MonoBehaviour
{
    public Vector3 InEulers = Vector3.zero;
    public Quaternion DebugQ = new Quaternion();
    public Vector3 OutEulers = Vector3.zero;

    void Update()
    {
        //DebugQ = quaternion.EulerXYZ(InEulers);
        DebugQ = quaternion.EulerXYZ(InEulers.x, InEulers.y, InEulers.z);
        OutEulers = DebugQ.eulerAngles;
    }
}

At least one other variant of Euler* shows the same behavior, I didn't test further.

Visual inspection based on Using the RotationEulerXYZ components in an ECS project is consistent with the incorrect math -- that is setting a 45 degree rotation produces a result that looks closer to 60 degrees than to 45.

PacMan says my version of Mathematics is preview1-1.0.0
My Unity Editor version is 2019.1.0b8, Mac

The provided 3D snoise function produces very low quality perlin noise and appears to be unusable for any practical application.

Here is a sample output of the algorithm, converted to PNG format:

As you can see, there is a diagonal periodic nature to it at higher scales. And, if you look very closely, you can see a pattern of discontinuous individual pixels (stuck at values -1 or 1).

Here is the code I used to generate this texture. Perhaps I made a mistake somewhere?

    [BurstCompile]
    public struct PerlinNoiseGenJob : IJob, IDisposable
    {
        public PerlinNoiseGenJob(int2 seed, float frequency, int2 origin, int2 dimensions, float valueMultiplier=1)
        {
            this.seed = seed;
            this.frequency = frequency;
            this.origin = origin;
            this.dimensions = dimensions;
            this.valueMultiplier = valueMultiplier;
            perlinNoise = new NativeArray<float>(dimensions.x * dimensions.y, Allocator.TempJob, NativeArrayOptions.UninitializedMemory);
        }
        
        public int2 seed;

        public float frequency;

        public int2 origin;

        public int2 dimensions;

        public float valueMultiplier;

        public NativeArray<float> perlinNoise;
        
        public void Execute()
        {
//            float z = (float) hash(seed) / uint.MaxValue;
            float z = 0;
            for (int i = 0; i < perlinNoise.Length; i++)
            {
                int ox = i % dimensions.x;
                int oy = i / dimensions.x;
                float pnx = (origin.x + ox) * frequency;
                float pny = (origin.y + oy) * frequency;
                perlinNoise[i] = noise.snoise(float3(pnx, pny, z)) * valueMultiplier;
            }
        }

        public void Dispose()
        {
            perlinNoise.Dispose();
        }
    }

    public class PerlinNoiseTextureGenerator : MonoBehaviour
    {
        public Texture2D texture;
        
        private void Start()
        {
            var dimensions = int2(1000,1000);
            var job = new PerlinNoiseGenJob(int2(5,12), 1f/10, int2(0,0), dimensions);
            var startTime = Time.realtimeSinceStartup;
            var handle = job.Schedule();
            handle.Complete();
            Debug.Log("Run time: "+(Time.realtimeSinceStartup - startTime));
            
            Color[] colors = new Color[dimensions.y * dimensions.x];
            for (int i=0; i<job.perlinNoise.Length; i++)
            {
                colors[i] = new Color((job.perlinNoise[i]+1)/2, 0,0);
            }
            
            texture = new Texture2D(dimensions.x,dimensions.y);
            texture.SetPixels(colors);
            
            //AssetDatabase.CreateAsset(texture, "Assets/Generated/Perlin.asset");
            File.WriteAllBytes("D:\\Perlin2.png", texture.EncodeToPNG());
            
            job.Dispose();
        }
    }

Hi, just noticed the documentation is flipped for all the radiens(floatN) methods

/Jannek

Good to see that the vector components are public fields instead of meaningless properties this time around 👍 Also nice to see that they have gotten the Serializable attributes as well.

Using structs as keys in HashSets and Dictionaries is pretty slow even if the struct has the IEquatable interface - they are still getting boxed (EDIT: they are not getting boxed, virtcalls on structs is just expensive). Providing a custom IEqualityComparer instance makes .Nets hash-tables a lot faster.

I find myself making them a lot, so would be really convenient if one as included, perhaps like so:

public partial class int3 : ...
{
    public static readonly Int3EqualityComparer DefaultEqualityComparer = new Int3EqualityComparer();

    public class Int3EqualityComparer : IEqualityComparer<int3>
    {
        public bool Equals(int3 a, int3 b)
        {
            return a.x == b.x && a.y == b.y && a.z == b.z;
        }

        public int GetHashCode(int3 v)
        {
            return ...
        }
    }
}

Would also be really convenient if int2, int3, and int4 had the FloorToInt, RoundToInt(v3) and CeilToInt methods. Just like Vector3Int

Right now the only way to multiply quaternion by quaternion or float4 by float4x4 is with math.mul. This concept is familiar reasonably discoverable for developers with shader programming experience, but that does not make up the majority of our users. We need to either fix the discoverability problem or provide the operators most users would expect from the Vector3, etc API

Mathf.PI works just fine of course but that's a bit of a code smell

Hi,
In my 2d grid system code I would like to have function overloads to let it's users provide grid coordinates in different formats, like:

void SetGridValue ( int x , int y , Value value ) => collection[ x , y ] = value;
void SetGridValue ( int2 xy , Value value ) => collection[ xy ] = value;//the same issue applies to indexer
void SetGridValue ( int i , Value value ) => collection[ i ] = value;

But since int can be implicitly cast to int2 without user knowledge I came to a conclusion that this would be a bad idea. My vote here thereby is to make this cast explicit since implicit introduces uncertainty between these types.

Hi, I know this is just a nice to have feature, but while static readonly might be faster than calling a constructor, it does break the burst compiler. I am not sure if it is the plan to add support for static field support to burst, but otherwise changing vector.zero to a static get property would save a few headaches I think.

/Jannek

Hi, I've been (ill-advisedly) using some of your codegen to create larger matrices for linear algebra stuff. Pretty cool so far. One thing I've found, is that the floatN this[int i] indexer on matrices does not allow setting of individual members due to returning a struct by value. e.g: this doesn't work:

myNxnMatrix[2][3] = 9;

This is fairly expected, but I've found that if you used a ref floatN this[int i] you'd be able to allow for that kind of nested indexing, and even use the indexed column as a modifiable lvalue. In my case, I use it to avoid copying float9 vectors.

This also removes the need for the setter.

Best of all, the indexer would still make copies at the call site unless the ref keyword is explicitly used, so as to avoid unintentional modifications of the matrix.

When using static Unity.Mathematics.math, type names get shadowed by functions of the same name (e.g. float3, float4x4, quaternion), making it imposible to access their static members without fully qualifying the type name.

This makes it really annoying to use static members such as float3.zero, float4x4.PerspectiveFov, quaternion.AxisAngle, etc. having to either qualify them with Unity.Mathematics. or dropping the using static altogether and qualify all math with math..

I was playing with ECS today, and I was looking for a function to project a float3 onto a plane described by a normal float3. It looks like projection functions don't exist yet (?).

I'd like to see double precision options here as well. (math operations for doubles, double2, double3, double4, etc.)

There is inconsistency right now in the naming of quaternion factory methods, which can lead to confusion (see https://unity.slack.com/archives/CE7DZN2H1/p1546448661023000).

quaternion.RotateX() is named in a such a way that implies the method is going to rotate something, rather than produce a rotation quaternion (cf https://docs.google.com/document/d/1RaGSTzE3d3AN-l73J18nxKlPgIwLCzVdQuWdhYKywbA/edit). To bring them in line with LookRotation(), please consider renaming:

• RotateX() -> XRotation()
• RotateY() -> YRotation()
• RotateZ() -> ZRotation()

Seeing this is supposed to be a HLSL/GLSL compliant math library, would be nice to see some 3D math functions supported such as GetPointClosestToPlane or similar sugar to aid 3D math operations.