public void Init()
 {
     m = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 10000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
     for (int i = 0; i < 10000; ++i)
     {
         m[i] = float3x3.identity;
     }
 }
 public void Init()
 {
     rng = new Random(1);
     m   = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * iterations, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
     for (int i = 0; i < iterations; ++i)
     {
         m[i] = float3x3.identity;
     }
 }
 public void Init()
 {
     rng = new Random(1);
     m   = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * iterations, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
     for (int i = 0; i < iterations; ++i)
     {
         m[i] = new float3x3(0.054824f, 0.462398f, 0.050136f, 0.054824f, 0.462398f, 0.050136f, 0.938166f, 0.542226f, 0.106844f);
     }
 }
                public void Init()
                {
                    q = (quaternion *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <quaternion>() * 10000, UnsafeUtility.AlignOf <quaternion>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        q[i] = quaternion.identity;
                    }

                    f3x3 = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 10000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        f3x3[i] = float3x3.identity;
                    }
                }
Пример #5
0
                public void Init()
                {
                    v = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 100000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < 100000; ++i)
                    {
                        v[i] = new float3x3(1.0f);
                    }

                    hash = (uint3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <uint3>() * 100000, UnsafeUtility.AlignOf <uint3>(), Allocator.Persistent);
                    for (int i = 0; i < 100000; ++i)
                    {
                        hash[i] = 0;
                    }
                }
Пример #6
0
                public void Init()
                {
                    m1 = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 10000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        m1[i] = float3x3.identity;
                    }

                    m2 = (float3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3>() * 10000, UnsafeUtility.AlignOf <float3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        m2[i] = new float3(1.0f, 0.0f, 0.0f);
                    }
                }
                public void Init()
                {
                    rng = new Random(1);
                    v   = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * iterations, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        v[i] = new float3x3(1.0f);
                    }

                    hash = (uint3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <uint3>() * iterations, UnsafeUtility.AlignOf <uint3>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        hash[i] = 0;
                    }
                }
                public void Init()
                {
                    rng = new Random(1);
                    q   = (quaternion *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <quaternion>() * iterations, UnsafeUtility.AlignOf <quaternion>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        q[i] = quaternion.identity;
                    }

                    f3x3 = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * iterations, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        f3x3[i] = float3x3.identity;
                    }
                }
                public void Init()
                {
                    forward = (float3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3>() * 10000, UnsafeUtility.AlignOf <float3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        forward[i] = math.normalize(new float3(1.0f));
                    }

                    up = (float3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3>() * 10000, UnsafeUtility.AlignOf <float3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        up[i] = math.normalize(new float3(0.0f, 1.0f, 0.0f));
                    }

                    m = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 10000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        m[i] = float3x3.identity;
                    }
                }
                public void Init()
                {
                    v = (float3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3>() * 10000, UnsafeUtility.AlignOf <float3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        v[i] = math.normalize(new float3(1.0f));
                    }

                    m = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * 10000, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        m[i] = float3x3.identity;
                    }

                    angle = (float *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float>() * 10000, UnsafeUtility.AlignOf <float>(), Allocator.Persistent);
                    for (int i = 0; i < 10000; ++i)
                    {
                        angle[i] = 1.0f;
                    }
                }
Пример #11
0
                public void Init()
                {
                    rng = new Random(1);
                    v   = (float3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3>() * iterations, UnsafeUtility.AlignOf <float3>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        v[i] = math.normalize(new float3(1.0f));
                    }

                    m = (float3x3 *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float3x3>() * iterations, UnsafeUtility.AlignOf <float3x3>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        m[i] = float3x3.identity;
                    }

                    angle = (float *)UnsafeUtility.Malloc(UnsafeUtility.SizeOf <float>() * iterations, UnsafeUtility.AlignOf <float>(), Allocator.Persistent);
                    for (int i = 0; i < iterations; ++i)
                    {
                        angle[i] = 1.0f;
                    }
                }
Пример #12
0
 public static unsafe void TestIdentityFloat3x3(float3x3 *mat)
 {
     *mat = float3x3.identity;
 }