added sample randomizers

com.unity.perception/Runtime/Randomization/Parameters/ParameterTypes/CategorialParameters.meta

+fileFormatVersion: 2
+guid: e09548ac8cf147b6b8ce910112ae97c4
+timeCreated: 1600890464

com.unity.perception/Runtime/Randomization/Parameters/ParameterTypes/NumericParameters.meta

+fileFormatVersion: 2
+guid: db7c97a0f5014b73a7af47aa6f6a276a
+timeCreated: 1600890440

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers.meta

+fileFormatVersion: 2
+guid: 30298872573345e4b74b28fb0f2c3e7b
+timeCreated: 1600834284

com.unity.perception/Runtime/Randomization/Parameters/ParameterTypes/CategorialParameters/Texture2DParameter.cs

+using System;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Parameters
+{
+    /// <summary>
+    /// A categorical parameter for generating GameObject samples
+    /// </summary>
+    [Serializable]
+    public class Texture2DParameter : CategoricalParameter<Texture2D> { }
+}

com.unity.perception/Runtime/Randomization/Parameters/ParameterTypes/CategorialParameters/Texture2DParameter.cs.meta

+fileFormatVersion: 2
+guid: 918b30749d6743a79fecd6e361a7e8e7
+timeCreated: 1600890374

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers.meta

+fileFormatVersion: 2
+guid: c023cfd4f6be49589b2e738890aa8617
+timeCreated: 1600834466

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/BackgroundObjectPlacementRandomizer.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Perception.Randomization.Parameters;
+using UnityEngine.Experimental.Perception.Randomization.Samplers;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    [Serializable]
+    public class BackgroundObjectPlacementRandomizer : Randomizer
+    {
+        public float depth;
+        public int layerCount = 2;
+        public float separationDistance = 2f;
+        public Vector2 placementArea;
+        public GameObjectParameter prefabs;
+        List<GameObject> m_SpawnedObjects = new List<GameObject>();
+
+        protected override void OnIterationStart()
+        {
+            for (var i = 0; i < layerCount; i++)
+            {
+                var seed = SamplerUtility.IterateSeed((uint)scenario.currentIteration, (uint)i);
+                var placementSamples = PoissonDiskSampling.GenerateSamples(
+                    placementArea.x, placementArea.y, separationDistance, seed);
+                var offset = new Vector3(placementArea.x, placementArea.y, 0f) * -0.5f;
+                var parent = scenario.transform;
+                foreach (var sample in placementSamples)
+                {
+                    var instance = Object.Instantiate(prefabs.Sample(), parent);
+                    instance.transform.position = new Vector3(sample.x, sample.y, separationDistance * i + depth) + offset;
+                    m_SpawnedObjects.Add(instance);
+                }
+                placementSamples.Dispose();
+            }
+        }
+
+        protected override void OnIterationEnd()
+        {
+            foreach (var spawnedObject in m_SpawnedObjects)
+                Object.Destroy(spawnedObject);
+            m_SpawnedObjects.Clear();
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/BackgroundObjectPlacementRandomizer.cs.meta

+fileFormatVersion: 2
+guid: 1d45e868d49e45a994c74df953db52e5
+timeCreated: 1600839950

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/ColorRandomizer.cs

+using System;
+using UnityEngine.Experimental.Perception.Randomization.Parameters;
+using UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    [Serializable]
+    public class ColorRandomizer : Randomizer
+    {
+        static readonly int k_BaseColor = Shader.PropertyToID("_BaseColor");
+        public ColorHsvaParameter colorParameter;
+
+        protected override void OnIterationStart()
+        {
+            var taggedObjects = tagManager.Query<ColorRandomizerTag>();
+            foreach (var taggedObject in taggedObjects)
+            {
+                var renderer = taggedObject.GetComponent<MeshRenderer>();
+                renderer.material.SetColor(k_BaseColor, colorParameter.Sample());
+            }
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/ColorRandomizer.cs.meta

+fileFormatVersion: 2
+guid: 9af0ee54b83446c5820eaaf8333d9e53
+timeCreated: 1600841128

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/ForegroundObjectPlacementRandomizer.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Perception.Randomization.Parameters;
+using UnityEngine.Experimental.Perception.Randomization.Samplers;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    [Serializable]
+    public class ForegroundObjectPlacementRandomizer : Randomizer
+    {
+        public float depth;
+        public float separationDistance = 2f;
+        public Vector2 placementArea;
+        public GameObjectParameter prefabs;
+        List<GameObject> m_SpawnedObjects = new List<GameObject>();
+
+        protected override void OnIterationStart()
+        {
+            var seed = SamplerUtility.IterateSeed((uint)scenario.currentIteration, SamplerUtility.largePrime);
+            var placementSamples = PoissonDiskSampling.GenerateSamples(
+                placementArea.x, placementArea.y, separationDistance, seed);
+            var offset = new Vector3(placementArea.x, placementArea.y, 0f) * -0.5f;
+            var parent = scenario.transform;
+            foreach (var sample in placementSamples)
+            {
+                var instance = Object.Instantiate(prefabs.Sample(), parent);
+                instance.transform.position = new Vector3(sample.x, sample.y, depth) + offset;
+                m_SpawnedObjects.Add(instance);
+            }
+            placementSamples.Dispose();
+        }
+
+        protected override void OnIterationEnd()
+        {
+            foreach (var spawnedObject in m_SpawnedObjects)
+                Object.Destroy(spawnedObject);
+            m_SpawnedObjects.Clear();
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/ForegroundObjectPlacementRandomizer.cs.meta

+fileFormatVersion: 2
+guid: 1aa5f41630694acb95f73ccedd8056ab
+timeCreated: 1600838786

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/RotationRandomizer.cs

+using System;
+using UnityEngine.Experimental.Perception.Randomization.Parameters;
+using UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    [Serializable]
+    public class RotationRandomizer : Randomizer
+    {
+        public Vector3Parameter rotation = new Vector3Parameter();
+
+        protected override void OnIterationStart()
+        {
+            var taggedObjects = tagManager.Query<RotationRandomizerTag>();
+            foreach (var taggedObject in taggedObjects)
+                taggedObject.transform.rotation = Quaternion.Euler(rotation.Sample());
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/RotationRandomizer.cs.meta

+fileFormatVersion: 2
+guid: cc253e4bce9d4e10bcb091293726f362
+timeCreated: 1600834466

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/TextureRandomizer.cs

+using System;
+using UnityEngine.Experimental.Perception.Randomization.Parameters;
+using UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    [Serializable]
+    public class TextureRandomizer : Randomizer
+    {
+        static readonly int k_BaseTexture = Shader.PropertyToID("_BaseMap");
+        public Texture2DParameter texture;
+
+        protected override void OnIterationStart()
+        {
+            var taggedObjects = tagManager.Query<TextureRandomizerTag>();
+            foreach (var taggedObject in taggedObjects)
+            {
+                var renderer = taggedObject.GetComponent<MeshRenderer>();
+                renderer.material.SetTexture(k_BaseTexture, texture.Sample());
+            }
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Randomizers/TextureRandomizer.cs.meta

+fileFormatVersion: 2
+guid: a6f6fa9eaed24e9eac29ed8fb44cbb3e
+timeCreated: 1600890289

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags.meta

+fileFormatVersion: 2
+guid: 98eebc94769dc4c4f936f424ffdf3f3b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/ColorRandomizerTag.cs

+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags
+{
+    [AddComponentMenu("Perception/RandomizerTags/ColorRandomizerTag")]
+    public class ColorRandomizerTag : RandomizerTag { }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/ColorRandomizerTag.cs.meta

+fileFormatVersion: 2
+guid: a8823429b12641208135cb2bd79e1096
+timeCreated: 1600841172

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/RotationRandomizerTag.cs

+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags
+{
+    [AddComponentMenu("Perception/RandomizerTags/RotationRandomizerTag")]
+    public class RotationRandomizerTag : RandomizerTag { }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/RotationRandomizerTag.cs.meta

+fileFormatVersion: 2
+guid: b85e54e30bb74162b2d6bca9b68f5482
+timeCreated: 1600834529

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/TextureRandomizerTag.cs

+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers.Tags
+{
+    [AddComponentMenu("Perception/RandomizerTags/TextureRandomizerTag")]
+    public class TextureRandomizerTag : RandomizerTag { }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Tags/TextureRandomizerTag.cs.meta

+fileFormatVersion: 2
+guid: e9546a8975fe4783ac74e987ecca9635
+timeCreated: 1600890539

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Utilities.meta

+fileFormatVersion: 2
+guid: 7edf59614df54a13b3a98879e7c15ffe
+timeCreated: 1600838959

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Utilities/PoissonDiskSampling.cs

+using System;
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Jobs;
+using Unity.Mathematics;
+
+namespace UnityEngine.Experimental.Perception.Randomization.Randomizers.SampleRandomizers
+{
+    public static class PoissonDiskSampling
+    {
+        const int k_DefaultSamplingResolution = 30;
+
+        // Algorithm sourced from Robert Bridson's paper "Fast Poisson Disk Sampling in Arbitrary Dimensions"
+        // https://www.cs.ubc.ca/~rbridson/docs/bridson-siggraph07-poissondisk.pdf
+        /// <summary>
+        ///   <para>Returns a list of poisson disc sampled points for a given area and density</para>
+        /// </summary>
+        /// <param name="width">Width of the sampling area</param>
+        /// <param name="height">Height of the sampling area</param>
+        /// <param name="minimumRadius">The minimum distance required between each sampled point</param>
+        /// <param name="seed">The random seed used to initialize the algorithm state</param>
+        /// <param name="samplingResolution">The number of potential points sampled around every valid point</param>
+        public static NativeList<float2> GenerateSamples(
+            float width,
+            float height,
+            float minimumRadius,
+            uint seed = 12345,
+            int samplingResolution = k_DefaultSamplingResolution)
+        {
+            if (width < 0)
+                throw new ArgumentException($"Width {width} cannot be negative");
+            if (height < 0)
+                throw new ArgumentException($"Height {height} cannot be negative");
+            if (minimumRadius < 0)
+                throw new ArgumentException($"MinimumRadius {minimumRadius} cannot be negative");
+            if (seed == 0)
+                throw new ArgumentException("Random seed cannot be 0");
+            if (samplingResolution <= 0)
+                throw new ArgumentException($"SamplingAttempts {samplingResolution} cannot be <= 0");
+
+            var samples = new NativeList<float2>(Allocator.TempJob);
+            new SampleJob
+            {
+                width = width,
+                height = height,
+                minimumRadius = minimumRadius,
+                seed = seed,
+                samplingResolution = samplingResolution,
+                samples = samples
+            }.Schedule().Complete();
+            return samples;
+        }
+
+        [BurstCompile]
+        struct SampleJob : IJob
+        {
+            public float width;
+            public float height;
+            public float minimumRadius;
+            public uint seed;
+            public int samplingResolution;
+            public NativeList<float2> samples;
+
+            public void Execute()
+            {
+                var newSamples = Sample(width, height, minimumRadius, seed, samplingResolution, Allocator.Temp);
+                samples.AddRange(newSamples);
+                newSamples.Dispose();
+            }
+        }
+
+        public static NativeList<float2> Sample(
+            float width,
+            float height,
+            float minimumRadius,
+            uint seed,
+            int samplingResolution,
+            Allocator allocator)
+        {
+            var samples = new NativeList<float2>(allocator);
+
+            var random = new Unity.Mathematics.Random(seed);
+            var cellSize = minimumRadius / math.sqrt(2);
+            var rows = Mathf.FloorToInt(height / cellSize);
+            var cols = Mathf.FloorToInt(width / cellSize);
+            var gridSize = rows * cols;
+            if (gridSize == 0)
+                return samples;
+
+            var rSqr = minimumRadius * minimumRadius;
+            var samplingArc = (math.PI * 2) / samplingResolution;
+            var halfSamplingArc = samplingArc / 2;
+
+            var gridToSampleIndex = new NativeArray<int>(gridSize, Allocator.Temp);
+            for (var i = 0; i < gridSize; i++)
+                gridToSampleIndex[i] = -1;
+
+            var activePoints = new NativeList<float2>(Allocator.Temp);
+
+            var firstPoint = new float2(
+                random.NextFloat(0.4f, 0.6f) * width,
+                random.NextFloat(0.4f, 0.6f) * height);
+            samples.Add(firstPoint);
+            var firstPointCol = Mathf.FloorToInt(firstPoint.x / cellSize);
+            var firstPointRow = Mathf.FloorToInt(firstPoint.y / cellSize);
+            gridToSampleIndex[firstPointCol + firstPointRow * cols] = 0;
+            activePoints.Add(firstPoint);
+
+            while (activePoints.Length > 0)
+            {
+                var randomIndex = random.NextInt(0, activePoints.Length);
+                var activePoint = activePoints[randomIndex];
+
+                var nextPointFound = false;
+                for (var i = 0; i < samplingResolution; i++)
+                {
+                    var length = random.NextFloat(minimumRadius, minimumRadius * 2);
+                    var angle = samplingArc * i + random.NextFloat(-halfSamplingArc, halfSamplingArc);
+
+                    var newPoint = activePoint + new float2(
+                        math.cos(angle) * length,
+                        math.sin(angle) * length);
+
+                    var col = Mathf.FloorToInt(newPoint.x / cellSize);
+                    var row = Mathf.FloorToInt(newPoint.y / cellSize);
+
+                    if (row < 0 || row >= rows || col < 0 || col >= cols)
+                        continue;
+
+                    var tooCloseToAnotherPoint = false;
+                    for (var x = -2; x <= 2; x++)
+                    {
+                        if ((col + x) < 0 || (col + x) >= cols)
+                            continue;
+
+                        for (var y = -2; y <= 2; y++)
+                        {
+                            if ((row + y) < 0 || (row + y) >= rows)
+                                continue;
+
+                            var gridIndex = (col + x) + (row + y) * cols;
+                            if (gridToSampleIndex[gridIndex] < 0)
+                                continue;
+
+                            var distanceSqr = math.distancesq(samples[gridToSampleIndex[gridIndex]], newPoint);
+
+                            if (distanceSqr >= rSqr)
+                                continue;
+                            tooCloseToAnotherPoint = true;
+                            break;
+                        }
+                    }
+
+                    if (tooCloseToAnotherPoint)
+                        continue;
+
+                    nextPointFound = true;
+                    activePoints.Add(newPoint);
+                    samples.Add(newPoint);
+                    gridToSampleIndex[col + row * cols] = samples.Length - 1;
+                }
+
+                if (!nextPointFound)
+                    activePoints.RemoveAtSwapBack(randomIndex);
+            }
+            gridToSampleIndex.Dispose();
+            activePoints.Dispose();
+
+            return samples;
+        }
+    }
+}

com.unity.perception/Runtime/Randomization/Randomizers/SampleRandomizers/Utilities/PoissonDiskSampling.cs.meta

+fileFormatVersion: 2
+guid: 4c1bfda42c1c41b28a50aebe4174c4fa
+timeCreated: 1600839153