public SamplerElement(SerializedProperty property, Parameter parameter)
        {
            m_Property = property;
            var template = AssetDatabase.LoadAssetAtPath <VisualTreeAsset>(
                $"{StaticData.uxmlDir}/Sampler/SamplerElement.uxml");

            template.CloneTree(this);

            m_Parameter = parameter;
            m_Sampler   = GetSamplerFromSerializedObject();

            if (m_Sampler == null)
            {
                CreateSampler(typeof(UniformSampler));
            }

            var samplerName = this.Q <Label>("sampler-name");

            samplerName.text = UppercaseFirstLetter(m_Property.name);

            m_Properties               = this.Q <VisualElement>("fields-container");
            m_SamplerTypeDropdown      = this.Q <ToolbarMenu>("sampler-type-dropdown");
            m_SamplerTypeDropdown.text = SamplerUtility.GetSamplerDisplayName(m_Sampler.GetType());;
            foreach (var samplerType in StaticData.samplerTypes)
            {
                var displayName = SamplerUtility.GetSamplerDisplayName(samplerType);;
                m_SamplerTypeDropdown.menu.AppendAction(
                    displayName,
                    a => { ReplaceSampler(samplerType); },
                    a => DropdownMenuAction.Status.Normal);
            }
            CreatePropertyFields();
        }
 internal void RandomizeSamplers()
 {
     foreach (var sampler in samplers)
     {
         sampler.baseSeed = SamplerUtility.GenerateRandomSeed();
         sampler.ResetState();
     }
 }
        public void SeedIteratedByChangingEitherBaseSeedOrIndex()
        {
            // Check if changing the index changes the generated random state
            var iteratedIndex1 = SamplerUtility.IterateSeed(0, 0);
            var iteratedIndex2 = SamplerUtility.IterateSeed(1, 0);

            Assert.AreNotEqual(iteratedIndex1, iteratedIndex2);

            // Check if changing the seed changes the generated random state
            var iteratedSeed1 = SamplerUtility.IterateSeed(0, 0);
            var iteratedSeed2 = SamplerUtility.IterateSeed(0, 1);

            Assert.AreNotEqual(iteratedSeed1, iteratedSeed2);
        }
        void CreateSampler(Type samplerType)
        {
            var newSampler = (ISampler)Activator.CreateInstance(samplerType);

            newSampler.baseSeed = SamplerUtility.GenerateRandomSeed();

            if (m_RangeProperty != null)
            {
                newSampler.range = new FloatRange(
                    m_RangeProperty.FindPropertyRelative("minimum").floatValue,
                    m_RangeProperty.FindPropertyRelative("maximum").floatValue);
            }


            m_Sampler = newSampler;
            m_Property.managedReferenceValue = newSampler;
            m_Property.serializedObject.ApplyModifiedProperties();
        }
 void ReplaceSampler(Type samplerType)
 {
     CreateSampler(samplerType);
     m_SamplerTypeDropdown.text = SamplerUtility.GetSamplerDisplayName(samplerType);
     CreatePropertyFields();
 }
Exemplo n.º 6
0
        void Update()
        {
            // TODO: remove this check when the perception camera can capture the first frame of output
            if (m_SkipFrame)
            {
                m_SkipFrame = false;
                return;
            }

            // Wait for any final uploads before exiting quitting
            if (m_WaitingForFinalUploads && quitOnComplete)
            {
                Manager.Instance.Shutdown();
                if (!Manager.FinalUploadsDone)
                {
                    return;
                }
#if UNITY_EDITOR
                UnityEditor.EditorApplication.ExitPlaymode();
#else
                Application.Quit();
#endif
                return;
            }

            // Iterate Scenario
            if (m_FirstScenarioFrame)
            {
                m_FirstScenarioFrame = false;
            }
            else
            {
                currentIterationFrame++;
                framesSinceInitialization++;
                if (isIterationComplete)
                {
                    IncrementIteration();
                    currentIterationFrame = 0;
                    foreach (var randomizer in activeRandomizers)
                    {
                        randomizer.IterationEnd();
                    }
                }
            }

            // Quit if scenario is complete
            if (isScenarioComplete)
            {
                foreach (var randomizer in activeRandomizers)
                {
                    randomizer.ScenarioComplete();
                }
                DatasetCapture.ResetSimulation();
                m_WaitingForFinalUploads = true;
                return;
            }

            // Perform new iteration tasks
            if (currentIterationFrame == 0)
            {
                DatasetCapture.StartNewSequence();
                SamplerState.randomState = SamplerUtility.IterateSeed((uint)currentIteration, genericConstants.randomSeed);

                DatasetCapture.ReportMetric(m_IterationMetricDefinition, new[]
                {
                    new IterationMetricData()
                    {
                        iteration = currentIteration
                    }
                });
                foreach (var randomizer in activeRandomizers)
                {
                    randomizer.IterationStart();
                }
            }

            // Perform new frame tasks
            foreach (var randomizer in activeRandomizers)
            {
                randomizer.Update();
            }
        }
Exemplo n.º 7
0
 /// <summary>
 /// Generates a new random state and overwrites the old random state with the newly generated value
 /// </summary>
 /// <returns>The newly generated random state</returns>
 public uint NextRandomState()
 {
     m_RandomState = SamplerUtility.Hash32NonZero(m_RandomState);
     return(m_RandomState);
 }
 /// <summary>
 /// Generates a new random state and overwrites the old random state with the newly generated value
 /// </summary>
 /// <returns>The newly generated random state</returns>
 public static uint NextRandomState()
 {
     randomState = SamplerUtility.Hash32NonZero(randomState);
     return(randomState);
 }
Exemplo n.º 9
0
 /// <summary>
 /// Resets SamplerState.randomState with a new seed value generated by hashing this Scenario's randomSeed
 /// with its currentIteration
 /// </summary>
 protected virtual void ResetRandomStateOnIteration()
 {
     SamplerState.randomState = SamplerUtility.IterateSeed((uint)currentIteration, genericConstants.randomSeed);
 }