/// <summary> /// Initialization method /// </summary> /// <param name="sourcePanel">Parent source panel</param> /// <param name="source">Scenario element source class which will be used for adding new elements from this panel</param> /// <param name="variant">Cached scenario element source variant handled by this panel</param> public void Initialize(SourcePanel sourcePanel, ScenarioElementSource source, SourceVariant variant) { addElementsPanel = GetComponentInParent <AddElementsPanel>(); this.source = source; this.variant = variant; if (variant == null) { (sourcePanel.MultiplePages ? content : gameObject).SetActive(false); } else { (sourcePanel.MultiplePages ? content : gameObject).SetActive(true); if (!variant.IsPrepared) { var progress = variant.IsBusy ? $"{variant.PreparationProgress:F1}% " : ""; text.text = $"{progress}{UnpreparedSign} {variant.Name} {UnpreparedSign}"; variant.Prepared += VariantOnPrepared; } else { text.text = variant.Name; } } }
/// <summary> /// Setup method for initializing the required element data /// </summary> /// <param name="source">Source of this variant</param> /// <param name="variant">This agent variant</param> /// <param name="initialPolicy">Initial policy that will be set</param> public void Setup(ScenarioElementSource source, SourceVariant variant, List <ControlAction> initialPolicy) { OverriddenTransformToResize = transform; base.Setup(source, variant); Policy = initialPolicy; ScenarioManager.Instance.GetExtension <ScenarioControllablesManager>().RegisterControllable(this); }
/// <summary> /// Hides this panel if given variant is the same as shown one /// </summary> /// <param name="variant">Variant, which description should be hidden</param> public void Hide(SourceVariant variant) { if (shownVariant == variant) { Hide(); } }
/// <summary> /// Changes the current agent variant /// </summary> /// <param name="newVariant">New agent variant</param> /// <param name="registerUndo">If true, this action can be undone</param> public virtual void ChangeVariant(SourceVariant newVariant, bool registerUndo = true) { if (registerUndo) { RegisterUndoChangeVariant(); } var position = Vector3.zero; var rotation = Quaternion.Euler(0.0f, 0.0f, 0.0f); if (modelInstance != null) { position = modelInstance.transform.localPosition; rotation = modelInstance.transform.localRotation; DisposeModel(); } variant = newVariant; //Check if variant should spawn a model instance modelInstance = source.GetModelInstance(variant); if (modelInstance != null) { modelInstance.name = modelObjectName; modelInstance.transform.SetParent(transform); modelInstance.transform.localPosition = position; modelInstance.transform.localRotation = rotation; modelRenderers = null; } VariantChanged?.Invoke(variant); }
/// <inheritdoc/> public override void OnVariantSelected(SourceVariant variant) { selectedVariant = variant as ControllableVariant; if (selectedVariant != null) { ScenarioManager.Instance.GetExtension <InputManager>().StartDraggingElement(this); } }
/// <summary> /// Method invokes when this source is selected in the UI /// </summary> /// <param name="variant">Scenario element variant that is selected</param> public virtual void OnVariantSelected(SourceVariant variant) { selectedVariant = variant; if (variant != null) { ScenarioManager.Instance.GetExtension <InputManager>().StartDraggingElement(this); } }
/// <summary> /// Deinitialization method /// </summary> public void Deinitialize() { if (Variant != null) { Variant.Prepared -= VariantOnPrepared; } source = null; variant = null; }
/// <summary> /// Gets an instantiated variant if it is available in the scenario /// </summary> /// <param name="variant">Requested source variant</param> /// <returns>Instantiated variant if available, null otherwise</returns> public ScenarioElement GetVariantInstance(SourceVariant variant) { if (variant == navOriginVariant) { return(navOrigins.Count > 0 ? navOrigins[0] : null); } return(null); }
/// <summary> /// Method that instantiates and initializes a prefab of the selected variant /// </summary> /// <param name="variant">Scenario element variant which model should be instantiated</param> /// <returns>Scenario element variant model</returns> public virtual GameObject GetModelInstance(SourceVariant variant) { if (variant.Prefab == null) { return(null); } var instance = ScenarioManager.Instance.prefabsPools.GetInstance(variant.Prefab); return(instance); }
/// <summary> /// Detaches from the variant /// </summary> private void DetachFromVariant() { if (shownVariant == null) { return; } elementNameTitle.text = null; elementDescriptionText.text = null; shownVariant = null; }
/// <summary> /// Attaches to the given variant, setups UI for this variant /// </summary> /// <param name="variant">Variant which will be shown</param> private void AttachToVariant(SourceVariant variant) { DetachFromVariant(); shownVariant = variant; if (variant == null) { return; } elementNameTitle.text = variant.Name; FillDescription(variant.Description); }
/// <summary> /// Shows the description panel for requested variant /// </summary> /// <param name="rt">Target RectTransform to which this panel will be attached</param> /// <param name="variant">Variant that which description will be displayed</param> public void Show(RectTransform rt, SourceVariant variant) { if (variant == null) { return; } AttachToVariant(variant); gameObject.SetActive(true); transform.localScale = Vector3.zero; StartCoroutine(ShowAnimation(rt)); }
/// <inheritdoc/> public override ScenarioElement GetElementInstance(SourceVariant variant) { var newPoint = Instantiate(variant.Prefab, transform); var scenarioNavOrigin = newPoint.AddComponent <ScenarioNavOrigin>(); var navOrigin = newPoint.GetComponent <NavOrigin>(); if (navOrigin == null) { navOrigin = newPoint.AddComponent <NavOrigin>(); } scenarioNavOrigin.Setup(navOrigin, false); return(scenarioNavOrigin); }
/// <inheritdoc/> public override void OnVariantSelected(SourceVariant variant) { var availableInstance = ScenarioManager.Instance.GetExtension <ScenarioNavExtension>() .GetVariantInstance(variant); if (availableInstance != null) { var inputManager = ScenarioManager.Instance.GetExtension <InputManager>(); inputManager.FocusOnScenarioElement(availableInstance); } else { base.OnVariantSelected(variant); } }
/// <inheritdoc/> public Task Initialize() { var sourceGO = new GameObject("NavOriginSource"); sourceGO.transform.SetParent(transform); source = sourceGO.AddComponent <ScenarioNavSource>(); navOriginVariant = new SourceVariant("ScenarioNavOrigin", "This is a scenario NavOrigin implementation.", NavOriginPrefab.gameObject); source.Variants.Add(navOriginVariant); ScenarioManager.Instance.ScenarioReset += OnScenarioReset; var mapManager = ScenarioManager.Instance.GetExtension <ScenarioMapManager>(); OnMapChanged(mapManager.CurrentMapMetaData); mapManager.MapChanged += OnMapChanged; IsInitialized = true; return(Task.CompletedTask); }
/// <inheritdoc/> public override void CopyProperties(ScenarioElement origin) { var originWithVariant = origin as ScenarioElementWithVariant; if (originWithVariant == null) { throw new ArgumentException( $"Could not cast copied element to {nameof(ScenarioElementWithVariant)} type."); } source = originWithVariant.source; variant = originWithVariant.variant; for (var i = 0; i < transform.childCount; i++) { var child = transform.GetChild(i); if (child.name == modelObjectName) { modelInstance = child.gameObject; } } }
/// <summary> /// Creates an element instance for the given source variant /// </summary> /// <param name="variant">Source variant for the new instance</param> /// <returns>Element instance for the given source variant</returns> public abstract ScenarioElement GetElementInstance(SourceVariant variant);
/// <inheritdoc/> public override void Setup(ScenarioElementSource source, SourceVariant variant) { OverriddenTransformToResize = transform; base.Setup(source, variant); ScenarioManager.Instance.GetExtension <ScenarioControllablesManager>().RegisterControllable(this); }
/// <summary> /// Changes variant of the selected vehicle /// </summary> /// <param name="variant">Variant that will be applied to the vehicle</param> /// <returns>Task</returns> private void ChangeVariant(SourceVariant variant) { ScenarioManager.Instance.colorPicker.Hide(); selectedAgent.ChangeVariant(variant); }
/// <summary> /// Method invoked when selected agent changes the variant /// </summary> /// <param name="newVariant">Agent new variant</param> private void SelectedAgentOnVariantChanged(SourceVariant newVariant) { var variantId = variantDropdown.options.FindIndex(o => o.text == selectedAgent.Variant.Name); variantDropdown.SetValueWithoutNotify(variantId); }
/// <summary> /// Method invoked when selected agent changes the variant /// </summary> /// <param name="newVariant">Agent new variant</param> private void SelectedAgentOnVariantChanged(SourceVariant newVariant) { SetupSensorsConfigurationDropdown(); }
/// <inheritdoc/> public override void Setup(ScenarioElementSource source, SourceVariant variant) { base.Setup(source, variant); ScenarioManager.Instance.GetExtension <ScenarioAgentsManager>().RegisterAgent(this); }
/// <summary> /// Method called when variant of the parent agent changes /// </summary> /// <param name="newVariant">New variant of the parent agent</param> private void ParentAgentOnVariantChanged(SourceVariant newVariant) { if (newVariant is EgoAgentVariant egoAgentVariant && egoAgentVariant.SensorsConfigurations.Count > 0) { ChangeSensorsConfigurationId(egoAgentVariant.SensorsConfigurations[0].Id, false); }
public override ScenarioElement GetElementInstance(SourceVariant variant) { return(GetControllableInstance(variant as ControllableVariant)); }
/// <summary> /// Setup method for initializing the required element data /// </summary> /// <param name="source">Source of this variant</param> /// <param name="variant">This agent variant</param> public virtual void Setup(ScenarioElementSource source, SourceVariant variant) { this.source = source; this.variant = variant; ChangeVariant(variant, false); }
/// <summary> /// Constructor /// </summary> /// <param name="scenarioElementWithVariant">Scenario element which variant was changed</param> /// <param name="sourceVariant">Previous source variant</param> public UndoChangeVariant(ScenarioElementWithVariant scenarioElementWithVariant, SourceVariant sourceVariant) { this.scenarioElementWithVariant = scenarioElementWithVariant; this.sourceVariant = sourceVariant; }
/// <summary> /// Method invokes when this source is selected in the UI /// </summary> /// <param name="variant">Scenario element variant that is selected</param> public abstract void OnVariantSelected(SourceVariant variant);
/// <summary> /// Method invoked when selected agent changes the variant /// </summary> /// <param name="newVariant">Agent new variant</param> private void SelectedAgentOnVariantChanged(SourceVariant newVariant) { var variantId = agentSource.Variants.IndexOf(newVariant); variantDropdown.SetValueWithoutNotify(variantId); }