// this is intended to be run while layout is running (ie in parallel)
public void GatherBoxDataParallel()
{
UIElement root = view.dummyRoot;
int frameId = root.application.frameId;
int idx = 0;
wrapperList.QuickClear();
elemRefStack.array[elemRefStack.size++].element = root;
while (elemRefStack.size > 0)
{
UIElement currentElement = elemRefStack.array[--elemRefStack.size].element;
RenderBox renderBox = currentElement.renderBox;
renderBox.culled = renderBox.element.layoutResult.isCulled;
renderBox.clipper = currentElement.layoutResult.clipper;
renderBox.traversalIndex = idx++;
if (wrapperList.size + (currentElement.children.size * 2) >= wrapperList.array.Length)
{
wrapperList.EnsureAdditionalCapacity(currentElement.children.size * 2);
}
if (elemRefStack.size + currentElement.children.size >= elemRefStack.array.Length)
{
elemRefStack.EnsureAdditionalCapacity(currentElement.children.size);
}
if (!renderBox.culled && renderBox.visibility != Visibility.Hidden)
{
ref RenderOperationWrapper backgroundOp = ref wrapperList.array[wrapperList.size++];
backgroundOp.renderBox = renderBox;
backgroundOp.renderOperation = DrawCommandType.BackgroundTransparent;
if (renderBox.hasForeground)
{
ref RenderOperationWrapper foreground = ref wrapperList.array[wrapperList.size++];
foreground.renderBox = renderBox;
foreground.renderOperation = DrawCommandType.ForegroundTransparent;
}
}
public new void Clear()
{
base.Clear();
matrixChanged = false;
drawCallList.QuickClear();
fillStyles?.QuickClear();
strokeStyles?.QuickClear();
transforms.size = 0;
objectDataList.size = 0;
geometry.Clear();
currentMatrix = Matrix4x4.identity;
currentFillStyle = SVGXFillStyle.Default;
currentStrokeStyle = SVGXStrokeStyle.Default;
currentShapeRange = default;
currentFixedRenderState = new FixedRenderState(BlendState.Default, DepthState.Default);
transforms.Add(currentMatrix);
if (renderStateList != null)
{
renderStateList.size = 0;
}
}
internal static MethodInfo SelectEligibleMethod(IList <MethodInfo> methodInfos, Expression[] arguments, StructList <ParameterConversion> winningConversions)
{
if (methodInfos.Count == 0)
{
return(null);
}
if (methodInfos.Count == 1)
{
if (CheckCandidate(new Candidate(methodInfos[0].GetParameters()), arguments, out int unused, winningConversions))
{
return(methodInfos[0]);
}
return(null);
}
StructList <Candidate> candidates = StructList <Candidate> .GetMinSize(methodInfos.Count);
StructList <ParameterConversion> conversions = StructList <ParameterConversion> .Get();
int argCount = arguments.Length;
for (int i = 0; i < methodInfos.Count; i++)
{
MethodInfo methodInfo = methodInfos[i];
ParameterInfo[] parameterInfos = methodInfo.GetParametersCached();
if (parameterInfos.Length == argCount)
{
candidates.Add(new Candidate(methodInfo, parameterInfos));
}
else if (parameterInfos.Length > argCount)
{
bool valid = true;
for (int j = 0; j < parameterInfos.Length; j++)
{
if (!parameterInfos[j].HasDefaultValue)
{
valid = false;
break;
}
}
if (valid)
{
candidates.Add(new Candidate(methodInfo, parameterInfos));
}
}
}
int winner = -1;
int winnerPoints = -1;
for (int i = 0; i < candidates.Count; i++)
{
int candidatePoints;
conversions.QuickClear();
if (!CheckCandidate(candidates[i], arguments, out candidatePoints, conversions))
{
continue;
}
// todo -- handle the ambiguous case
if (BestScoreSoFar(candidatePoints, winnerPoints))
{
winner = i;
winnerPoints = candidatePoints;
winningConversions.QuickClear();
winningConversions.AddRange(conversions);
}
}
StructList <ParameterConversion> .Release(ref conversions);
if (winner != -1)
{
MethodInfo retn = candidates[winner].methodInfo;
StructList <Candidate> .Release(ref candidates);
return(retn);
}
return(null);
}
internal static ConstructorInfo SelectEligibleConstructor(Type type, Expression[] arguments, StructList <ParameterConversion> winningConversions)
{
ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Instance | BindingFlags.Public);
if (constructors.Length == 0)
{
return(null);
}
if (constructors.Length == 1)
{
if (CheckCandidate(new Candidate(constructors[0].GetParametersCached()), arguments, out int unused, winningConversions))
{
return(constructors[0]);
}
return(null);
}
StructList <Candidate> candidates = StructList <Candidate> .GetMinSize(constructors.Length);
StructList <ParameterConversion> conversions = StructList <ParameterConversion> .Get();
for (int i = 0; i < constructors.Length; i++)
{
candidates[i] = new Candidate(constructors[i].GetParametersCached());
}
int winner = -1;
int winnerPoints = 0;
for (int i = 0; i < constructors.Length; i++)
{
int candidatePoints;
conversions.QuickClear();
if (!CheckCandidate(candidates[i], arguments, out candidatePoints, conversions))
{
continue;
}
// todo -- handle the ambiguous case
if (BestScoreSoFar(candidatePoints, winnerPoints))
{
winner = i;
winnerPoints = candidatePoints;
winningConversions.QuickClear();
winningConversions.AddRange(conversions);
}
}
StructList <Candidate> .Release(ref candidates);
StructList <ParameterConversion> .Release(ref conversions);
if (winner != -1)
{
return(constructors[winner]);
}
return(null);
}
public void GatherBoxData(IList <UIView> views)
{
int idx = 0;
wrapperList.QuickClear();
for (int viewIdx = 0; viewIdx < views.Count; ++viewIdx)
{
UIView view = views[viewIdx];
UIElement dummyRoot = view.dummyRoot;
int frameId = view.application.frameId;
if (dummyRoot.renderBox == null)
{
dummyRoot.renderBox = new RootRenderBox();
dummyRoot.renderBox.element = dummyRoot;
}
elemRefStack.array[elemRefStack.size++].element = dummyRoot;
while (elemRefStack.size > 0)
{
UIElement currentElement = elemRefStack.array[--elemRefStack.size].element;
RenderBox renderBox = currentElement.renderBox;
renderBox.culled = renderBox.element.layoutResult.isCulled;
renderBox.clipper = currentElement.layoutResult.clipper;
renderBox.traversalIndex = idx++;
renderBox.viewDepthIdx = viewIdx;
if (wrapperList.size + 2 + (currentElement.children.size * 2) >= wrapperList.array.Length)
{
wrapperList.EnsureAdditionalCapacity(2 + (currentElement.children.size * 2));
}
if (elemRefStack.size + 2 + currentElement.children.size >= elemRefStack.array.Length)
{
elemRefStack.EnsureAdditionalCapacity(2 + (currentElement.children.size * 2));
}
if (!renderBox.culled && renderBox.visibility != Visibility.Hidden)
{
ref RenderOperationWrapper backgroundOp = ref wrapperList.array[wrapperList.size++];
backgroundOp.renderBox = renderBox;
backgroundOp.renderOperation = DrawCommandType.BackgroundTransparent;
if (renderBox.hasForeground)
{
ref RenderOperationWrapper foreground = ref wrapperList.array[wrapperList.size++];
foreground.renderBox = renderBox;
foreground.renderOperation = DrawCommandType.ForegroundTransparent;
}
}
for (int i = currentElement.children.size - 1; i >= 0; i--)
{
UIElement child = currentElement.children.array[i];
if ((child.flags & UIElementFlags.EnabledFlagSet) == UIElementFlags.EnabledFlagSet)
{
// todo change check on painter
if (child.renderBox == null)
{
CreateRenderBox(child);
Debug.Assert(child.renderBox != null, "child.renderBox != null");
child.renderBox.Enable();
}
else if (child.enableStateChangedFrameId == frameId)
{
UpdateRenderBox(child);
child.renderBox.Enable();
}
if (child.renderBox.scrollFix == 1)
{
elemRefStack.array[elemRefStack.size++].element = child;
}
}
}
for (int i = currentElement.children.size - 1; i >= 0; i--)
{
UIElement child = currentElement.children.array[i];
if ((child.flags & UIElementFlags.EnabledFlagSet) == UIElementFlags.EnabledFlagSet)
{
if (child.renderBox.scrollFix == 0)
{
elemRefStack.array[elemRefStack.size++].element = child;
}
}
}
}