public void EvaluatesBasicExpressionWithConstantAndParameter()
{
using var inputParams = new NativeArray <float>(new float[] { 2f }, Allocator.Persistent);
using var operatorData = new NativeArray <OperatorDefinition>(new OperatorDefinition[]
{
new OperatorDefinition
{
operatorType = OperatorType.MULTIPLY,
rhs = 1,
lhs = 2
},
new OperatorDefinition
{
operatorType = OperatorType.CONSTANT_VALUE,
nodeValue = 1.5f
},
new OperatorDefinition
{
operatorType = OperatorType.PARAMETER_VALUE,
parameterIndex = 0
},
}, Allocator.Persistent);
var expression = new StructExpression
{
operationDataSlice = new JaggedIndexing
{
index = 0,
length = 3
}
};
var result = expression.EvaluateExpression(
inputParams,
new JaggedIndexing
{
index = 0,
length = 1
},
operatorData);
Assert.AreEqual(3f, result);
}
public float DynamicInvoke(params float[] input)
{
using var inputParams = new NativeArray <float>(input, Allocator.Temp);
using var opDefs = new NativeArray <OperatorDefinition>(definitionList.ToArray(), Allocator.Temp);
var structExp = new StructExpression
{
operationDataSlice = new JaggedIndexing
{
index = 0,
length = (ushort)opDefs.Length
}
};
return(structExp.EvaluateExpression(
inputParams,
new JaggedIndexing
{
index = 0,
length = (ushort)inputParams.Length
},
opDefs));
}
public bool PreMatchCapturedParametersWithoutConditional(
SymbolStringBranchingCache branchingCache,
SymbolString <float> source,
int indexInSymbols,
NativeArray <float> parameterMemory,
int startIndexInParameterMemory,
ref LSystemSingleSymbolMatchData matchSingletonData,
TmpNativeStack <SymbolStringBranchingCache.BranchEventData> helperStack,
NativeArray <float> globalParams,
NativeArray <OperatorDefinition> globalOperatorData,
ref Unity.Mathematics.Random random,
NativeArray <RuleOutcome.Blittable> outcomes)
{
var target = targetSymbolWithParameters;
// parameters
byte matchedParameterNum = 0;
// context match
if (contextPrefix.IsValid && contextPrefix.graphNodeMemSpace.length > 0)
{
var backwardsMatchMatches = branchingCache.MatchesBackwards(
branchingCache.includeSymbols[ruleGroupIndex],
indexInSymbols,
contextPrefix,
source,
startIndexInParameterMemory + matchedParameterNum,
parameterMemory,
out var copiedParameters
);
if (!backwardsMatchMatches)
{
return(false);
}
matchedParameterNum += copiedParameters;
}
var coreParametersIndexing = source.parameters[indexInSymbols];
if (coreParametersIndexing.length != target.parameterLength)
{
return(false);
}
if (coreParametersIndexing.length > 0)
{
for (int i = 0; i < coreParametersIndexing.length; i++)
{
var paramValue = source.parameters[coreParametersIndexing, i];
parameterMemory[startIndexInParameterMemory + matchedParameterNum] = paramValue;
matchedParameterNum++;
}
}
if (contextSuffix.IsCreated && contextSuffix.graphNodeMemSpace.length > 0)
{
var forwardMatch = branchingCache.MatchesForward(
branchingCache.includeSymbols[ruleGroupIndex],
indexInSymbols,
contextSuffix,
source,
startIndexInParameterMemory + matchedParameterNum,
parameterMemory,
out var copiedParameters,
helperStack);
if (!forwardMatch)
{
return(false);
}
matchedParameterNum += copiedParameters;
}
matchSingletonData.tmpParameterMemorySpace = new JaggedIndexing
{
index = startIndexInParameterMemory,
length = matchedParameterNum
};
if (conditional.IsValid)
{
var conditionalMatch = conditional.EvaluateExpression(
globalParams,
new JaggedIndexing {
index = 0, length = (ushort)globalParams.Length
},
parameterMemory,
matchSingletonData.tmpParameterMemorySpace,
globalOperatorData) > 0;
if (!conditionalMatch)
{
return(false);
}
}
matchSingletonData.selectedReplacementPattern = SelectOutcomeIndex(ref random, outcomes, possibleOutcomeIndexing);
var outcomeObject = outcomes[matchSingletonData.selectedReplacementPattern + possibleOutcomeIndexing.index];
matchSingletonData.replacementSymbolIndexing = JaggedIndexing.GetWithOnlyLength(outcomeObject.replacementSymbolSize);
matchSingletonData.replacementParameterIndexing = JaggedIndexing.GetWithOnlyLength(outcomeObject.replacementParameterCount);
return(true);
}
