// this might be getting called too many times since im not sure im caching the result
private void ParseContentTemplate(TemplateRootNode templateRootNode, TemplateShell shell, ProcessedType processedType)
{
XElement root = shell.GetElementTemplateContent(processedType.templateAttr.templateId);
if (root == null)
{
throw new TemplateNotFoundException(processedType.templateAttr.filePath, processedType.templateAttr.templateId);
}
IXmlLineInfo xmlLineInfo = root;
StructList <AttributeDefinition> attributes = StructList <AttributeDefinition> .Get();
StructList <AttributeDefinition> injectedAttributes = StructList <AttributeDefinition> .Get();
ParseAttributes(shell, "Contents", root.Attributes(), attributes, injectedAttributes, out string genericTypeResolver, out string requireType);
if (attributes.size == 0)
{
StructList <AttributeDefinition> .Release(ref attributes);
}
if (injectedAttributes.size == 0)
{
StructList <AttributeDefinition> .Release(ref injectedAttributes);
}
templateRootNode.attributes = ValidateRootAttributes(shell.filePath, attributes);
templateRootNode.lineInfo = new TemplateLineInfo(xmlLineInfo.LineNumber, xmlLineInfo.LinePosition);
templateRootNode.genericTypeResolver = genericTypeResolver;
templateRootNode.requireType = requireType; // always null I think
ParseChildren(templateRootNode, templateRootNode, root.Nodes());
}
private ASTNode ParseInternal(string input)
{
tokenStream = new TokenStream(ExpressionTokenizer.Tokenize(input, StructList <ExpressionToken> .Get()));
expressionStack = expressionStack ?? StackPool <ASTNode> .Get();
operatorStack = operatorStack ?? StackPool <OperatorNode> .Get();
if (tokenStream.Current == ExpressionTokenType.ExpressionOpen)
{
tokenStream.Advance();
}
if (!tokenStream.HasMoreTokens)
{
throw new ParseException("Failed trying to parse empty expression");
}
if (tokenStream.Last == ExpressionTokenType.ExpressionClose)
{
tokenStream.Chop();
}
ASTNode retn = ParseLoop();
Release();
return(retn);
}
public TypeBodyNode Parse(string input, string fileName, int lineStart)
{
tokenStream = new TokenStream(ExpressionTokenizer.Tokenize(input, StructList <ExpressionToken> .Get()));
if (!tokenStream.HasMoreTokens)
{
throw new ParseException("Failed trying to parse empty expression");
}
TypeBodyNode retn = new TypeBodyNode();
int cnt = 0;
while (tokenStream.HasMoreTokens && cnt < 10000)
{
cnt++;
ExpressionToken current = tokenStream.Current;
ASTNode node = null;
if (ParseDeclaration(ref node))
{
retn.nodes.Add(node);
continue;
}
if (current == tokenStream.Current)
{
throw new ParseException($"Failed to parse {fileName}. Got stuck on {current.value}");
}
}
return(retn);
}
public GridTrack(GridTrackSize size)
{
this.size = size;
this.position = 0;
this.outputSize = 0;
this.autoPlacementCursor = 0;
this.spanningItems = StructList <int> .Get();
}
public StyleAnimationKeyFrame(float key, StyleKeyFrameValue p0)
{
this.key = key;
this.properties = StructList <StyleKeyFrameValue> .Get();
this.properties.EnsureCapacity(1);
this.properties[0] = p0;
this.properties.Count = 1;
}
private void AddToChangeSet(UIElement element, StyleProperty property)
{
if (!m_ChangeSets.TryGetValue(element.id, out ChangeSet changeSet))
{
changeSet = new ChangeSet(element, StructList <StyleProperty> .Get());
m_ChangeSets[element.id] = changeSet;
}
changeSet.changes.Add(property);
}
public StyleAnimationKeyFrame(float key, StyleKeyFrameValue p0, StyleKeyFrameValue p1, StyleKeyFrameValue p2)
{
this.key = key;
this.properties = StructList <StyleKeyFrameValue> .Get();
this.properties.EnsureCapacity(3);
this.properties[0] = p0;
this.properties[1] = p1;
this.properties[2] = p2;
this.properties.Count = 3;
}
public StyleAnimationKeyFrame(float key, IList <StyleKeyFrameValue> properties)
{
this.key = key;
this.properties = StructList <StyleKeyFrameValue> .Get();
this.properties.EnsureCapacity(properties.Count);
for (int i = 0; i < properties.Count; i++)
{
this.properties[i] = properties[i];
}
this.properties.Count = properties.Count;
}
public static bool TryParseTypeName(string typeName, out TypeLookup typeLookup)
{
StructList <ExpressionToken> list = StructList <ExpressionToken> .Get();
ExpressionTokenizer.Tokenize(typeName, list);
ExpressionParser parser = new ExpressionParser(new TokenStream(list));
typeLookup = default;
bool valid = parser.ParseTypePath(ref typeLookup);
parser.Release();
list.Release();
return(valid);
}
public static StructList <InputHandler> CompileInputAnnotations(Type targetType)
{
if (s_Cache.TryGetValue(targetType, out StructList <InputHandler> handlers))
{
return(handlers);
}
handlers = StructList <InputHandler> .Get();
MethodInfo[] methods = ReflectionUtil.GetInstanceMethods(targetType);
for (int i = 0; i < methods.Length; i++)
{
MethodInfo methodInfo = methods[i];
object[] customAttributes = methodInfo.GetCustomAttributes(true);
if (customAttributes.Length == 0)
{
continue;
}
ParameterInfo[] parameters = methodInfo.GetParameters();
GetMouseEventHandlers(methodInfo, parameters, customAttributes, handlers);
GetKeyboardEventHandlers(methodInfo, parameters, customAttributes, handlers);
GetDragCreators(methodInfo, parameters, customAttributes, handlers);
GetDragHandlers(methodInfo, parameters, customAttributes, handlers);
}
if (handlers.size == 0)
{
handlers.Release();
s_Cache[targetType] = null;
return(null);
}
s_Cache[targetType] = handlers;
return(handlers);
}
public void AddSlotForward(TemplateScope parentScope, string slotName, UIElement context, int slotId)
{
slotInputs = slotInputs ?? StructList <SlotUsage> .Get();
if (parentScope.slotInputs == null)
{
slotInputs.Add(new SlotUsage(slotName, slotId, context));
return;
}
for (int i = 0; i < parentScope.slotInputs.size; i++)
{
if (parentScope.slotInputs.array[i].slotName == slotName)
{
slotInputs.Add(parentScope.slotInputs.array[i]);
}
}
slotInputs.Add(new SlotUsage(slotName, slotId, context));
}
public LayoutFrameData GetResults(LayoutDirection direction, int frameId)
{
StructList <LayoutFrameDataEntry> historyEntries = StructList <LayoutFrameDataEntry> .Get();
for (int i = 0; i < log.size; i++)
{
if (log.array[i].frameId != frameId)
{
continue;
}
if (log.array[i].direction != direction)
{
continue;
}
LayoutFrameDataEntry entry = new LayoutFrameDataEntry(log.array[i].reason, log.array[i].description);
historyEntries.Add(entry);
}
return(new LayoutFrameData(historyEntries));
}
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 static StructList <WordInfo> BreakIntoWords(char[] buffer, int bufferSize = -1)
{
return(BreakIntoWords(StructList <WordInfo> .Get(), buffer, bufferSize));
}
// depth buffer means our regions are locked per channel
// 2 options: 1. each channel is its own set of draw calls, this is easy but maybe not as fast. do this as a first pass
// 2. try to re-use regions for different channels, almost certainly leads to less throughput but faster since we don't need extra draw calls
// probably means we have sub-sorting regions, ie large packers would have sub-packers
// would definitely want to sort by size in that case and first try to pack larger regions into themselves
// would likely update rect packer to be channel aware, when trying to place next item instead of moving over try colliding a different channel instead
public void Clip(Camera camera, CommandBuffer commandBuffer)
{
// breaks on refresh if we don't do this :(
this.clearMaterial.SetColor(s_Color, Color.white);
this.clearCountMaterial.SetColor(s_Color, new Color(0, 0, 0, 0));
requireRegionCounting = false;
for (int i = 0; i < batchesToRender.size; i++)
{
batchesToRender[i].pooledMesh.Release();
StructList <Matrix4x4> .Release(ref batchesToRender.array[i].transforms);
StructList <Vector4> .Release(ref batchesToRender.array[i].objectData);
StructList <Vector4> .Release(ref batchesToRender.array[i].colorData);
}
batchesToRender.Clear();
Gather();
Vector3 cameraOrigin = camera.transform.position;
cameraOrigin.x -= 0.5f * Screen.width;
cameraOrigin.y += (0.5f * Screen.height);
cameraOrigin.z += 2;
Matrix4x4 origin = Matrix4x4.TRS(cameraOrigin, Quaternion.identity, Vector3.one);
LightList <ClipData> texturedClippers = LightList <ClipData> .Get();
regionMesh?.Release();
regionMesh = GetRegionMesh(out requireRegionCounting);
clipTexture = RenderTexture.GetTemporary(Screen.width, Screen.height, 24, RenderTextureFormat.Default); // todo -- use lower resolution
#if DEBUG
commandBuffer.BeginSample("UIFora Clip Draw");
#endif
commandBuffer.SetRenderTarget(clipTexture);
// probably don't need this actually, can bake it into clear. keep for debugging
commandBuffer.ClearRenderTarget(true, true, Color.black);
commandBuffer.DrawMesh(regionMesh.mesh, origin, clearMaterial, 0, 0);
// todo -- handle multiple shapes from one path
ClipBatch batch = new ClipBatch();
batch.transforms = StructList <Matrix4x4> .Get();
batch.colorData = StructList <Vector4> .Get();
batch.objectData = StructList <Vector4> .Get();
for (int i = 0; i < clippers.size; i++)
{
ClipData clipData = clippers[i];
Path2D clipPath = clipData.clipPath;
if (clipPath == null)
{
// todo if transform is not identity we need to generate a rotated or skewed rect for the clip shape
continue;
}
clipPath.UpdateGeometry(); // should early out if no update required
if (AnyShapeUsesTextures(clipPath))
{
// todo -- handle textures
// todo -- handle text
continue;
}
batch = DrawShapesInPath(batch, clipPath, clipData, clipData);
for (int j = 0; j < clipData.dependents.size; j++)
{
batch = DrawShapesInPath(batch, clipPath, clipData, clipData.dependents[j]);
}
}
FinalizeBatch(batch, false);
for (int i = 0; i < batchesToRender.size; i++)
{
ref ClipBatch clipBatch = ref batchesToRender.array[i];
ClipPropertyBlock propertyBlock = clipMaterialPool.GetPropertyBlock(clipBatch.transforms.size);
propertyBlock.SetData(clipBatch);
commandBuffer.DrawMesh(clipBatch.pooledMesh.mesh, origin, clipDrawMaterial, 0, 0, propertyBlock.matBlock);
}
private bool ParseDeclaration(ref ASTNode node)
{
AttributeNode attrNode = null;
LightList <AttributeNode> attributes = LightList <AttributeNode> .Get();
while (ParseAttribute(ref attrNode))
{
attributes.Add(attrNode);
if (tokenStream.Current != ExpressionTokenType.ArrayAccessOpen)
{
break;
}
}
if (attributes.size == 0)
{
LightList <AttributeNode> .Release(ref attributes);
}
if (tokenStream.Current != ExpressionTokenType.Identifier)
{
return(false);
}
// modifiers? -> returnType -> name -> signature -> openBrace * closeBrace
tokenStream.Save();
bool isStatic = false;
if (tokenStream.Current == "static")
{
isStatic = true;
tokenStream.Advance();
}
ExpressionParser parser = new ExpressionParser(tokenStream);
StructList <LambdaArgument> signature = null;
TypeLookup typeLookup = default;
if (!parser.ParseTypePath(ref typeLookup))
{
goto fail;
}
tokenStream.Set(parser.GetTokenPosition());
parser.Release(false);
if (tokenStream.Current != ExpressionTokenType.Identifier)
{
goto fail;
}
string name = tokenStream.Current.value;
tokenStream.Advance();
// if semi colon then we have a field!
if (tokenStream.Current == ExpressionTokenType.SemiColon)
{
tokenStream.Advance();
node = new FieldNode()
{
name = name,
isStatic = isStatic,
attributes = attributes,
typeLookup = typeLookup
};
return(true);
}
if (tokenStream.Current != ExpressionTokenType.ParenOpen)
{
goto fail;
}
signature = StructList <LambdaArgument> .Get();
if (tokenStream.NextTokenIs(ExpressionTokenType.ParenClose))
{
tokenStream.Advance(2);
}
else
{
int matchingIndex = tokenStream.FindMatchingIndex(ExpressionTokenType.ParenOpen, ExpressionTokenType.ParenClose);
if (matchingIndex == -1)
{
goto fail;
}
TokenStream subStream = tokenStream.AdvanceAndReturnSubStream(matchingIndex);
subStream.Advance();
tokenStream.Advance();
if (!ExpressionParser.ParseSignature(subStream, signature))
{
goto fail;
}
for (int i = 0; i < signature.size; i++)
{
if (signature.array[i].type == null)
{
throw new ParseException($"When defining a method you must specify a type for all arguments. Found identifier {signature.array[i].identifier} but no type was given.");
}
}
}
if (tokenStream.Current != ExpressionTokenType.ExpressionOpen)
{
goto fail;
}
BlockNode block = ParseBlock();
node = new MethodNode()
{
body = block,
returnTypeLookup = typeLookup,
attributes = attributes,
name = name,
isStatic = isStatic,
signatureList = signature != null?signature.ToArray() : s_EmptySignature
};
StructList <LambdaArgument> .Release(ref signature);
parser.Release(false);
return(true);
fail:
{
tokenStream.Restore();
parser.Release(false);
typeLookup.Release();
signature?.Release();
return(false);
}
}
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);
}
public BlockDefinition2()
{
this.variables = StructList <Parameter> .Get();
this.statements = LightList <Expression> .Get();
}
public void AddSlotOverride(string slotName, UIElement context, int slotId)
{
slotInputs = slotInputs ?? StructList <SlotUsage> .Get();
slotInputs.Add(new SlotUsage(slotName, slotId, context));
}