/// <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);
}
