public override string ToString() { var sources = string.Join(", ", SourceNodes.Select(x => x.GetType().Name)); var targets = string.Join(", ", TargetNodes.Select(x => x.GetType().Name)); return($"{ThisNode.GetType().Name}, Builder='{Builder.Name}', Sources=[{sources}], Targets=[{targets}]"); }
//Validate that the we are using valid colors and set appropriate defaults if not. private void CheckForInvalidColorData() { // check for sane default colors when first rendering it HashSet <Color> validColors = new HashSet <Color>(); validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true))); //Validate Color 1 if (validColors.Any() && (!validColors.Contains(_data.Color1.ToArgb()) || !_data.ColorGradient1.GetColorsInGradient().IsSubsetOf(validColors))) { Color1 = validColors.First(); ColorGradient1 = new ColorGradient(validColors.First()); } //Validate color 2 if (validColors.Any() && (!validColors.Contains(_data.Color2.ToArgb()) || !_data.ColorGradient2.GetColorsInGradient().IsSubsetOf(validColors))) { if (validColors.Count > 1) { Color2 = validColors.ElementAt(1); ColorGradient2 = new ColorGradient(validColors.ElementAt(1)); } else { Color2 = validColors.First(); ColorGradient2 = new ColorGradient(validColors.First()); } } }
public IEffectNode CreateEffectNode(Dictionary <Guid, ElementNode> elementNodes) { // Create a element node lookup of elements that are currently valid. //Currently we only have one TargetNode per effect, so removing all the extra junk that sorts though //Multiples. If it changes in the future, we can change this around. //IEnumerable<Guid> targetNodeIds = TargetNodes.Select(x => x.NodeId); //IEnumerable<Guid> validElementIds = targetNodeIds.Intersect(elementNodes.Keys); IEffectModuleInstance effect = Modules.ModuleManagement.GetEffect(TypeId); effect.InstanceId = InstanceId; effect.TimeSpan = TimeSpan; effect.StartTime = StartTime; //effect.TargetNodes = validElementIds.Select(x => elementNodes[x]).ToArray(); if (elementNodes.TryGetValue(TargetNodes.First().NodeId, out var node)) { effect.TargetNodes = new IElementNode[] { node }; } else { effect.TargetNodes = new IElementNode[] { new ProxyElementNode(TargetNodes.First().NodeId, TargetNodes.First().Name) }; } return(new EffectNode(effect, StartTime)); }
protected override void TargetNodesChanged() { if (TargetNodes.Any()) { CheckForInvalidColorData(); } }
private List <ElementNode> GetNodesToRenderOn() { IEnumerable <ElementNode> renderNodes = null; if (DepthOfEffect == 0) { renderNodes = TargetNodes.SelectMany(x => x.GetLeafEnumerator()).ToList(); } else { renderNodes = TargetNodes; for (int i = 0; i < DepthOfEffect; i++) { renderNodes = renderNodes.SelectMany(x => x.Children); } } // If the given DepthOfEffect results in no nodes (because it goes "too deep" and misses all nodes), // then we'll default to the LeafElements, which will at least return 1 element (the TargetNode) if (!renderNodes.Any()) { renderNodes = TargetNodes.SelectMany(x => x.GetLeafEnumerator()); } return(renderNodes.ToList()); }
public EffectIntents Render() { if (IsDirty && !IsRendering) { IsRendering = true; try { PreRender(); } catch (Exception e) { //Trap any errors to prevent the effect from staying in a state of rendering. Logging.Error(e, $"Error rendering {EffectName} on element {TargetNodes?.FirstOrDefault()?.Name}"); Logging.Error($"Error rendering Effect Property settings: {PropertyInfo()}"); } finally { IsRendering = false; } } else { //To prevent the effect from being rendered multiple times if multiple threads //try to access it all at the same time. I.E the editor pre rendering process. while (IsRendering) { Thread.Sleep(1); } } return(_Render()); }
private IEnumerable <IElementNode> GetNodesToRenderOn() { IEnumerable <IElementNode> renderNodes = TargetNodes; renderNodes = TargetNodes.SelectMany(x => x.GetLeafEnumerator()); return(renderNodes); }
private void CalculateAffectedElements() { if (TargetNodes == null || TargetNodes.Length == 0) { EffectedElementIds = Enumerable.Empty <Guid>(); } EffectedElementIds = TargetNodes.SelectMany(y => y.GetElementEnumerator()).Select(z => z.Id); }
protected override void _PreRender() { _effectIntents = new EffectIntents(); _r = new Random(); foreach (Element element in TargetNodes.SelectMany(x => x)) { _RenderCandleOnElement(element); } }
protected override void TargetNodesChanged() { CheckForInvalidColorData(); var firstNode = TargetNodes.FirstOrDefault(); if (firstNode != null && DepthOfEffect > firstNode.GetMaxChildDepth() - 1) { DepthOfEffect = 0; } }
/// <summary> /// Performs encoding transformation for each <c>XmlElement</c> of <c>App.config</c> where <c>Encode</c> transform is applied for. /// </summary> protected override void Apply() { //If target node has no attributes - skip the transform: if (TargetNode.Attributes == null) { return; } //Getting list of passed XPath arguments to this Encode instance: var encodeXPathArguments = new List <string>(); if (Arguments != null) { encodeXPathArguments.AddRange(Arguments); } //Adding DefaultAttributeName to XPath arguments if it's not present: if (!encodeXPathArguments.Contains(DefaultAttributeName)) { encodeXPathArguments.Add(DefaultAttributeName); } //Looping thru TargetNodes foreach (var targetNode in TargetNodes.OfType <XmlElement>()) { //For each TargetNode looping thru encodeXPathArguments foreach (var arg in encodeXPathArguments) { //Getting TargetNode.XmlNode by XPath arg: var destinationNode = targetNode.SelectSingleNode(arg); if (destinationNode == null) { continue; } //TransformNode.XmlNode by XPath arg: var applyTransformNode = TransformNode.SelectSingleNode(arg); //Determine which XmlNode.InnerText to encode: string valueToEncode = applyTransformNode == null || string.IsNullOrEmpty(applyTransformNode.InnerText) ? destinationNode.InnerText //Getting default destination XmlNode.InnerText : applyTransformNode.InnerText; //Getting XmlNode.InnerText specified in App.config transformer if (string.IsNullOrEmpty(valueToEncode)) { continue; } //If valueToEncode is OK - then encrypt it and assign to destination XmlNode.InnerText: destinationNode.InnerText = _encryptorDecryptor.Encrypt(valueToEncode); } } }
protected override void TargetNodesChanged() { if (TargetNodes.Any()) { CheckForInvalidColorData(); if (DepthOfEffect > TargetNodes.FirstOrDefault().GetMaxChildDepth() - 1) { DepthOfEffect = 0; } } }
/// <summary> /// Gets the list of valid colors this effect can use and sets the hasDiscreteColors flag if any of it's targeted elements are discrete and have a restricted list. /// </summary> /// <returns></returns> protected HashSet <Color> GetValidColors() { HashSet <Color> validColors = new HashSet <Color>(); validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true))); if (validColors.Any()) { HasDiscreteColors = true; } return(validColors); }
private void CheckForInvalidColorData() { HashSet <Color> validColors = new HashSet <Color>(); validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true))); if (validColors.Any() && !_data.ColorGradient.GetColorsInGradient().IsSubsetOf(validColors)) { //Our color is not valid for any elements we have. //Try to set a default color gradient from our available colors _data.ColorGradient = new ColorGradient(validColors.First()); } }
//Validate that the we are using valid colors and set appropriate defaults if not. private void CheckForInvalidColorData() { HashSet <Color> validColors = new HashSet <Color>(); validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true))); if (validColors.Any() && !validColors.Contains(_data.color.ToArgb())) { //Our color is not valid for any elements we have. //Set a default color Color = validColors.First(); } }
//Validate that the we are using valid colors and set appropriate defaults if not. private void CheckForInvalidColorData() { HashSet <Color> validColors = new HashSet <Color>(); validColors.AddRange(TargetNodes.SelectMany(x => ColorModule.getValidColorsForElementNode(x, true))); if (validColors.Any() && (!validColors.Contains(_data.StaticColor) || !_data.ColorGradient.GetColorsInGradient().IsSubsetOf(validColors))) //Discrete colors specified { _data.ColorGradient = new ColorGradient(validColors.DefaultIfEmpty(Color.White).First()); _data.StaticColor = validColors.First(); } }
private void ConfigureVirtualBuffer() { ElementLocations = TargetNodes.SelectMany(x => x.GetLeafEnumerator()).Select(x => new ElementLocation(x)).ToList(); var xMax = ElementLocations.Max(p => p.X); var xMin = ElementLocations.Min(p => p.X); var yMax = ElementLocations.Max(p => p.Y); var yMin = ElementLocations.Min(p => p.Y); _bufferWi = (yMax - yMin) + 1; _bufferHt = (xMax - xMin) + 1; _bufferWiOffset = yMin; _bufferHtOffset = xMin; }
protected override void _PreRender(CancellationTokenSource cancellationToken = null) { _effectIntents = new EffectIntents(); _r = new Random(); var nodes = TargetNodes.SelectMany(x => x.GetLeafEnumerator()); var elementGroup = nodes.Select((x, index) => new { x, index }) .GroupBy(x => x.index / GroupLevel, y => y.x); foreach (IGrouping <int, ElementNode> block in elementGroup) { _RenderCandleOnElements(block.GetElements().ToList()); } }
protected void SetOrientation() { var orientation = OrientationModule.GetOrientationForElement(TargetNodes.First()); switch (orientation) { case Orientation.Horizontal: StringOrientation = StringOrientation.Horizontal; break; default: StringOrientation = StringOrientation.Vertical; break; } }
public ISequenceFilterNode CreateFilterNode() { var elementNodes = VixenSystem.Nodes.Distinct().ToDictionary(x => x.Id); IEnumerable <Guid> targetNodeIds = TargetNodes.Select(x => x.NodeId); IEnumerable <Guid> validElementIds = targetNodeIds.Intersect(elementNodes.Keys); ISequenceFilterModuleInstance filter = Modules.ModuleManagement.GetSequenceFilter(TypeId); filter.InstanceId = InstanceId; filter.TimeSpan = TimeSpan; filter.TargetNodes = validElementIds.Select(x => elementNodes[x]).ToArray(); return(new SequenceFilterNode(filter, StartTime)); }
public IEffectNode CreateEffectNode() { // Create a element node lookup of elements that are currently valid. var elementNodes = VixenSystem.Nodes.Distinct().ToDictionary(x => x.Id); IEnumerable <Guid> targetNodeIds = TargetNodes.Select(x => x.NodeId); IEnumerable <Guid> validElementIds = targetNodeIds.Intersect(elementNodes.Keys); IEffectModuleInstance effect = Modules.ModuleManagement.GetEffect(TypeId); effect.InstanceId = InstanceId; effect.TimeSpan = TimeSpan; effect.TargetNodes = validElementIds.Select(x => elementNodes[x]).ToArray(); return(new EffectNode(effect, StartTime)); }
protected override void _PreRender(CancellationTokenSource cancellationToken = null) { _effectIntents = new EffectIntents(); _r = new Random(); var nodes = TargetNodes.SelectMany(x => x.GetLeafEnumerator()); var elementGroup = nodes.Select((x, index) => new { x, index }) .GroupBy(x => x.index / GroupLevel, y => y.x); foreach (IGrouping <int, IElementNode> block in elementGroup) { _RenderCandleOnElements(block.ToList()); } //_effectIntents = IntentBuilder.ConvertToStaticArrayIntents(_effectIntents, TimeSpan, IsDiscrete()); }
protected override void _PreRender(CancellationTokenSource cancellationToken = null) { _elementData = new EffectIntents(); var targetNodes = TargetNodes.AsParallel(); if (cancellationToken != null) { targetNodes = targetNodes.WithCancellation(cancellationToken.Token); } targetNodes.ForAll(node => { if (node != null) { RenderNode(node); } }); }
protected override void _PreRender(CancellationTokenSource cancellationToken = null) { _effectIntents = new EffectIntents(); _r = new Random(); foreach (Element element in TargetNodes.SelectMany(x => x)) { if (cancellationToken != null && cancellationToken.IsCancellationRequested) { return; } if (element != null) { _RenderCandleOnElement(element); } } }
/// <summary> /// Sets the fixed attribute values from <see cref="AbstractSolver{T}.TargetNodes"/> and /// from <see cref="AdvancedSolverSettings.InitialAttributes"/>. /// </summary> private void CreateFixedAttributes() { _fixedNodes = TargetNodes.Select(n => n.Id).ToList(); // Set start stats from start and target nodes. AddAttributes(_fixedNodes, _fixedAttributes); // Add the initial stats from the settings. foreach (var initialStat in Settings.InitialAttributes) { var name = initialStat.Key; if (_attrNameLookup.ContainsKey(name)) { foreach (var i in _attrNameLookup[name]) { _fixedAttributes[i] += initialStat.Value * _attrConversionMultipliers[Tuple.Create(name, i)]; } } } }
protected override void _PreRender(CancellationTokenSource cancellationToken = null) { _elementData = new EffectIntents(); var value = new CommandValue(new StringCommand(string.Format("{0}|{1},{2}", "Launcher", _data.Executable, _data.Arguments))); var targetNodes = TargetNodes.AsParallel(); if (cancellationToken != null) { targetNodes = targetNodes.WithCancellation(cancellationToken.Token); } targetNodes.ForAll(node => { IIntent i = new CommandIntent(value, TimeSpan); _elementData.AddIntentForElement(node.Element.Id, i, TimeSpan.Zero); }); }
// renders the given node to the internal ElementData dictionary. If the given node is // not a element, will recursively descend until we render its elements. private void RenderNodes() { var renderNodes = TargetNodes.SelectMany(x => x.GetNodeEnumerator()); if (LipSyncMode == LipSyncMode.MarkCollection) { SetupMarks(); } PhonemeType phoneme = _data.StaticPhoneme; if (MappingType == MappingType.Map) { if (!_library.Library.ContainsKey(_data.PhonemeMapping)) { _data.PhonemeMapping = _library.DefaultMappingName; } LipSyncMapData mapData; if (_library.Library.TryGetValue(_data.PhonemeMapping, out mapData)) { if (mapData.IsMatrix) { RenderMapMatrix(mapData, phoneme); } else { //We should never get here becasue we no longer have string maps Logging.Error("Trying to render as deprecated string maps!"); foreach (var element in renderNodes) { RenderMapElements(mapData, element, phoneme); } } } } else { foreach (var element in renderNodes) { RenderPropertyMapElements(element, phoneme); } } }
private IEnumerable <ElementNode> FindLeafParents() { var nodes = new List <ElementNode>(); var nonLeafElements = new List <ElementNode>(); if (TargetNodes.FirstOrDefault() != null) { nonLeafElements = TargetNodes.SelectMany(x => x.GetNonLeafEnumerator()).ToList(); foreach (var elementNode in TargetNodes) { foreach (var leafNode in elementNode.GetLeafEnumerator()) { nodes.AddRange(leafNode.Parents); } } } //Some nodes can have multiple node parents with odd groupings so this fancy linq query makes sure that the parent //node is part of the Target nodes lineage. return(nodes.Distinct().Intersect(nonLeafElements)); }
void selectTargetNode() { selectTargetTransform(); if (_targetTransform == null) { return; } TargetNodes targetNodes = _targetTransform.GetComponent <TargetNodes>(); Pathfinding.GraphNode targetNode = targetNodes.GetClosestNode(_transform.position); if (targetNode == null) { return; } _aiPath.destination = (Vector3)targetNode.position; }
protected override void TargetNodesChanged() { if (TargetNodes.Any()) { if (TargetNodes.Length > 1) { DepthOfEffect = 0; } else { CheckForInvalidColorData(); var firstNode = TargetNodes.FirstOrDefault(); if (firstNode != null && DepthOfEffect > firstNode.GetMaxChildDepth() - 1) { DepthOfEffect = 0; } } } UpdateTargetingAttributes(); TypeDescriptor.Refresh(this); }