private string GetFilePath(IVsHierarchy hierarchy, uint itemId)
{
ThreadHelper.ThrowIfNotOnUIThread();
// GetMkDocument and GetCanonicalName don't work on the solution/root node.
if (hierarchy == null ||
HierarchyUtilities.IsSolutionNode(hierarchy, itemId))
{
return(RetrieveCurrentSolutionPath());
}
int hr;
string?file;
// We prefer IVsProject, but it's not available in all projects.
if (hierarchy is IVsProject project)
{
hr = project.GetMkDocument(itemId, out file);
}
else
{
hr = hierarchy.GetCanonicalName(itemId, out file);
}
if (ErrorHandler.Failed(hr) || file == null)
{
file = string.Empty;
}
return(file);
}
private void InspectHierarchyItems(IVsHierarchy hier, uint itemid, int level, List <uint> sharedItemIds)
{
string caption = HierarchyUtilities.GetHierarchyProperty <string>(hier, itemid, (int)__VSHPROPID.VSHPROPID_Caption);
this.Output(string.Format("{0}{1}\n", new string('\t', level), caption));
bool isSharedItem;
if (HierarchyUtilities.TryGetHierarchyProperty(hier, itemid, (int)__VSHPROPID7.VSHPROPID_IsSharedItem, out isSharedItem) &&
isSharedItem)
{
sharedItemIds.Add(itemid);
}
uint child;
if (HierarchyUtilities.TryGetHierarchyProperty(hier, itemid, (int)__VSHPROPID.VSHPROPID_FirstChild, Unbox.AsUInt32, out child) &&
child != (uint)VSConstants.VSITEMID.Nil)
{
this.InspectHierarchyItems(hier, child, level + 1, sharedItemIds);
while (HierarchyUtilities.TryGetHierarchyProperty(hier, child, (int)__VSHPROPID.VSHPROPID_NextSibling, Unbox.AsUInt32, out child) &&
child != (uint)VSConstants.VSITEMID.Nil)
{
this.InspectHierarchyItems(hier, child, level + 1, sharedItemIds);
}
}
}
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
if (this.branchDiffValidator.ValidateBranch(this.package))
{
// Create new tag tables everytime the filter is applied
BranchDiffFilterProvider.TagManager.CreateTagTables();
IVsHierarchyItem root = HierarchyUtilities.FindCommonAncestor(rootItems);
if (this.branchDiffValidator.ValidateSolution(this.solutionDirectory))
{
try
{
this.changeSet = this.branchDiffWorker.GenerateDiff(this.solutionDirectory, this.package.BranchToDiffAgainst);
}
catch (GitOperationException e)
{
this.errorPresenter.ShowError(e.Message);
return(null);
}
IReadOnlyObservableSet <IVsHierarchyItem> sourceItems = await this.vsHierarchyItemCollectionProvider.GetDescendantsAsync(
root.HierarchyIdentity.NestedHierarchy,
CancellationToken);
IFilteredHierarchyItemSet includedItems = await this.vsHierarchyItemCollectionProvider.GetFilteredHierarchyItemsAsync(
sourceItems,
ShouldIncludeInFilter,
CancellationToken);
return(includedItems);
}
}
return(null);
}
/// <summary>
/// Instantiates new prefab
/// </summary>
public void InstantiatePrefab(int prefabId, string relativePath, string objectName)
{
if (prefabId < 0 || prefabId >= Settings.DistributedObjectPrefabs.Length)
{
throw new ArgumentException(
$"Prefab of distributed object with id {prefabId} is not defined in {typeof(NetworkSettings).Name}.");
}
var rootTransform = transform;
var newGameObject = Instantiate(
Settings.DistributedObjectPrefabs[prefabId],
rootTransform.position,
rootTransform.rotation,
HierarchyUtilities.GetOrCreateChild(rootTransform, relativePath));
newGameObject.name = objectName;
var distributedObject = newGameObject.GetComponent <DistributedObject>();
if (distributedObject == null)
{
throw new ArgumentException(
$"Prefab of distributed object with id {prefabId} has no {typeof(DistributedObject).Name} component in the root game object.");
}
instantiatedObjects.Add(new InstantiatedObjectData(prefabId, distributedObject));
}
private bool ShouldIncludeInFilter(IVsHierarchyItem hierarchyItem)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (hierarchyItem == null)
{
return(false);
}
if (HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity) ||
HierarchyUtilities.IsProject(hierarchyItem.HierarchyIdentity))
{
var absoluteFilePath = string.Empty;
if (HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity))
{
absoluteFilePath = hierarchyItem.CanonicalName;
}
else if (HierarchyUtilities.IsProject(hierarchyItem.HierarchyIdentity))
{
var vsHierarchy = hierarchyItem.HierarchyIdentity.Hierarchy;
vsHierarchy.ParseCanonicalName(hierarchyItem.CanonicalName, out uint itemId);
vsHierarchy.GetProperty(itemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out object itemObject);
if (itemObject is EnvDTE.Project project)
{
absoluteFilePath = project.FullName;
}
}
if (!string.IsNullOrEmpty(absoluteFilePath))
{
DiffResultItem diffResultItem = this.branchDiffWorker.GetItemFromChangeSet(this.changeSet, absoluteFilePath);
if (diffResultItem != null)
{
// If the physical file in changeSet is under "External Dependencies" folder of a C++ project, always ignore. This file is a link, and already shows up elsewhere.
if (HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity) && IsCPPExternalDependencyFile(hierarchyItem))
{
return(false);
}
// Mark all Project nodes found in changeset, so we only enable "Open Diff With Base" button for these project nodes.
if (HierarchyUtilities.IsProject(hierarchyItem.HierarchyIdentity))
{
BranchDiffFilterProvider.TagManager.MarkProjAsChanged(hierarchyItem);
}
// If item renamed in working branch. Tag the old path so we find the Base branch version of file using the Old Path.
if (!string.IsNullOrEmpty(diffResultItem.OldAbsoluteFilePath))
{
BranchDiffFilterProvider.TagManager.SetOldFilePathOnRenamedItem(hierarchyItem, diffResultItem.OldAbsoluteFilePath);
}
return(true);
}
}
}
return(false);
}
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
IVsHierarchyItem root = HierarchyUtilities.FindCommonAncestor(rootItems);
IReadOnlyObservableSet <IVsHierarchyItem> sourceItems;
sourceItems = await _hierarchyCollectionProvider.GetDescendantsAsync(root.HierarchyIdentity.NestedHierarchy, CancellationToken);
return(await _hierarchyCollectionProvider.GetFilteredHierarchyItemsAsync(sourceItems, MeetsFilter, CancellationToken));
}
public static bool IsFileWithBookmarks(IVsHierarchyItem hierarchyItem)
{
if (hierarchyItem == null || !HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity))
{
return(false);
}
return(BookmarksManager.HasBookmarks(hierarchyItem.CanonicalName));
}
bool IsItemForFile(IVsHierarchyItem item, string filePath)
{
if (item.IsDisposed)
{
return(false);
}
return(HierarchyUtilities.IsPhysicalFile(item.HierarchyIdentity) &&
item.CanonicalName.Equals(filePath, StringComparison.OrdinalIgnoreCase));
}
public static string GetName(this IVsSolution4 solution, Guid identifier)
{
ThreadHelper.ThrowIfNotOnUIThread();
TryGetHierarchy(solution, identifier, out IVsHierarchy hierarchy);
if (HierarchyUtilities.TryGetHierarchyProperty(hierarchy, VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_Name, out string name))
{
return(name);
}
return("?");
}
private static bool IsLoaded(IVsSolution4 solution, Guid identifier)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (solution.TryGetHierarchy(identifier, out IVsHierarchy hierarchy))
{
return(!HierarchyUtilities.IsStubHierarchy(hierarchy));
}
else
{
return(false);
}
}
public IEnumerable <IVsHierarchy> EnumImportingProjects(IVsHierarchy hierarchy)
{
IVsSharedAssetsProject sharedAssetsProject;
if (HierarchyUtilities.TryGetHierarchyProperty(hierarchy, (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID7.VSHPROPID_SharedAssetsProject, out sharedAssetsProject) &&
sharedAssetsProject != null)
{
foreach (IVsHierarchy importingProject in sharedAssetsProject.EnumImportingProjects())
{
yield return(importingProject);
}
}
}
public IVsHierarchy GetActiveProjectContext(IVsHierarchy hierarchy)
{
IVsHierarchy activeProjectContext;
if (HierarchyUtilities.TryGetHierarchyProperty(hierarchy, (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID7.VSHPROPID_SharedItemContextHierarchy, out activeProjectContext))
{
return(activeProjectContext);
}
else
{
return(null);
}
}
/// <summary>
/// This function is the callback used to execute a command when the a menu item is clicked.
/// See the Initialize method to see how the menu item is associated to this function using
/// the OleMenuCommandService service and the MenuCommand class.
/// </summary>
private void MenuItemCallback(object sender, EventArgs e)
{
var sharedHier = this.FindSharedProject();
string sharedCaption = HierarchyUtilities.GetHierarchyProperty <string>(sharedHier, (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_Caption);
this.Output(string.Format("Found shared project: {0}\n", sharedCaption));
var activePlatformHier = this.GetActiveProjectContext(sharedHier);
string activeCaption = HierarchyUtilities.GetHierarchyProperty <string>(activePlatformHier, (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_Caption);
this.Output(string.Format("The active platform project: {0}\n", activeCaption));
this.Output("Platform projects:\n");
foreach (IVsHierarchy platformHier in this.EnumImportingProjects(sharedHier))
{
string platformCaption = HierarchyUtilities.GetHierarchyProperty <string>(platformHier, (uint)VSConstants.VSITEMID.Root, (int)__VSHPROPID.VSHPROPID_Caption);
this.Output(string.Format(" * {0}\n", platformCaption));
}
this.Output("Walk the active platform project:\n");
var sharedItemIds = new List <uint>();
this.InspectHierarchyItems(activePlatformHier, (uint)VSConstants.VSITEMID.Root, 1, sharedItemIds);
var sharedItemId = sharedItemIds[0];
string fullPath;
ErrorHandler.ThrowOnFailure(((IVsProject)activePlatformHier).GetMkDocument(sharedItemId, out fullPath));
this.Output(string.Format("Shared item full path: {0}\n", fullPath));
var dte = (EnvDTE.DTE) this.GetService(typeof(EnvDTE.DTE));
var dteEvents = (EnvDTE80.Events2)dte.Events;
dteEvents.ProjectItemsEvents.ItemRenamed += this.OnItemRenamed;
HierarchyUtilities.TryGetHierarchyProperty(activePlatformHier, sharedItemId, (int)__VSHPROPID7.VSHPROPID_SharedProjectHierarchy, out sharedHier);
uint itemIdInSharedHier;
int found;
VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1];
if (ErrorHandler.Succeeded(((IVsProject)sharedHier).IsDocumentInProject(fullPath, out found, priority, out itemIdInSharedHier)) &&
found != 0)
{
var newName = DateTime.Now.Ticks.ToString() + Path.GetExtension(fullPath);
ErrorHandler.ThrowOnFailure(sharedHier.SetProperty(itemIdInSharedHier, (int)__VSHPROPID.VSHPROPID_EditLabel, newName));
this.Output(string.Format("Renamed {0} to {1}\n", fullPath, newName));
}
dteEvents.ProjectItemsEvents.ItemRenamed -= this.OnItemRenamed;
}
private static HierarchyNode CreateNode(IVsHierarchy hierarchy, Guid identifier, IVsImageService2 imageService, IVsHierarchyItemManager hierarchyItemManager)
{
ThreadHelper.ThrowIfNotOnUIThread();
ImageMoniker collapsedIcon;
ImageMoniker expandedIcon;
string name;
bool isFolder;
name = HierarchyUtilities.GetHierarchyProperty <string>(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHPROPID.VSHPROPID_Name
);
isFolder = HierarchyUtilities.IsSolutionFolder(
hierarchyItemManager.GetHierarchyItem(hierarchy, VSConstants.VSITEMID_ROOT).HierarchyIdentity
);
collapsedIcon = imageService.GetImageMonikerForHierarchyItem(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHIERARCHYIMAGEASPECT.HIA_Icon
);
expandedIcon = imageService.GetImageMonikerForHierarchyItem(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHIERARCHYIMAGEASPECT.HIA_OpenFolderIcon
);
// Sometimes the icons can be blank.
// In those cases, use some default icons.
if (collapsedIcon.Id == 0 && collapsedIcon.Guid == default)
{
collapsedIcon = isFolder ? KnownMonikers.FolderClosed : KnownMonikers.DocumentCollection;
}
if (expandedIcon.Id == 0 && expandedIcon.Guid == default)
{
expandedIcon = isFolder ? KnownMonikers.FolderOpened : KnownMonikers.DocumentCollection;
}
return(new HierarchyNode(identifier, name, collapsedIcon, expandedIcon)
{
IsLoaded = !HierarchyUtilities.IsStubHierarchy(hierarchy),
IsFolder = isFolder
});
}
// Gets the items to be included from this filter provider.
// rootItems is a collection that contains the root of your solution
// Returns a collection of items to be included as part of the filter
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
IVsHierarchyItem root = HierarchyUtilities.FindCommonAncestor(rootItems);
IReadOnlyObservableSet <IVsHierarchyItem> sourceItems;
sourceItems = await _hierarchyCollectionProvider.GetDescendantsAsync(
root.HierarchyIdentity.NestedHierarchy,
CancellationToken);
IFilteredHierarchyItemSet includedItems = await _hierarchyCollectionProvider.GetFilteredHierarchyItemsAsync(
sourceItems,
_shouldInclude == null?(Predicate <IVsHierarchyItem>) ShouldIncludeInFilterByRegex : (Predicate <IVsHierarchyItem>)ShouldIncludeInFilterByFunc,
CancellationToken);
return(includedItems);
}
private bool ShouldIncludeInFilter(IVsHierarchyItem hierarchyItem)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (hierarchyItem == null)
{
return(false);
}
if (HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity) ||
HierarchyUtilities.IsProject(hierarchyItem.HierarchyIdentity))
{
var absoluteFilePath = string.Empty;
if (HierarchyUtilities.IsPhysicalFile(hierarchyItem.HierarchyIdentity))
{
absoluteFilePath = hierarchyItem.CanonicalName;
}
else if (HierarchyUtilities.IsProject(hierarchyItem.HierarchyIdentity))
{
hierarchyItem.HierarchyIdentity.Hierarchy.GetProperty(VSConstants.VSITEMID_ROOT, (int)__VSHPROPID.VSHPROPID_ExtObject, out var prjObject);
if (prjObject is EnvDTE.Project project)
{
absoluteFilePath = project.FullName;
}
}
if (!string.IsNullOrEmpty(absoluteFilePath))
{
DiffResultItem diffResultItem = this.branchDiffWorker.GetItemFromChangeSet(this.changeSet, hierarchyItem.CanonicalName);
if (diffResultItem != null)
{
// Tag the old path so we find the Base branch version of file using the Old Path (for files renamed in the working branch)
if (!string.IsNullOrEmpty(diffResultItem.OldAbsoluteFilePath))
{
BranchDiffFilterProvider.TagManager.SetOldFilePathOnRenamedItem(
hierarchyItem.HierarchyIdentity.Hierarchy,
hierarchyItem.CanonicalName,
diffResultItem.OldAbsoluteFilePath);
}
return(true);
}
}
}
return(false);
}
/// <summary>
/// Returns the <see cref="IVsSharedAssetsProject"/> for the <see cref="IVsHierarchy"/>.
/// </summary>
/// <param name="hierarchy"></param>
public static IVsSharedAssetsProject?GetSharedAssetsProject(this IVsHierarchy hierarchy)
{
if (hierarchy == null)
{
throw new ArgumentNullException(nameof(hierarchy));
}
ThreadHelper.ThrowIfNotOnUIThread();
HierarchyUtilities.TryGetHierarchyProperty <IVsSharedAssetsProject>(
hierarchy,
(uint)VSConstants.VSITEMID.Root,
(int)__VSHPROPID7.VSHPROPID_SharedAssetsProject,
out IVsSharedAssetsProject? sharedAssetsProject);
return(sharedAssetsProject);
}
private bool TryGetManager(out IVsReferenceManagerUser manager)
{
_project.GetItemInfo(out IVsHierarchy hierarchy, out uint itemId, out _);
IVsReferenceManagerUser?value = HierarchyUtilities.GetHierarchyProperty <IVsReferenceManagerUser?>(
hierarchy,
itemId,
(int)__VSHPROPID5.VSHPROPID_ReferenceManagerUser
);
if (value is not null)
{
manager = value;
return(true);
}
manager = null !;
return(false);
}
/// <inheritdoc/>
public void UnicastInitialMessages(IPEndPoint endPoint)
{
for (var i = 0; i < instantiatedObjects.Count; i++)
{
var instantiatedObject = instantiatedObjects[i];
if (instantiatedObject.DistributedObject == null)
{
continue;
}
var message = GetInstantiationMessage(
instantiatedObject.PrefabId,
HierarchyUtilities.GetRelativePath(
transform,
instantiatedObject.DistributedObject.transform),
instantiatedObject.DistributedObject.name);
UnicastMessage(endPoint, message);
instantiatedObject.DistributedObject.UnicastInitialMessages(endPoint);
}
}
private static Guid GetParentIdentifier(IVsSolution solution, IVsHierarchy hierarchy)
{
IVsHierarchy?parentHierarchy;
ThreadHelper.ThrowIfNotOnUIThread();
parentHierarchy = HierarchyUtilities.GetHierarchyProperty <IVsHierarchy?>(
hierarchy,
VSConstants.VSITEMID_ROOT,
(int)__VSHPROPID.VSHPROPID_ParentHierarchy
);
if (parentHierarchy is not null)
{
if (TryGetIdentifier(solution, parentHierarchy, out Guid parentIdentifier))
{
return(parentIdentifier);
}
}
return(default);
// Gets the items to be included from this filter provider.
// rootItems is a collection that contains the root of your solution
// Returns a collection of items to be included as part of the filter
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
// get default hierarchy
var root = HierarchyUtilities.FindCommonAncestor(rootItems);
var sourceItems = await _hierarchyCollectionProvider.GetDescendantsAsync(
root.HierarchyIdentity.NestedHierarchy,
CancellationToken);
// switch thread context
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(CancellationToken);
// get diff stats
var stats = GetRepoStats();
if (stats == null)
{
return(sourceItems);
}
return(await _hierarchyCollectionProvider.GetFilteredHierarchyItemsAsync(
sourceItems,
ShouldIncludeInFilter(stats),
CancellationToken));
}
/// <summary>
/// Instantiates selected prefab in the unique relative path
/// </summary>
/// <param name="prefabId">Id of instantiated prefab in <see cref="NetworkSettings.DistributedObjectPrefabs"/></param>
/// <param name="relativePath">Relative path to the root where object will be created, can be changed if object name is not unique</param>
/// <returns>Instantiated new distributed object</returns>
/// <exception cref="ArgumentException">Invalid configuration of the instantiated prefab</exception>
private DistributedObject InstantiatePrefab(int prefabId, string relativePath)
{
if (prefabId < 0 || prefabId >= Settings.DistributedObjectPrefabs.Length)
{
throw new ArgumentException(
$"Prefab of distributed object with id {prefabId} is not defined in {typeof(NetworkSettings).Name}.");
}
var distributedObjectParent = HierarchyUtilities.GetOrCreateChild(transform, relativePath);
var newGameObject = Instantiate(Settings.DistributedObjectPrefabs[prefabId], distributedObjectParent);
HierarchyUtilities.ChangeToUniqueName(newGameObject);
var distributedObject = newGameObject.GetComponent <DistributedObject>();
if (distributedObject == null)
{
throw new ArgumentException(
$"Prefab of distributed object with id {prefabId} has no {typeof(DistributedObject).Name} component in the root game object.");
}
instantiatedObjects.Add(new InstantiatedObjectData(prefabId, distributedObject));
return(distributedObject);
}
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
if (BranchDiffFilterValidator.ValidateBranch(this.package))
{
// Create new tag tables everytime the filter is applied
BranchDiffFilterProvider.TagManager.CreateTagTables();
IVsHierarchyItem root = HierarchyUtilities.FindCommonAncestor(rootItems);
if (BranchDiffFilterValidator.ValidateSolution(this.solutionDirectory, this.solutionFile))
{
try
{
// TODO: The solution directory path may not always be the Git repo path!
// Git repo could be setup higher up. Write a service to find the Git repo upwards in the heirarchy and pass that here.
this.changeSet = this.branchDiffWorker.GenerateDiff(this.solutionDirectory, this.package.BranchToDiffAgainst);
}
catch (GitOperationException e)
{
ErrorPresenter.ShowError(e.Message);
return(null);
}
IReadOnlyObservableSet <IVsHierarchyItem> sourceItems = await this.vsHierarchyItemCollectionProvider.GetDescendantsAsync(
root.HierarchyIdentity.NestedHierarchy,
CancellationToken);
IFilteredHierarchyItemSet includedItems = await this.vsHierarchyItemCollectionProvider.GetFilteredHierarchyItemsAsync(
sourceItems,
ShouldIncludeInFilter,
CancellationToken);
return(includedItems);
}
}
return(null);
}
// Gets the items to be included from this filter provider.
// rootItems is a collection that contains the root of your solution
// Returns a collection of items to be included as part of the filter
protected override async Task <IReadOnlyObservableSet> GetIncludedItemsAsync(IEnumerable <IVsHierarchyItem> rootItems)
{
IVsHierarchyItem root = HierarchyUtilities.FindCommonAncestor(rootItems);
IReadOnlyObservableSet <IVsHierarchyItem> sourceItems;
sourceItems = await hierarchyCollectionProvider.GetDescendantsAsync(
root.HierarchyIdentity.NestedHierarchy,
CancellationToken);
IFilteredHierarchyItemSet includedItems = await hierarchyCollectionProvider.GetFilteredHierarchyItemsAsync(
sourceItems,
FilesWithBookmarksFilteredHierarchyItemSet.IsFileWithBookmarks,
CancellationToken);
var wrapper = new FilesWithBookmarksFilteredHierarchyItemSet(sourceItems, includedItems);
if (FilesWithBookmarksFilteredHierarchyItemSet.Instance != null)
{
FilesWithBookmarksFilteredHierarchyItemSet.Instance.Dispose();
}
FilesWithBookmarksFilteredHierarchyItemSet.Instance = wrapper;
return(wrapper);
}
public GameObject SpawnAgent(AgentConfig config)
{
var go = Instantiate(config.Prefab, transform);
go.name = config.Name;
var agentController = go.GetComponent <AgentController>();
agentController.SensorsChanged += AgentControllerOnSensorsChanged;
agentController.Config = config;
agentController.Config.AgentGO = go;
SIM.LogSimulation(SIM.Simulation.VehicleStart, config.Name);
ActiveAgents.Add(agentController.Config);
agentController.GTID = ++SimulatorManager.Instance.GTIDs;
agentController.Config.GTID = agentController.GTID;
BridgeClient bridgeClient = null;
if (config.Bridge != null)
{
bridgeClient = go.AddComponent <BridgeClient>();
bridgeClient.Init(config.Bridge);
if (config.Connection != null)
{
var split = config.Connection.Split(':');
if (split.Length != 2)
{
throw new Exception("Incorrect bridge connection string, expected HOSTNAME:PORT");
}
bridgeClient.Connect(split[0], int.Parse(split[1]));
}
}
SIM.LogSimulation(SIM.Simulation.BridgeTypeStart, config.Bridge != null ? config.Bridge.Name : "None");
var sensorsController = go.AddComponent <SensorsController>();
agentController.AgentSensorsController = sensorsController;
sensorsController.SetupSensors(config.Sensors);
//Add required components for distributing rigidbody from master to clients
var network = Loader.Instance.Network;
if (network.IsClusterSimulation)
{
HierarchyUtilities.ChangeToUniqueName(go);
if (network.IsClient)
{
//Disable controller and dynamics on clients so it will not interfere mocked components
agentController.enabled = false;
var vehicleDynamics = agentController.GetComponent <IVehicleDynamics>() as MonoBehaviour;
if (vehicleDynamics != null)
{
vehicleDynamics.enabled = false;
}
}
//Change the simulation type only if it's not set in the prefab
var distributedRigidbody = go.GetComponent <DistributedRigidbody>();
if (distributedRigidbody == null)
{
distributedRigidbody = go.AddComponent <DistributedRigidbody>();
distributedRigidbody.SimulationType = DistributedRigidbody.MockingSimulationType.ExtrapolateVelocities;
}
//Add the rest required components for cluster simulation
ClusterSimulationUtilities.AddDistributedComponents(go);
}
go.transform.position = config.Position;
go.transform.rotation = config.Rotation;
agentController.Init();
#if UNITY_EDITOR
// TODO remove hack for editor opaque with alpha clipping 2019.3.3
Array.ForEach(go.GetComponentsInChildren <Renderer>(), renderer =>
{
foreach (var m in renderer.materials)
{
m.shader = Shader.Find(m.shader.name);
}
});
Array.ForEach(go.GetComponentsInChildren <DecalProjector>(), decal =>
{
decal.material.shader = Shader.Find(decal.material.shader.name);
});
#endif
return(go);
}
/// <summary>
/// Tries to get a property from a hierarchy item.
/// </summary>
/// <remarks>
/// Inspired by https://github.com/dotnet/roslyn/blob/main/src/VisualStudio/Core/Def/Implementation/ProjectSystem/Extensions/IVsHierarchyExtensions.cs
/// </remarks>
public static bool TryGetItemProperty <T>(this IVsHierarchy hierarchy, uint itemId, int propertyId, out T?value)
{
return(HierarchyUtilities.TryGetHierarchyProperty <T>(hierarchy, itemId, propertyId, out value));
}
public GameObject SpawnAgent(AgentConfig config)
{
var go = Instantiate(config.Prefab, transform);
go.name = config.Name;
// set it inactive until we can be sure setting up sensors etc worked without exceptions and it AgentController was initialized
go.SetActive(false);
var controller = go.GetComponent <IAgentController>();
if (controller == null)
{
Debug.LogWarning($"{nameof(IAgentController)} implementation not found on the {config.Name} vehicle. This vehicle can't be used as an ego vehicle.");
}
else
{
controller.Config = config;
controller.Config.AgentGO = go;
ActiveAgents.Add(controller.Config);
controller.GTID = ++SimulatorManager.Instance.GTIDs;
controller.Config.GTID = controller.GTID;
}
var lane = go.AddComponent <VehicleLane>();
var baseLink = go.GetComponentInChildren <BaseLink>();
if (baseLink == null)
{
baseLink = new GameObject("BaseLink").AddComponent <BaseLink>();
baseLink.transform.SetParent(go.transform, false);
}
var sensorsController = go.GetComponent <ISensorsController>() ?? go.AddComponent <SensorsController>();
if (controller != null)
{
controller.AgentSensorsController = sensorsController;
}
//Add required components for distributing rigidbody from master to clients
var network = Loader.Instance.Network;
if (network.IsClusterSimulation)
{
HierarchyUtilities.ChangeToUniqueName(go);
//Add the rest required components for cluster simulation
ClusterSimulationUtilities.AddDistributedComponents(go);
if (network.IsClient)
{
controller?.DisableControl();
}
}
BridgeClient bridgeClient = null;
if (config.BridgeData != null)
{
var dir = Path.Combine(Simulator.Web.Config.PersistentDataPath, "Bridges");
var vfs = VfsEntry.makeRoot(dir);
Simulator.Web.Config.CheckDir(vfs.GetChild(config.BridgeData.AssetGuid), Simulator.Web.Config.LoadBridgePlugin);
bridgeClient = go.AddComponent <BridgeClient>();
config.Bridge = BridgePlugins.Get(config.BridgeData.Type);
bridgeClient.Init(config.Bridge);
if (!String.IsNullOrEmpty(config.Connection))
{
bridgeClient.Connect(config.Connection);
}
}
go.transform.position = config.Position;
go.transform.rotation = config.Rotation;
sensorsController.SetupSensors(config.Sensors);
controller?.Init();
if (SimulatorManager.Instance.IsAPI)
{
SimulatorManager.Instance.EnvironmentEffectsManager.InitRainVFX(go.transform);
}
go.SetActive(true);
return(go);
}
public GameObject SpawnAgent(AgentConfig config)
{
var go = Instantiate(config.Prefab, transform);
go.name = config.Name;
// set it inactive until we can be sure setting up sensors etc worked without exceptions and it AgentController was initialized
go.SetActive(false);
var agentController = go.GetComponent <AgentController>();
agentController.Config = config;
agentController.Config.AgentGO = go;
var lane = go.AddComponent <VehicleLane>();
var baseLink = go.GetComponentInChildren <BaseLink>();
if (baseLink == null)
{
baseLink = new GameObject("BaseLink").AddComponent <BaseLink>();
baseLink.transform.SetParent(go.transform, false);
}
ActiveAgents.Add(agentController.Config);
agentController.GTID = ++SimulatorManager.Instance.GTIDs;
agentController.Config.GTID = agentController.GTID;
BridgeClient bridgeClient = null;
if (config.Bridge != null)
{
bridgeClient = go.AddComponent <BridgeClient>();
bridgeClient.Init(config.Bridge);
if (!String.IsNullOrEmpty(config.Connection))
{
bridgeClient.Connect(config.Connection);
}
}
var sensorsController = go.AddComponent <SensorsController>();
agentController.AgentSensorsController = sensorsController;
//Add required components for distributing rigidbody from master to clients
var network = Loader.Instance.Network;
if (network.IsClusterSimulation)
{
HierarchyUtilities.ChangeToUniqueName(go);
if (network.IsClient)
{
//Disable controller and dynamics on clients so it will not interfere mocked components
agentController.enabled = false;
var vehicleDynamics = agentController.GetComponent <IVehicleDynamics>() as MonoBehaviour;
if (vehicleDynamics != null)
{
vehicleDynamics.enabled = false;
}
}
//Change the simulation type only if it's not set in the prefab
var distributedRigidbody = go.GetComponent <DistributedRigidbody>();
if (distributedRigidbody == null)
{
distributedRigidbody = go.AddComponent <DistributedRigidbody>();
distributedRigidbody.SimulationType = DistributedRigidbody.MockingSimulationType.ExtrapolateVelocities;
}
//Add the rest required components for cluster simulation
ClusterSimulationUtilities.AddDistributedComponents(go);
}
go.transform.position = config.Position;
go.transform.rotation = config.Rotation;
sensorsController.SetupSensors(config.Sensors);
agentController.Init();
go.SetActive(true);
return(go);
}
