private IEnumerator SortRoutine()
{
while (true)
{
using (PooledList <Transform> children = PooledList <Transform> .Create())
{
if (children.Capacity < SortGroup.childCount)
{
children.Capacity = SortGroup.childCount;
}
for (int i = 0; i < SortGroup.childCount; ++i)
{
children.Add(SortGroup.GetChild(i));
}
children.Sort(s_HeightSorter);
for (int i = 0; i < children.Count; ++i)
{
children[i].SetSiblingIndex(i);
}
if (Controller.DraggingObject != null && Controller.DraggingObject.transform.parent == SortGroup)
{
Controller.DraggingObject.transform.SetAsLastSibling();
}
}
yield return(0.05f);
}
}
private IEnumerator EggAnimationRoutine(int inNumToSend)
{
using (PooledList <Transform> targetPositions = PooledList <Transform> .Create())
{
for (int i = 0; i < inNumToSend; ++i)
{
targetPositions.Add(Counter.GetNextSlot(i + 1));
}
SteerableBehavior lastEgg = null;
for (int i = 0; i < inNumToSend; ++i)
{
lastEgg = m_Eggs[m_Eggs.Count - 1];
m_Eggs.RemoveAt(m_Eggs.Count - 1);
m_AnimatingEggs.Add(lastEgg);
SendEggToDestination(lastEgg, targetPositions[i]);
yield return(TimeBetweenEggs);
}
if (m_Eggs.Count == 0 && TwoPhase == false)
{
while (lastEgg != null && lastEgg.IsMoving)
{
yield return(null);
}
if (OnFinished != null)
{
OnFinished();
}
}
TwoPhase = false;
}
}
public void CheckNullValueProcessTag(string key, object value)
{
var attributeEnumerationState = new AttributeEnumerationState
{
Tags = PooledList <KeyValuePair <string, object> > .Create(),
};
ProcessTags(ref attributeEnumerationState, new KeyValuePair <string, object>(key, value));
Assert.Empty(attributeEnumerationState.Tags);
}
public void CheckProcessTag(string key, object value)
{
var attributeEnumerationState = new AttributeEnumerationState
{
Tags = PooledList <KeyValuePair <string, object> > .Create(),
};
ProcessTags(ref attributeEnumerationState, new KeyValuePair <string, object>(key, value));
Assert.Equal(key, attributeEnumerationState.Tags[0].Key);
Assert.Equal(value, attributeEnumerationState.Tags[0].Value);
}
public bool ForEach(ActivityLink activityLink)
{
if (!this.Created)
{
this.Links = PooledList <OtlpTrace.Span.Types.Link> .Create();
this.Created = true;
}
PooledList <OtlpTrace.Span.Types.Link> .Add(ref this.Links, ToOtlpLink(activityLink));
return(true);
}
public bool ForEach(ActivityEvent activityEvent)
{
if (!this.Created)
{
this.Events = PooledList <OtlpTrace.Span.Types.Event> .Create();
this.Created = true;
}
PooledList <OtlpTrace.Span.Types.Event> .Add(ref this.Events, ToOtlpEvent(activityEvent));
return(true);
}
public bool ForEach(ActivityLink activityLink)
{
if (!this.Created)
{
this.SpanRefs = PooledList <JaegerSpanRef> .Create();
this.Created = true;
}
PooledList <JaegerSpanRef> .Add(ref this.SpanRefs, activityLink.ToJaegerSpanRef());
return(true);
}
public bool ForEach(ActivityEvent activityEvent)
{
if (!this.Created)
{
this.Logs = PooledList <JaegerLog> .Create();
this.Created = true;
}
PooledList <JaegerLog> .Add(ref this.Logs, activityEvent.ToJaegerLog());
return(true);
}
public bool ForEach(ActivityEvent activityEvent)
{
if (!this.Created)
{
this.Annotations = PooledList <ZipkinAnnotation> .Create();
this.Created = true;
}
PooledList <ZipkinAnnotation> .Add(ref this.Annotations, new ZipkinAnnotation(activityEvent.Timestamp.ToEpochMicroseconds(), activityEvent.Name));
return(true);
}
private static void CollectFrame()
{
ProfilerFrame frame = new ProfilerFrame();
frame.frameNumber = currentFrame;
frame.frameLength = (stopwatch.ElapsedTicks / (double)Stopwatch.Frequency) * 1000000.0;
frame.threadMethods = PooledList <(string, PooledList <ProfilerMethod>)> .Create();
foreach (var dataList in collectedMethods.Values)
{
if (dataList.Count == 0)
{
continue;
}
if (profilingThreads.TryGetValue(dataList[0].threadId, out string threadName))
{
var tuple = frame.threadMethods.SingleOrDefault(x => x.Item1 == threadName);
PooledList <ProfilerMethod> outList = null;
if (tuple.Item1 == null)
{
outList = PooledList <ProfilerMethod> .Create();
frame.threadMethods.Add((threadName, outList));
}
else
{
outList = tuple.Item2;
}
outList.AddRange(dataList);
}
}
foreach (var dataList in collectedMarkers.Values)
{
if (frame.markers == null)
{
frame.markers = PooledList <ProfilerMarker> .Create();
}
frame.markers.AddRange(dataList);
}
if (collectedFrames.IsFull)
{
collectedFrames.Front().Dispose();
}
collectedFrames.PushBack(frame);
}
public void HideFrom(Transform inTransform)
{
CleanList();
using (PooledList <Graphic> graphics = PooledList <Graphic> .Create())
{
inTransform.GetComponentsInChildren <Graphic>(graphics);
foreach (var graphic in graphics)
{
if (graphic.enabled)
{
graphic.enabled = false;
m_GraphicsToRestore.Add(graphic);
}
}
}
}
private void SpawnChickens()
{
using (PooledList <DragHolder> chickenNests = PooledList <DragHolder> .Create())
{
int maxChickens = Level.Chickens.Length;
if (!Level.FixedOperator)
{
maxChickens += 2;
}
for (int i = 0; i < maxChickens; ++i)
{
float offset = i - ((maxChickens - 1) / 2.0f);
// Spawn the nest
DragHolder chickenNest = ((GameObject)Instantiate(ChickenNestPrefab, new Vector3(offset * ChickenSpacing, 0, 0), Quaternion.identity)).GetComponent <DragHolder>();
chickenNest.transform.SetParent(ChickenRoot, false);
chickenNests.Add(chickenNest);
SlotFinder.AddSlot(chickenNest);
if (i < Level.Chickens.Length)
{
// Spawn the chicken
ExpressionChicken chicken = ((GameObject)Instantiate(ValueChickenPrefab, new Vector3(offset * ChickenSpacing, 0, 0), Quaternion.identity)).GetComponent <ExpressionChicken>();
chicken.transform.SetParent(ChickenRoot, false);
chicken.GetComponent <StartingSeat>().SetHolder(chickenNest);
chicken.SetValue(Level.Chickens[i]);
chicken.SlotFinder = SlotFinder;
}
else
{
OperatorType operatorType = i == Level.Chickens.Length ? OperatorType.Add : OperatorType.Subtract;
// Spawn the operator chicken
ExpressionChicken chicken = ((GameObject)Instantiate(OperatorChickenPrefab, new Vector3(offset * ChickenSpacing, 0, 0), Quaternion.identity)).GetComponent <ExpressionChicken>();
chicken.transform.SetParent(ChickenRoot, false);
chicken.GetComponent <StartingSeat>().SetHolder(chickenNest);
chicken.SetOperator(operatorType);
chicken.SlotFinder = SlotFinder;
}
}
foreach (var nest in chickenNests)
{
nest.transform.SetAsFirstSibling();
}
}
}
private ExpressionMinigameSettings FindContextualLevel()
{
Level currentLevel = Session.instance.currentLevel;
ExpressionMinigameCategories category;
if (currentLevel.isSingleDigitProblem)
{
category = ExpressionMinigameCategories.Single;
}
else
{
if (currentLevel.value < LOW_DOUBLE_THRESHOLD)
{
category = ExpressionMinigameCategories.DoubleLow;
}
else
{
category = ExpressionMinigameCategories.Double;
if (currentLevel.requiresRegrouping)
{
category |= ExpressionMinigameCategories.Regroup;
}
}
}
if (currentLevel.isSubtractionProblem)
{
category |= ExpressionMinigameCategories.Subtraction;
}
else
{
category |= ExpressionMinigameCategories.Addition;
}
using (PooledList <ExpressionMinigameSettings> listToUse = PooledList <ExpressionMinigameSettings> .Create())
{
listToUse.AddRange(m_Levels[category]);
if ((category | ExpressionMinigameCategories.Regroup) > 0)
{
listToUse.AddRange(m_Levels[category & ~ExpressionMinigameCategories.Regroup]);
}
return(RNG.Instance.Choose(listToUse));
}
}
private DragHolder FindHolder(PointerEventData inEventData)
{
using (PooledList <RaycastResult> raycastResult = PooledList <RaycastResult> .Create())
{
EventSystem.current.RaycastAll(inEventData, raycastResult);
foreach (var result in raycastResult)
{
var b = result.gameObject.GetComponentInParent <DragBase>();
if (b != null && b.Type == DragBaseType.Holder)
{
return((DragHolder)b);
}
}
return(null);
}
}
// Resumes all paused input.
public void ResumeInputs()
{
using (PooledList <string> keys = PooledList <string> .Create())
{
keys.AddRange(_temporaryPausedInputs);
_temporaryPausedInputs.Clear();
foreach (string key in keys)
{
if (_activatedInputs.Contains(key))
{
EnableInput(key, _objects[key], true, false);
}
}
}
Logger.Log("RESUMING INPUTS");
}
static public string[] EvaluateConcepts(Level inLevel)
{
using (PooledList <Code> codes = PooledList <Code> .Create())
{
codes.Capacity = 4;
if (inLevel.isSingleDigitProblem && inLevel.isTargetNumber)
{
codes.Add(Code.M52);
codes.Add(Code.M53);
}
if (inLevel.isDoubleDigitProblem && inLevel.isTargetNumber && !inLevel.requiresRegrouping)
{
codes.Add(Code.M64);
}
if (inLevel.isSingleDigitProblem && !inLevel.isTargetNumber)
{
codes.Add(Code.M80);
codes.Add(Code.M85);
}
if (inLevel.isDoubleDigitProblem)
{
codes.Add(Code.M86);
}
if (inLevel.isDoubleDigitProblem && inLevel.isTargetNumber && inLevel.requiresRegrouping)
{
codes.Add(Code.M87);
}
if (!inLevel.requiresRegrouping && !inLevel.isTargetNumber)
{
codes.Add(Code.M88);
}
if (inLevel.requiresRegrouping)
{
codes.Add(Code.M92);
}
return(BuildCodeStrings(codes));
}
}
static public string[] EvaluateConcepts(Minigames.ExpressionMinigame inMinigame)
{
using (PooledList <Code> codes = PooledList <Code> .Create())
{
ExpressionMinigameCategories category = inMinigame.Level.Categories;
codes.Capacity = 4;
bool bIsDouble = HasCategories(category, ExpressionMinigameCategories.Double) || HasCategories(category, ExpressionMinigameCategories.DoubleLow);
if (HasCategories(category, ExpressionMinigameCategories.Single))
{
codes.Add(Code.M52);
codes.Add(Code.M53);
codes.Add(Code.M80);
codes.Add(Code.M85);
}
if (bIsDouble && !HasCategories(category, ExpressionMinigameCategories.Regroup))
{
codes.Add(Code.M64);
}
if (bIsDouble)
{
codes.Add(Code.M86);
}
if (HasCategories(category, ExpressionMinigameCategories.Double | ExpressionMinigameCategories.Regroup) ||
HasCategories(category, ExpressionMinigameCategories.DoubleLow | ExpressionMinigameCategories.Regroup))
{
codes.Add(Code.M87);
}
if (HasCategories(category, ExpressionMinigameCategories.Regroup))
{
codes.Add(Code.M92);
}
return(BuildCodeStrings(codes));
}
}
internal static ZipkinSpan ToZipkinSpan(this Activity activity, ZipkinEndpoint defaultLocalEndpoint, bool useShortTraceIds = false)
{
var context = activity.Context;
var startTimestamp = activity.StartTimeUtc.ToEpochMicroseconds();
string parentId = EncodeSpanId(activity.ParentSpanId);
if (string.Equals(parentId, InvalidSpanId, StringComparison.Ordinal))
{
parentId = null;
}
var attributeEnumerationState = new AttributeEnumerationState
{
Tags = PooledList <KeyValuePair <string, string> > .Create(),
};
DictionaryEnumerator <string, string, AttributeEnumerationState> .AllocationFreeForEach(activity.Tags, ref attributeEnumerationState, ProcessTagsRef);
var activitySource = activity.Source;
if (!string.IsNullOrEmpty(activitySource.Name))
{
PooledList <KeyValuePair <string, string> > .Add(ref attributeEnumerationState.Tags, new KeyValuePair <string, string>("library.name", activitySource.Name));
if (!string.IsNullOrEmpty(activitySource.Version))
{
PooledList <KeyValuePair <string, string> > .Add(ref attributeEnumerationState.Tags, new KeyValuePair <string, string>("library.version", activitySource.Version));
}
}
var localEndpoint = defaultLocalEndpoint;
var serviceName = attributeEnumerationState.ServiceName;
// override default service name
if (!string.IsNullOrWhiteSpace(serviceName))
{
if (!string.IsNullOrWhiteSpace(attributeEnumerationState.ServiceNamespace))
{
serviceName = attributeEnumerationState.ServiceNamespace + "." + serviceName;
}
if (!LocalEndpointCache.TryGetValue(serviceName, out localEndpoint))
{
localEndpoint = defaultLocalEndpoint.Clone(serviceName);
LocalEndpointCache.TryAdd(serviceName, localEndpoint);
}
}
ZipkinEndpoint remoteEndpoint = null;
if ((activity.Kind == ActivityKind.Client || activity.Kind == ActivityKind.Producer) && attributeEnumerationState.RemoteEndpointServiceName != null)
{
remoteEndpoint = RemoteEndpointCache.GetOrAdd(attributeEnumerationState.RemoteEndpointServiceName, ZipkinEndpoint.Create);
}
var annotations = PooledList <ZipkinAnnotation> .Create();
ListEnumerator <ActivityEvent, PooledList <ZipkinAnnotation> > .AllocationFreeForEach(activity.Events, ref annotations, ProcessActivityEventsRef);
return(new ZipkinSpan(
EncodeTraceId(context.TraceId, useShortTraceIds),
parentId,
EncodeSpanId(context.SpanId),
ToActivityKind(activity),
activity.OperationName,
activity.StartTimeUtc.ToEpochMicroseconds(),
duration: (long)activity.Duration.ToEpochMicroseconds(),
localEndpoint,
remoteEndpoint,
annotations,
attributeEnumerationState.Tags,
null,
null));
}
public Batch(Process process)
{
this.Process = process ?? throw new ArgumentNullException(nameof(process));
this.spanMessages = PooledList <BufferWriterMemory> .Create();
}
private void MakeChickenPhoto()
{
m_LastPolaroid = configurations[RNG.Instance.Next(0, configurations.Length)];
if (Session.instance.numEggs == 0)
{
if (firstLevelConfiguration != null)
{
m_LastPolaroid = firstLevelConfiguration;
}
else
{
Logger.Warn("Missing PolaroidConfig for first level!");
}
}
// display foreground
_background.GetComponent <Image>().sprite = m_LastPolaroid.Background;
// display foreground
Image image = _foreground.GetComponent <Image>();
image.sprite = m_LastPolaroid.Foreground;
image.enabled = image.sprite != null;
// clear chicken mounts
foreach (Transform slot in ChickenSlots)
{
slot.GetComponent <Image>().enabled = false;
}
foreach (var pilotConfig in PeacockAndKiwi)
{
pilotConfig.Slot.gameObject.SetActive(false);
}
int numberOfChickensToDisplay = 1;
if (Session.instance.currentLevel.value > 1 && RNG.Instance.NextBool())
{
numberOfChickensToDisplay = 2;
}
using (PooledList <Sprite> foregroundChickens = PooledList <Sprite> .Create())
{
// HORRIBLE HACK
GameObject screen = GameObject.FindGameObjectWithTag("GameScreen");
MyScreen myScreen = screen.GetComponent <MyScreen>();
int brownCount = myScreen.onesColumn.GetNumWithColor(CreatureCtrl.COLOR_BROWN) + myScreen.tensColumn.GetNumWithColor(CreatureCtrl.COLOR_BROWN) * 10;
int goldCount = myScreen.tensColumn.GetNumWithColor(CreatureCtrl.COLOR_GOLD) * 10;
int whiteCount = myScreen.onesColumn.GetNumWithColor(CreatureCtrl.COLOR_WHITE) + myScreen.tensColumn.GetNumWithColor(CreatureCtrl.COLOR_WHITE) * 10;
bool bCheckExclusionList = Optimizer.instance.DisableMasks;
if (brownCount == 1)
{
Sprite brownChicken = null;
while (brownChicken == null)
{
brownChicken = RNG.Instance.Choose(m_LastPolaroid.BrownChickens);
if (bCheckExclusionList && ExcludedOnLowEnd.Contains(brownChicken))
{
brownChicken = null;
}
}
string brownChickenPose = brownChicken.name;
foregroundChickens.Add(brownChicken);
Sprite whiteChicken = null;
int tries = m_LastPolaroid.WhiteChickens.Length * 2;
while (whiteChicken == null && --tries >= 0)
{
whiteChicken = RNG.Instance.Choose(m_LastPolaroid.WhiteChickens);
if (whiteChicken.name.Contains(brownChickenPose) || (bCheckExclusionList && ExcludedOnLowEnd.Contains(whiteChicken)))
{
whiteChicken = null;
}
}
if (whiteChicken != null)
{
foregroundChickens.Add(whiteChicken);
}
else
{
numberOfChickensToDisplay = 1;
}
}
else if (brownCount >= 2)
{
AddValidPoses(foregroundChickens, m_LastPolaroid.BrownChickens);
}
else
{
AddValidPoses(foregroundChickens, m_LastPolaroid.WhiteChickens);
if (foregroundChickens.Count < 2)
{
numberOfChickensToDisplay = 1;
}
}
ChickenSlots.Shuffle();
for (int i = 0; i < numberOfChickensToDisplay; ++i)
{
int chickenIndex = (i % foregroundChickens.Count);
if (chickenIndex == 0)
{
foregroundChickens.Shuffle();
}
Image slot = ChickenSlots[i].GetComponent <Image>();
slot.sprite = foregroundChickens[chickenIndex];
slot.enabled = true;
//slot.SetNativeSize();
}
}
}
internal static ZipkinSpan ToZipkinSpan(this SpanData otelSpan, ZipkinEndpoint defaultLocalEndpoint, bool useShortTraceIds = false)
{
var context = otelSpan.Context;
var startTimestamp = ToEpochMicroseconds(otelSpan.StartTimestamp);
var endTimestamp = ToEpochMicroseconds(otelSpan.EndTimestamp);
string parentId = null;
if (otelSpan.ParentSpanId != default)
{
parentId = EncodeSpanId(otelSpan.ParentSpanId);
}
var attributeEnumerationState = new AttributeEnumerationState
{
Tags = PooledList <KeyValuePair <string, string> > .Create(),
};
DictionaryEnumerator <string, object, AttributeEnumerationState> .AllocationFreeForEach(otelSpan.Attributes, ref attributeEnumerationState, ProcessAttributesRef);
DictionaryEnumerator <string, object, AttributeEnumerationState> .AllocationFreeForEach(otelSpan.LibraryResource.Attributes, ref attributeEnumerationState, ProcessLibraryResourcesRef);
var localEndpoint = defaultLocalEndpoint;
var serviceName = attributeEnumerationState.ServiceName;
// override default service name
if (!string.IsNullOrWhiteSpace(serviceName))
{
if (!string.IsNullOrWhiteSpace(attributeEnumerationState.ServiceNamespace))
{
serviceName = attributeEnumerationState.ServiceNamespace + "." + serviceName;
}
if (!LocalEndpointCache.TryGetValue(serviceName, out localEndpoint))
{
localEndpoint = defaultLocalEndpoint.Clone(serviceName);
LocalEndpointCache.TryAdd(serviceName, localEndpoint);
}
}
ZipkinEndpoint remoteEndpoint = null;
if ((otelSpan.Kind == SpanKind.Client || otelSpan.Kind == SpanKind.Producer) && attributeEnumerationState.RemoteEndpointServiceName != null)
{
remoteEndpoint = RemoteEndpointCache.GetOrAdd(attributeEnumerationState.RemoteEndpointServiceName, ZipkinEndpoint.Create);
}
var status = otelSpan.Status;
if (status.IsValid)
{
if (!CanonicalCodeCache.TryGetValue(status.CanonicalCode, out string canonicalCode))
{
canonicalCode = status.CanonicalCode.ToString();
CanonicalCodeCache.TryAdd(status.CanonicalCode, canonicalCode);
}
PooledList <KeyValuePair <string, string> > .Add(ref attributeEnumerationState.Tags, new KeyValuePair <string, string>(StatusCode, canonicalCode));
if (status.Description != null)
{
PooledList <KeyValuePair <string, string> > .Add(ref attributeEnumerationState.Tags, new KeyValuePair <string, string>(StatusDescription, status.Description));
}
}
var annotations = PooledList <ZipkinAnnotation> .Create();
ListEnumerator <Event, PooledList <ZipkinAnnotation> > .AllocationFreeForEach(otelSpan.Events, ref annotations, ProcessEventsRef);
return(new ZipkinSpan(
EncodeTraceId(context.TraceId, useShortTraceIds),
parentId,
EncodeSpanId(context.SpanId),
ToSpanKind(otelSpan),
otelSpan.Name,
ToEpochMicroseconds(otelSpan.StartTimestamp),
duration: endTimestamp - startTimestamp,
localEndpoint,
remoteEndpoint,
annotations,
attributeEnumerationState.Tags,
null,
null));
}
public bool ForEach(KeyValuePair <string, object> activityTag)
{
if (activityTag.Value == null)
{
return(true);
}
var key = activityTag.Key;
switch (key)
{
case SpanAttributeConstants.StatusCodeKey:
this.StatusCode = activityTag.Value as string;
return(true);
case SpanAttributeConstants.StatusDescriptionKey:
this.StatusDescription = activityTag.Value as string;
return(true);
}
if (!this.Created)
{
this.Tags = PooledList <OtlpCommon.KeyValue> .Create();
this.Created = true;
}
OtlpCommon.ArrayValue arrayValue;
switch (activityTag.Value)
{
case string s:
PeerServiceResolver.InspectTag(ref this, key, s);
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
StringValue = s
}));
break;
case bool b:
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
BoolValue = b
}));
break;
case int i:
PeerServiceResolver.InspectTag(ref this, key, i);
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
IntValue = i
}));
break;
case long l:
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
IntValue = l
}));
break;
case double d:
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
DoubleValue = d
}));
break;
case int[] intArray:
arrayValue = new OtlpCommon.ArrayValue();
foreach (var item in intArray)
{
arrayValue.Values.Add(new OtlpCommon.AnyValue {
IntValue = item
});
}
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
ArrayValue = arrayValue
}));
break;
case double[] doubleArray:
arrayValue = new OtlpCommon.ArrayValue();
foreach (var item in doubleArray)
{
arrayValue.Values.Add(new OtlpCommon.AnyValue {
DoubleValue = item
});
}
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
ArrayValue = arrayValue
}));
break;
case bool[] boolArray:
arrayValue = new OtlpCommon.ArrayValue();
foreach (var item in boolArray)
{
arrayValue.Values.Add(new OtlpCommon.AnyValue {
BoolValue = item
});
}
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
ArrayValue = arrayValue
}));
break;
case string[] stringArray:
arrayValue = new OtlpCommon.ArrayValue();
foreach (var item in stringArray)
{
arrayValue.Values.Add(item == null ? new OtlpCommon.AnyValue() : new OtlpCommon.AnyValue {
StringValue = item
});
}
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
ArrayValue = arrayValue
}));
break;
case long[] longArray:
arrayValue = new OtlpCommon.ArrayValue();
foreach (var item in longArray)
{
arrayValue.Values.Add(new OtlpCommon.AnyValue {
IntValue = item
});
}
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
ArrayValue = arrayValue
}));
break;
default:
PooledList <OtlpCommon.KeyValue> .Add(ref this.Tags, CreateOtlpKeyValue(key, new OtlpCommon.AnyValue {
StringValue = activityTag.Value.ToString()
}));
break;
}
return(true);
}
public static void WriteToFile(string filename, ProfilingFormat format, FrameSelection frameSelection = FrameSelection.Median)
{
if (!ProfilingEnabled)
{
throw new InvalidOperationException("Cannot write profile to file when profiling is not enabled.");
}
ProfilerFrame frame = default;
if (collectedFrames.IsEmpty)
{
return;
}
bool needsDispose = false;
switch (frameSelection)
{
case FrameSelection.Median:
var ordered = collectedFrames.OrderBy(x => x.frameLength).ToArray();
frame = ordered[(int)Math.Floor(ordered.Length / 2.0)];
break;
case FrameSelection.Longest:
frame = collectedFrames.MaxBy(x => x.frameLength);
break;
case FrameSelection.Shortest:
frame = collectedFrames.MinBy(x => x.frameLength);
break;
case FrameSelection.Latest:
frame = collectedFrames.Back();
break;
case FrameSelection.Percentile95:
ordered = collectedFrames.OrderBy(x => x.frameLength).ToArray();
int index = ordered.Length - (int)(ordered.Length * 0.05f);
if (index >= ordered.Length)
{
index = ordered.Length - 1;
}
frame = ordered[index];
break;
case FrameSelection.All:
frame = new ProfilerFrame();
frame.frameNumber = collectedFrames.Min(x => x.frameNumber);
frame.frameLength = collectedFrames.Sum(x => x.frameLength);
frame.markers = PooledList <ProfilerMarker> .Create();
double elapsedTime = 0;
foreach (var collectedFrame in collectedFrames)
{
if (collectedFrame.markers != null)
{
frame.markers.AddRange(collectedFrame.markers.Select(x =>
new ProfilerMarker(x.markName, x.time + elapsedTime)));
}
elapsedTime += collectedFrame.frameLength;
}
frame.threadMethods = PooledList <(string, PooledList <ProfilerMethod>)> .Create();
elapsedTime = 0;
foreach (var collectedFrame in collectedFrames)
{
foreach (var collectedFrameThreadMethod in collectedFrame.threadMethods)
{
var tuple = frame.threadMethods.SingleOrDefault(x => x.Item1 == collectedFrameThreadMethod.Item1);
PooledList <ProfilerMethod> outList = null;
if (tuple.Item1 == null)
{
outList = PooledList <ProfilerMethod> .Create();
frame.threadMethods.Add((collectedFrameThreadMethod.Item1, outList));
}
else
{
outList = tuple.Item2;
}
outList.AddRange(collectedFrameThreadMethod.Item2.Select(x => new ProfilerMethod(
x.methodName, x.depth, x.startTime + elapsedTime, x.endTime + elapsedTime, x.threadId)));
}
elapsedTime += collectedFrame.frameLength;
}
needsDispose = true;
break;
default:
throw new ArgumentOutOfRangeException(nameof(frameSelection), frameSelection, null);
}
switch (format)
{
case ProfilingFormat.SpeedScope:
SpeedScopeWriter.WriteToFile(frame, filename);
break;
case ProfilingFormat.ChromeTracing:
ChromeTracingWriter.WriteToFile(frame, filename);
break;
default:
throw new ArgumentOutOfRangeException(nameof(format), format, null);
}
if (needsDispose)
{
frame.Dispose();
}
}
public GroupActions GetGroupsToUpdate(IGroupVisibilityContext options)
{
if (options == null)
{
return(null);
}
var planes = options.CameraPlanes;
var frustumCorners = options.CameraFrustumCorners;
var cameraPosition = options.CameraPosition;
var cameraLocalToWorldMatrix = options.CameraLocalToWorldMatrix;
var parentContainerWorldToLocalMatrix = options.ParentContainerWorldToLocalMatrix;
var groupBoundsTemplate = options.GroupBounds;
var cellInGroupCount = options.CellInGroupCount;
var invalidatedArea = options.InvalidatedArea_worldSpace;
var cameraPositionLocal = parentContainerWorldToLocalMatrix.MultiplyPoint(cameraPosition);
var localCameraBounds = new Bounds(cameraPositionLocal, new Vector3());
for (int i = 0; i < 4; i++)
{
var vector = parentContainerWorldToLocalMatrix.MultiplyPoint(cameraLocalToWorldMatrix.MultiplyVector(frustumCorners[i]));
localCameraBounds.Encapsulate(cameraPositionLocal + vector);
}
var bounds_center = groupBoundsTemplate.center;
var bounds_size = groupBoundsTemplate.size;
int min_group_x = Mathf.FloorToInt(localCameraBounds.min.x);
int min_group_y = Mathf.FloorToInt(localCameraBounds.min.y);
int max_group_x = Mathf.CeilToInt(localCameraBounds.max.x);
int max_group_y = Mathf.CeilToInt(localCameraBounds.max.y);
var cellInGroupCount_x = cellInGroupCount.x;
var cellInGroupCount_y = cellInGroupCount.y;
var groupsToRecompute = PooledList <Vector2i> .Create();
var groupsToKeep = PooledList <Vector2i> .Create();
for (int group_x = min_group_x; group_x <= max_group_x; group_x++)
{
for (int group_y = min_group_y; group_y <= max_group_y; group_y++)
{
var group = new Vector2i(group_x, group_y);
var groupBounds = new Bounds(new Vector3
(
bounds_center.x + group_x * cellInGroupCount_x,
bounds_center.y + group_y * cellInGroupCount_y,
bounds_center.z
), bounds_size);
bool isInside = TestPlanesAABB(planes, groupBounds);
if (isInside)
{
var groupArea = new Rect2i(group * cellInGroupCount, cellInGroupCount);
if (groupArea.Overlaps(invalidatedArea))
{
groupsToRecompute.Add(group);
}
else
{
if (!options.ExistingGroups.Contains(group))
{
groupsToRecompute.Add(group);
}
else
{
groupsToKeep.Add(group);
}
}
}
}
}
return(new GroupActions(groupsToRecompute, groupsToKeep));
}
