private Rect DrawIsBlockingToggle(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
IDataOwner dataOwner = wrapper.Value as IDataOwner;
rect = DrawRecursively(rect, wrapper, drawIsBlockingToggleName, changeValueCallback, label);
if (dataOwner == null)
{
Debug.LogError("The target property of the DrawIsBlockingToggleAttribute has to implement IDataOwner.");
return(rect);
}
IBackgroundBehaviorData backgroundBehaviorData = dataOwner.Data as IBackgroundBehaviorData;
if (backgroundBehaviorData == null)
{
return(rect);
}
ITrainingDrawer boolDrawer = DrawerLocator.GetDrawerForValue(backgroundBehaviorData.IsBlocking, typeof(bool));
rect.height += boolDrawer.Draw(new Rect(rect.x, rect.y + rect.height, rect.width, 0), backgroundBehaviorData.IsBlocking, (newValue) =>
{
backgroundBehaviorData.IsBlocking = (bool)newValue;
changeValueCallback(wrapper);
}, "Wait for completion").height;
return(rect);
}
private IList <MetadataWrapper> ConvertReorderableListOfMetadataToList(MetadataWrapper wrapper)
{
if (CheckListOfMetadata(wrapper) == false)
{
return(new List <MetadataWrapper>());
}
if (wrapper.Metadata.Count > 1)
{
throw new NotImplementedException($"ReorderableListOfAttribute attribute should have the lowest priority. Check MetadataWrapperDrawer.Draw method.");
}
ListOfAttribute.Metadata wrapperMetadata = (wrapper.Metadata[reorderableListOfName] as ListOfAttribute.Metadata);
List <Dictionary <string, object> > listOfMetadata = wrapperMetadata.ChildMetadata;
int wrapperCount = ((IList)wrapper.Value).Count;
if (listOfMetadata == null)
{
listOfMetadata = new List <Dictionary <string, object> >(wrapperCount);
}
if (listOfMetadata.Count != wrapperCount)
{
listOfMetadata.Clear();
for (int i = 0; i < wrapperCount; i++)
{
listOfMetadata.Add(wrapperMetadata.ChildAttributes.ToDictionary(attribute => attribute.Name, attribute => attribute.GetDefaultMetadata(null)));
listOfMetadata[i].Add(reorderableName, new ReorderableElementMetadata());
}
}
return(GetListOfWrappers(wrapper, listOfMetadata));
}
private Rect DrawDeletable(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label, bool isPartOfHeader)
{
rect = DrawRecursively(rect, wrapper, deletableName, changeValueCallback, label);
Vector2 buttonSize = new Vector2(EditorGUIUtility.singleLineHeight + 3, EditorDrawingHelper.SingleLineHeight);
GUIStyle style = GetStyle(isPartOfHeader);
if (GUI.Button(new Rect(rect.x + rect.width - buttonSize.x, rect.y + 1, buttonSize.x, buttonSize.y), deleteIcon.Texture, style))
{
object oldValue = wrapper.Value;
ChangeValue(() =>
{
wrapper.Value = null;
return(wrapper);
},
() =>
{
wrapper.Value = oldValue;
return(wrapper);
},
changeValueCallback);
}
return(rect);
}
private Rect DrawFoldable(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label, bool isPartOfHeader)
{
if (wrapper.Metadata[foldableName] == null)
{
wrapper.Metadata[foldableName] = true;
changeValueCallback(wrapper);
}
bool oldIsFoldedOutValue = (bool)wrapper.Metadata[foldableName];
GUIStyle foldoutStyle = new GUIStyle(EditorStyles.foldout)
{
fontStyle = FontStyle.Bold,
fontSize = 12
};
GUIStyle labelStyle = new GUIStyle(EditorStyles.label)
{
fontStyle = FontStyle.Bold,
fontSize = 12
};
Rect foldoutRect = new Rect(rect.x, rect.y, rect.width, EditorDrawingHelper.HeaderLineHeight);
if (isPartOfHeader)
{
EditorGUI.DrawRect(new Rect(0, foldoutRect.y, foldoutRect.width + foldoutRect.x + 8, foldoutRect.height), new Color(62f / 256f, 62f / 256f, 62f / 256f));
EditorGUI.DrawRect(new Rect(0, foldoutRect.y, foldoutRect.width + foldoutRect.x + 8, 1), new Color(26f / 256f, 26f / 256f, 26f / 256f));
EditorGUI.DrawRect(new Rect(0, foldoutRect.y + foldoutRect.height, foldoutRect.width + foldoutRect.x + 8, 1), new Color(48f / 256f, 48f / 256f, 48f / 256f));
}
bool newIsFoldedOutValue = EditorDrawingHelper.DrawFoldoutWithReducedFocusArea(foldoutRect, oldIsFoldedOutValue, oldIsFoldedOutValue ? new GUIContent() : label, foldoutStyle, labelStyle);
if (newIsFoldedOutValue != oldIsFoldedOutValue)
{
wrapper.Metadata[foldableName] = newIsFoldedOutValue;
changeValueCallback(wrapper);
}
// Collapsed
if (newIsFoldedOutValue == false)
{
rect.height = EditorDrawingHelper.HeaderLineHeight;
return(rect);
}
rect.height = 0f;
Rect wrappedRect = rect;
wrappedRect.x += EditorDrawingHelper.IndentationWidth;
wrappedRect.width -= EditorDrawingHelper.IndentationWidth;
return(DrawRecursively(wrappedRect, wrapper, foldableName, (newWrapper) =>
{
// We want the user to be aware that value has changed even if the foldable was collapsed (for example, undo/redo).
wrapper.Metadata[foldableName] = true;
changeValueCallback(wrapper);
}, label));
}
private Rect DrawWrapperRecursively(Rect rect, MetadataWrapper parentWrapper, Action <object> changeValueCallback, string removedMetadataName, GUIContent label)
{
MetadataWrapper wrappedWrapper = new MetadataWrapper()
{
Value = parentWrapper.Value,
ValueDeclaredType = parentWrapper.ValueDeclaredType,
Metadata = parentWrapper.Metadata.Where(kvp => kvp.Key != removedMetadataName).ToDictionary(kvp => kvp.Key, kvp => kvp.Value)
};
Action <object> wrappedWrapperChanged = (newValue) =>
{
MetadataWrapper newWrapper = (MetadataWrapper)newValue;
foreach (string key in newWrapper.Metadata.Keys)
{
parentWrapper.Metadata[key] = wrappedWrapper.Metadata[key];
}
parentWrapper.Value = newWrapper.Value;
changeValueCallback(parentWrapper);
};
rect.height = Draw(rect, wrappedWrapper, wrappedWrapperChanged, label).height;
return(rect);
}
private Rect DrawReorderableListOf(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
IList <MetadataWrapper> listOfWrappers = ConvertReorderableListOfMetadataToList(wrapper);
ITrainingDrawer valueDrawer = DrawerLocator.GetDrawerForValue(wrapper.Value, wrapper.ValueDeclaredType);
IList list = (IList)wrapper.Value;
for (int i = 0; i < listOfWrappers.Count; i++)
{
ReorderableElementMetadata metadata = (ReorderableElementMetadata)listOfWrappers[i].Metadata[reorderableName];
metadata.IsFirst = i == 0;
metadata.IsLast = i == listOfWrappers.Count - 1;
}
return(valueDrawer.Draw(rect, listOfWrappers, (newValue) =>
{
List <MetadataWrapper> newListOfWrappers = ((List <MetadataWrapper>)newValue).ToList();
for (int i = 0; i < newListOfWrappers.Count; i++)
{
ReorderableElementMetadata metadata = (ReorderableElementMetadata)newListOfWrappers[i].Metadata[reorderableName];
if (metadata.MoveDown && metadata.MoveUp == false)
{
metadata.MoveDown = false;
if (i < newListOfWrappers.Count - 1)
{
MetadataWrapper oldElement = newListOfWrappers[i];
newListOfWrappers[i] = newListOfWrappers[i + 1];
newListOfWrappers[i + 1] = oldElement;
}
// Repeat at same index because unprocessed element switched position to i.
i--;
}
else if (metadata.MoveDown == false && metadata.MoveUp)
{
metadata.MoveUp = false;
if (i > 0)
{
MetadataWrapper oldElement = newListOfWrappers[i];
newListOfWrappers[i] = newListOfWrappers[i - 1];
newListOfWrappers[i - 1] = oldElement;
}
}
else
{
// Reset, if both actions are true
metadata.MoveDown = false;
metadata.MoveUp = false;
}
}
ReflectionUtils.ReplaceList(ref list, newListOfWrappers.Select(childWrapper => childWrapper.Value));
wrapper.Value = list;
((ListOfAttribute.Metadata)wrapper.Metadata[reorderableListOfName]).ChildMetadata = newListOfWrappers.Select(childWrapper => childWrapper.Metadata).ToList();
changeValueCallback(wrapper);
}, label));
}
public virtual MetadataWrapper generateMetadataWrapper()
{
ObjectMetadata agentMeta = new ObjectMetadata();
agentMeta.name = "agent";
agentMeta.position = transform.position;
agentMeta.rotation = transform.eulerAngles;
agentMeta.cameraHorizon = m_Camera.transform.rotation.eulerAngles.x;
if (agentMeta.cameraHorizon > 180)
{
agentMeta.cameraHorizon -= 360;
}
MetadataWrapper metaMessage = new MetadataWrapper();
metaMessage.agent = agentMeta;
metaMessage.sceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
metaMessage.objects = generateObjectMetadata();
metaMessage.collided = collidedObjects.Length > 0;
metaMessage.collidedObjects = collidedObjects;
metaMessage.screenWidth = Screen.width;
metaMessage.screenHeight = Screen.height;
metaMessage.lastAction = lastAction;
metaMessage.lastActionSuccess = lastActionSuccess;
metaMessage.errorMessage = errorMessage;
if (errorCode != ServerActionErrorCode.Undefined)
{
metaMessage.errorCode = Enum.GetName(typeof(ServerActionErrorCode), errorCode);
}
return(metaMessage);
}
public async Task SaveAsync <T>(Guid jobId, T metadata)
where T : class, IDataAcquirerMetadata
{
var metadataWrapper = new MetadataWrapper
{
ComponentId = _componentId,
JobId = jobId,
ComponentMetadata = JObject.FromObject(metadata)
};
var jsonBody = JsonConvert.SerializeObject(metadataWrapper);
var httpContent = new StringContent(jsonBody, Encoding.UTF8, "application/json");
var uri = new Uri(
_routes.BaseUri,
_routes.PostComponentMetadataRoute.Replace("componentId", _componentId));
var response = await _httpClient
.PostAsync(uri, httpContent);
if (!response.IsSuccessStatusCode)
{
var error = await response.Content.ReadAsStringAsync();
throw new InvalidOperationException($"Adding data to storage failed: {error}");
}
}
public static Package ConvertToPackage(Version version)
{
var metadataWrapper = new MetadataWrapper(version.Metadata);
var package = new Package
{
Id = version.Project,
Version = version.Name,
Title = metadataWrapper["Title"],
Authors = metadataWrapper["Authors"],
Copyright = metadataWrapper["Copyrights"],
Description = metadataWrapper["Description"],
IconUrl = metadataWrapper["IconUrl"],
LicenseUrl = metadataWrapper["LicenseUrl"],
ProjectUrl = metadataWrapper["ProjectUrl"],
ReleaseNotes = metadataWrapper["RequireLicenseAcceptance"],
RequireLicenseAcceptance = (metadataWrapper["LicenseUrl"] ?? "").Equals("true", StringComparison.OrdinalIgnoreCase),
Summary = metadataWrapper["Summary"],
Tags = metadataWrapper["Tags"],
Dependencies = metadataWrapper["Dependencies"],
PackageHash = metadataWrapper["PackageHash"] ?? version.PackageHash,
PackageHashAlgorithm = metadataWrapper["PackageHashAlgorithm"] ?? "SHA512",
PackageSize = int.Parse(metadataWrapper["PackageSize"] ?? "-1"),
DownloadCount = int.Parse(metadataWrapper["DownloadCount"] ?? "0"),
LastUpdated = DateTime.UtcNow,
Published = DateTime.UtcNow,
IsLatestVersion = (metadataWrapper["IsLatestVersion"] ?? "").Equals("true", StringComparison.OrdinalIgnoreCase),
IsAbsoluteLatestVersion = (metadataWrapper["IsAbsoluteLatestName"] ?? "").Equals("true", StringComparison.OrdinalIgnoreCase),
};
return(package);
}
private Rect DrawDeletable(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
rect = DrawRecursively(rect, wrapper, deletableName, changeValueCallback, label);
Vector2 buttonSize = new Vector2(EditorGUIUtility.singleLineHeight + 3, EditorDrawingHelper.SingleLineHeight);
GUIStyle style = new GUIStyle(GUI.skin.button)
{
fontStyle = FontStyle.Bold
};
if (GUI.Button(new Rect(rect.x + rect.width - buttonSize.x, rect.y, buttonSize.x, buttonSize.y), "x", style))
{
object oldValue = wrapper.Value;
ChangeValue(() =>
{
wrapper.Value = null;
return(wrapper);
},
() =>
{
wrapper.Value = oldValue;
return(wrapper);
},
changeValueCallback);
}
return(rect);
}
public virtual MetadataWrapper generateMetadataWrapper()
{
ObjectMetadata agentMeta = new ObjectMetadata();
agentMeta.name = "agent";
agentMeta.position = transform.position;
agentMeta.rotation = transform.eulerAngles;
agentMeta.cameraHorizon = m_Camera.transform.rotation.eulerAngles.x;
if (agentMeta.cameraHorizon > 180)
{
agentMeta.cameraHorizon -= 360;
}
MetadataWrapper metaMessage = new MetadataWrapper();
metaMessage.agent = agentMeta;
metaMessage.sceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
metaMessage.objects = generateObjectMetadataForTag("SimObj", false);
metaMessage.collided = collidedObjects.Length > 0;
metaMessage.collidedObjects = collidedObjects;
metaMessage.screenWidth = Screen.width;
metaMessage.screenHeight = Screen.height;
return(metaMessage);
}
public override MetadataWrapper generateMetadataWrapper()
{
MetadataWrapper metadata = base.generateMetadataWrapper();
// For Drone controller, currentTime should be based on
// fixed update passes so use DroneTimeSinceStart instead of TimeSinceStart
metadata.currentTime = DroneTimeSinceStart();
// TODO: clean this up with reflection.
// it works, but will not update when something changes to AgentMetadata
// metadata.agent = new
AgentMetadata baseAgent = metadata.agent;
DroneAgentMetadata droneMeta = new DroneAgentMetadata();
droneMeta.name = "drone";
droneMeta.position = baseAgent.position;
droneMeta.rotation = baseAgent.rotation;
droneMeta.cameraHorizon = baseAgent.cameraHorizon;
droneMeta.inHighFrictionArea = baseAgent.inHighFrictionArea;
// New drone stuff for agent metadata
droneMeta.LauncherPosition = GetLauncherPosition();
metadata.agent = droneMeta;
return(metadata);
}
public override MetadataWrapper generateMetadataWrapper()
{
MetadataWrapper metaMessage = base.generateMetadataWrapper();
metaMessage.lastAction = lastAction;
metaMessage.lastActionSuccess = lastActionSuccess;
metaMessage.errorMessage = errorMessage;
if (errorCode != ServerActionErrorCode.Undefined)
{
metaMessage.errorCode = Enum.GetName(typeof(ServerActionErrorCode), errorCode);
}
List <InventoryObject> ios = new List <InventoryObject>();
foreach (string objectId in inventory.Keys)
{
SimObj so = inventory [objectId];
InventoryObject io = new InventoryObject();
io.objectId = so.UniqueID;
io.objectType = Enum.GetName(typeof(SimObjType), so.Type);
ios.Add(io);
}
metaMessage.inventoryObjects = ios.ToArray();
return(metaMessage);
}
/// <inheritdoc />
public override GUIContent GetLabel(object value, Type declaredType)
{
// Assert that value is never null, as we always call MetadataWrapper on freshly created instance.
MetadataWrapper wrapper = value as MetadataWrapper;
ITrainingDrawer valueDrawer = DrawerLocator.GetDrawerForValue(wrapper.Value, wrapper.ValueDeclaredType);
return(valueDrawer.GetLabel(wrapper.Value, wrapper.ValueDeclaredType));
}
/// <inheritdoc />
public override Rect Draw(Rect rect, object currentValue, Action <object> changeValueCallback, GUIContent label)
{
MetadataWrapper wrapper = (MetadataWrapper)currentValue;
// If the drawn object is a ITransition, IBehavior or ICondition the list object will be part of a header.
bool isPartOfHeader = wrapper.ValueDeclaredType == typeof(ITransition) || wrapper.ValueDeclaredType == typeof(IBehavior) || wrapper.ValueDeclaredType == typeof(ICondition);
if (wrapper.Metadata.ContainsKey(showHelpName))
{
return(DrawHelp(rect, wrapper, changeValueCallback, label, isPartOfHeader));
}
if (wrapper.Metadata.ContainsKey(reorderableName))
{
return(DrawReorderable(rect, wrapper, changeValueCallback, label, isPartOfHeader));
}
if (wrapper.Metadata.ContainsKey(separatedName))
{
return(DrawSeparated(rect, wrapper, changeValueCallback, label));
}
if (wrapper.Metadata.ContainsKey(deletableName))
{
return(DrawDeletable(rect, wrapper, changeValueCallback, label, isPartOfHeader));
}
if (wrapper.Metadata.ContainsKey(foldableName))
{
return(DrawFoldable(rect, wrapper, changeValueCallback, label, isPartOfHeader));
}
if (wrapper.Metadata.ContainsKey(drawIsBlockingToggleName))
{
return(DrawIsBlockingToggle(rect, wrapper, changeValueCallback, label));
}
if (wrapper.Metadata.ContainsKey(extendableListName))
{
return(DrawExtendableList(rect, wrapper, changeValueCallback, label));
}
if (wrapper.Metadata.ContainsKey(keepPopulatedName))
{
return(HandleKeepPopulated(rect, wrapper, changeValueCallback, label));
}
if (wrapper.Metadata.ContainsKey(reorderableListOfName))
{
return(DrawReorderableListOf(rect, wrapper, changeValueCallback, label));
}
if (wrapper.Metadata.ContainsKey(listOfName))
{
return(DrawListOf(rect, wrapper, changeValueCallback, label));
}
throw new NotImplementedException("Wrapper drawer for this kind of metadata is not implemented.");
}
/// <summary>
/// Asynchronously gets metadata for given resource
/// </summary>
/// <param name="uri">Relative or explicit path to a resource/endpoint</param>
/// <param name="verb">Metadata for given verb</param>
/// <param name="Headers">Request headers</param>
/// <returns>Task with metadata</returns>
/// <exception cref="RequestException">HTTP status not successful</exception>
public async Task <MetadataResponse> GetMetadataAsync(string uri, ApiResourceVerb verb, Headers headers = null)
{
var parameters = $"?uri={uri}&verb={verb}";
parameters += "&$expand=ApplicableDomainValues,ExpandableFields,Description,TranslatedDescription,TranslatedName,MacroDefinitions,URIParameters";
string url = "metadata";
ApiResponse response = await _request.PerformRequestAsync(ApiResourceVerb.GET, url, parameters : parameters, headers : headers);
MetadataWrapper metadataResponse = JsonConvert.DeserializeObject <MetadataWrapper>(response.Content);
return(metadataResponse.Metadata);
}
protected MetadataWrapper generateMetadataWrapper()
{
MetadataWrapper metaMessage = base.generateMetadataWrapper();
if (ThorChallengeInfo.IsValidationScene(UnityEngine.SceneManagement.SceneManager.GetActiveScene().name))
{
metaMessage.agent = new ObjectMetadata();
metaMessage.objects = new ObjectMetadata[] {};
metaMessage.collidedObjects = new string[] {};
}
return(metaMessage);
}
private Rect DrawExtendableList(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
if (wrapper.Value == null || wrapper.Value is IList == false)
{
if (wrapper.Value != null)
{
logger.Warn("ExtendableListAttribute can be used only with IList members.");
}
return(rect);
}
Type elementType = (wrapper.Metadata[extendableListName] as ExtendableListAttribute.SerializedTypeWrapper).Type;
IList list = (IList)wrapper.Value;
float currentY = 0;
currentY += DrawRecursively(rect, wrapper, extendableListName, changeValueCallback, label).height;
ITrainingDrawer addThingsDrawer = DrawerLocator.GetInstantiatorDrawer(elementType);
if (addThingsDrawer != null)
{
currentY += addThingsDrawer.Draw(new Rect(rect.x, rect.y + currentY, rect.width, 0), null, (newValue) =>
{
if (newValue == null)
{
ReflectionUtils.RemoveFromList(ref list, list.Count - 1);
}
else
{
ReflectionUtils.InsertIntoList(ref list, list.Count, newValue);
}
if (wrapper.Metadata.ContainsKey(listOfName))
{
ListOfAttribute.Metadata temp = (ListOfAttribute.Metadata)wrapper.Metadata[listOfName];
temp.ChildMetadata.Add(temp.ChildAttributes.ToDictionary(attribute => attribute.Name, attribute => attribute.GetDefaultMetadata(null)));
wrapper.Metadata[listOfName] = temp;
}
wrapper.Value = list;
changeValueCallback(wrapper);
}, "").height;
}
rect.height = currentY;
return(rect);
}
private bool CheckListOfMetadata(MetadataWrapper wrapper)
{
if (wrapper.Value == null || (wrapper.Value is IList == false))
{
if (wrapper.Value != null)
{
Debug.LogWarning($"ListOfAttribute can be used only with IList members.");
}
return(false);
}
return(true);
}
private IEnumerator EmitFrame()
{
frameCounter += 1;
// we should only read the screen buffer after rendering is complete
yield return(new WaitForEndOfFrame());
WWWForm form = new WWWForm();
MultiAgentMetadata multiMeta = new MultiAgentMetadata();
multiMeta.agents = new MetadataWrapper[this.agents.Count];
multiMeta.activeAgentId = this.activeAgentId;
multiMeta.sequenceId = this.currentSequenceId;
RenderTexture currentTexture = RenderTexture.active;
for (int i = 0; i < this.agents.Count; i++)
{
DiscreteRemoteFPSAgentController agent = this.agents.ToArray() [i];
MetadataWrapper metadata = agent.generateMetadataWrapper();
metadata.agentId = i;
// we don't need to render the agent's camera for the first agent
addImageForm(form, agent, i > 0);
addDepthImageForm(form, agent);
addObjectImageForm(form, agent, ref metadata);
addClassImageForm(form, agent);
multiMeta.agents [i] = metadata;
}
RenderTexture.active = currentTexture;
form.AddField("metadata", JsonUtility.ToJson(multiMeta));
form.AddField("token", robosimsClientToken);
WWW w = new WWW("http://" + robosimsHost + ":" + robosimsPort + "/train", form);
yield return(w);
if (!string.IsNullOrEmpty(w.error))
{
Debug.Log("Error: " + w.error);
yield break;
}
else
{
ProcessControlCommand(w.text);
}
}
private Rect DrawReorderable(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label, bool isPartOfHeader)
{
rect = DrawRecursively(rect, wrapper, reorderableName, changeValueCallback, label);
Vector2 buttonSize = new Vector2(EditorGUIUtility.singleLineHeight + 3f, EditorDrawingHelper.SingleLineHeight);
GUIStyle style = GetStyle(isPartOfHeader);
GUI.enabled = ((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).IsLast == false;
if (GUI.Button(new Rect(rect.x + rect.width - buttonSize.x * 2, rect.y + 1, buttonSize.x, buttonSize.y), arrowDownIcon.Texture, style))
{
object oldValue = wrapper.Value;
ChangeValue(() =>
{
((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).MoveDown = true;
return(wrapper);
},
() =>
{
((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).MoveDown = false;
wrapper.Value = oldValue;
return(wrapper);
},
changeValueCallback);
}
GUI.enabled = ((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).IsFirst == false;
if (GUI.Button(new Rect(rect.x + rect.width - buttonSize.x * 3, rect.y + 1, buttonSize.x, buttonSize.y), arrowUpIcon.Texture, style))
{
object oldValue = wrapper.Value;
ChangeValue(() =>
{
((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).MoveUp = true;
return(wrapper);
},
() =>
{
((ReorderableElementMetadata)wrapper.Metadata[reorderableName]).MoveUp = false;
wrapper.Value = oldValue;
return(wrapper);
},
changeValueCallback);
}
GUI.enabled = true;
return(rect);
}
private Rect DrawSeparated(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
EditorDrawingHelper.DrawRect(new Rect(0f, rect.y - 1f, rect.x + rect.width, 1f), Color.grey);
Rect wrappedRect = rect;
wrappedRect.y += EditorDrawingHelper.VerticalSpacing;
wrappedRect = DrawRecursively(wrappedRect, wrapper, separatedName, changeValueCallback, label);
wrappedRect.height += EditorDrawingHelper.VerticalSpacing;
EditorDrawingHelper.DrawRect(new Rect(0f, wrappedRect.y + wrappedRect.height - 1f, wrappedRect.x + wrappedRect.width, 1f), Color.grey);
rect.height = wrappedRect.height;
return(rect);
}
private Rect DrawListOf(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
IList <MetadataWrapper> listOfWrappers = ConvertListOfMetadataToList(wrapper);
ITrainingDrawer valueDrawer = DrawerLocator.GetDrawerForValue(wrapper.Value, wrapper.ValueDeclaredType);
IList list = (IList)wrapper.Value;
return(valueDrawer.Draw(rect, listOfWrappers, (newValue) =>
{
List <MetadataWrapper> newListOfWrappers = ((List <MetadataWrapper>)newValue).ToList();
ReflectionUtils.ReplaceList(ref list, newListOfWrappers.Select(childWrapper => childWrapper.Value));
wrapper.Value = list;
((ListOfAttribute.Metadata)wrapper.Metadata[listOfName]).ChildMetadata = newListOfWrappers.Select(childWrapper => childWrapper.Metadata).ToList();
changeValueCallback(wrapper);
}, label));
}
private Rect DrawHelp(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label, bool isPartOfHeader)
{
rect = DrawRecursively(rect, wrapper, showHelpName, changeValueCallback, label);
Vector2 buttonSize = new Vector2(EditorGUIUtility.singleLineHeight + 3f, EditorDrawingHelper.SingleLineHeight);
GUIStyle style = GetStyle(isPartOfHeader);
if (wrapper.Value != null && wrapper.Value.GetType() != null)
{
HelpLinkAttribute helpLinkAttribute = wrapper.Value.GetType().GetCustomAttribute(typeof(HelpLinkAttribute)) as HelpLinkAttribute;
if (helpLinkAttribute != null)
{
if (GUI.Button(new Rect(rect.x + rect.width - buttonSize.x * 4 - 0.1f, rect.y + 1, buttonSize.x, buttonSize.y), helpIcon.Texture, style))
{
Application.OpenURL(helpLinkAttribute.HelpLink);
}
}
}
return(rect);
}
// Saves the current session to a session file.
private void SaveCurrentSession(string filePath)
{
string[] attributeNames = { "archivePath", "historianId", "export", "display" };
XmlDocument doc = new XmlDocument();
XmlElement root = doc.CreateElement("historianDataViewer");
XmlAttribute startTime = doc.CreateAttribute("startTime");
XmlAttribute endTime = doc.CreateAttribute("endTime");
doc.AppendChild(doc.CreateXmlDeclaration("1.0", "UTF-8", string.Empty));
doc.AppendChild(root);
startTime.Value = StartTime.ToString("MM/dd/yyyy HH:mm:ss.fff");
endTime.Value = EndTime.ToString("MM/dd/yyyy HH:mm:ss.fff");
root.Attributes.Append(startTime);
root.Attributes.Append(endTime);
foreach (ArchiveFile archive in m_archiveFiles)
{
foreach (MetadataRecord record in archive.MetadataFile.Read())
{
MetadataWrapper wrapper = m_metadata.Single(wrap => wrap.GetMetadata().HistorianID == record.HistorianID);
if (wrapper.Export || wrapper.Display)
{
string[] attributeValues = { archive.FileName, record.HistorianID.ToString(), wrapper.Export.ToString(), wrapper.Display.ToString() };
XmlElement metadataElement = doc.CreateElement("metadata");
for (int i = 0; i < attributeNames.Length; i++)
{
XmlAttribute attribute = doc.CreateAttribute(attributeNames[i]);
attribute.Value = attributeValues[i];
metadataElement.Attributes.Append(attribute);
}
root.AppendChild(metadataElement);
}
}
}
doc.Save(filePath);
m_currentSessionPath = filePath;
//this.Title = System.Windows.Shapes.Path.GetFileName(filePath) + " - Historian Data Viewer";
}
private IList <MetadataWrapper> GetListOfWrappers(MetadataWrapper wrapper, List <Dictionary <string, object> > listOfMetadata)
{
Type entryType = ReflectionUtils.GetEntryType(wrapper.Value);
IList wrapperValueList = (IList)wrapper.Value;
List <MetadataWrapper> listOfWrappers = new List <MetadataWrapper>();
for (int i = 0; i < wrapperValueList.Count; i++)
{
listOfWrappers.Add(new MetadataWrapper()
{
Metadata = listOfMetadata[i],
ValueDeclaredType = entryType,
Value = wrapperValueList[i],
});
}
return(listOfWrappers);
}
public Version[] GetPackages(ref Repository repository, ref PackageFilter filter, string packageFormat, string projectId)
{
var repositoryCopy = repository;
var versions = (projectId == null ? Directory.EnumerateDirectories(configuration.DataPath) : Directory.EnumerateDirectories(configuration.DataPath, projectId))
.SelectMany(
projectPath =>
Directory.EnumerateDirectories(projectPath)
.Select(
versionPath =>
new Version
{
Company = repositoryCopy.Company,
Repository = repositoryCopy.Name,
Project = Path.GetFileName(projectPath),
Name = Path.GetFileName(versionPath),
PackageFormat = packageFormat,
})
.Where(version => GetPackagePathFromVersion(version, packageFormat) != null)
.Select(version => new Version
{
Company = version.Company,
Repository = version.Repository,
Project = version.Project,
Name = version.Name,
PackageFormat = "SHA512",
PackageHash = GetPackageSHA512(GetPackagePathFromVersion(version, packageFormat)),
})
)
.OrderByDescending(v => v.Name)
.ToArray();
foreach (var version in versions)
{
bool isLatest = versions.Where(v => v.Project == version.Project).Select(v => v.Name).FirstOrDefault() == version.Name;
var metadata = new List <MetadataEntry>(GetPackageMetadata(GetPackagePathFromVersion(version, packageFormat), packageFormat) ?? new MetadataEntry[0]);
var metadataWrapper = new MetadataWrapper(metadata);
metadataWrapper["IsLatestVersion"] = isLatest.ToString();
version.Metadata = metadata.ToArray();
}
return(versions);
}
protected virtual MetadataWrapper generateMetadataWrapper()
{
ObjectMetadata agentMeta = new ObjectMetadata();
agentMeta.name = "agent";
agentMeta.position = transform.position;
agentMeta.rotation = transform.eulerAngles;
agentMeta.cameraHorizon = m_Camera.transform.rotation.eulerAngles.x;
MetadataWrapper metaMessage = new MetadataWrapper();
metaMessage.agent = agentMeta;
metaMessage.objects = generateObjectMetadataForTag("SimObj", false);
metaMessage.collided = collidedObjects.Length > 0;
metaMessage.collidedObjects = collidedObjects;
metaMessage.screenWidth = Screen.width;
metaMessage.screenHeight = Screen.height;
return(metaMessage);
}
private Rect DrawRecursively(Rect rect, MetadataWrapper wrapper, string currentDrawerName, Action <object> changeValueCallback, GUIContent label)
{
// There are more metadata information to handle, pass it to the next iteration.
if (wrapper.Metadata.Count > 1)
{
rect = DrawWrapperRecursively(rect, wrapper, changeValueCallback, currentDrawerName, label);
}
else
{
// Draw an actual object.
ITrainingDrawer valueDrawer = DrawerLocator.GetDrawerForValue(wrapper.Value, wrapper.ValueDeclaredType);
Action <object> valueChanged = (newValue) =>
{
wrapper.Value = newValue;
changeValueCallback(wrapper);
};
rect = valueDrawer.Draw(rect, wrapper.Value, valueChanged, label);
}
return(rect);
}
private Rect HandleKeepPopulated(Rect rect, MetadataWrapper wrapper, Action <object> changeValueCallback, GUIContent label)
{
if (wrapper.Value == null || (wrapper.Value is IList == false))
{
if (wrapper.Value != null)
{
Debug.LogWarning("KeepPopulated can be used only with IList members.");
}
return(rect);
}
IList list = (IList)wrapper.Value;
if (list.Count == 0)
{
Type entryType = (Type)wrapper.Metadata[keepPopulatedName];
if (entryType != null)
{
Type listType = ReflectionUtils.GetEntryType(list);
if (listType.IsAssignableFrom(entryType))
{
ReflectionUtils.InsertIntoList(ref list, 0, ReflectionUtils.CreateInstanceOfType(entryType));
}
else
{
Debug.LogErrorFormat("Trying to add an keep populuated entry with type {0} to list filled {1}", entryType.Name, listType.Name);
}
}
else
{
Debug.LogError("No Type found to create default instance with");
}
}
return(DrawRecursively(rect, wrapper, keepPopulatedName, changeValueCallback, label));
}
