public TurtleMeshBuildingCompletable(
Mesh targetMesh,
NativeArray <TurtleMeshAllocationCounter> resultMeshSizeBySubmesh,
DependencyTracker <NativeTurtleData> nativeData,
NativeList <TurtleOrganInstance> organInstances)
{
if (nativeData.IsDisposed)
{
throw new InvalidOperationException("turtle data has been disposed before completable could finish.");
}
this.targetMesh = targetMesh;
targetMesh.MarkDynamic();
this.resultMeshSizeBySubmesh = resultMeshSizeBySubmesh;
UnityEngine.Profiling.Profiler.BeginSample("mesh data building job");
UnityEngine.Profiling.Profiler.BeginSample("allocating");
var lastSubmeshSize = resultMeshSizeBySubmesh[resultMeshSizeBySubmesh.Length - 1];
meshData = new MyMeshData
{
indices = new NativeArray <uint>(lastSubmeshSize.indexInTriangles + lastSubmeshSize.totalTriangleIndexes, Allocator.TempJob), // TODO: does this have to be persistent? or can it be tempjob since it'll be handed to the mesh?
vertexData = new NativeArray <MeshVertexLayout>(lastSubmeshSize.indexInVertexes + lastSubmeshSize.totalVertexes, Allocator.TempJob),
meshBounds = new NativeArray <Bounds>(1, Allocator.TempJob)
};
var turtleEntitySpawnJob = new TurtleMeshBuildingJob
{
templateVertexData = nativeData.Data.vertexData,
templateTriangleData = nativeData.Data.triangleData,
templateOrganData = nativeData.Data.allOrganData,
submeshSizes = resultMeshSizeBySubmesh,
organInstances = organInstances,
targetMesh = meshData
};
UnityEngine.Profiling.Profiler.EndSample();
UnityEngine.Profiling.Profiler.BeginSample("scheduling");
currentJobHandle = turtleEntitySpawnJob.Schedule();
nativeData.RegisterDependencyOnData(currentJobHandle);
currentJobHandle = organInstances.Dispose(currentJobHandle);
UnityEngine.Profiling.Profiler.EndSample();
UnityEngine.Profiling.Profiler.EndSample();
}
private JobHandle ScheduleImmaturityJob(JobHandle dependency)
{
if (nativeData.Data.immaturityMarkerSymbols.IsCreated)
{
isImmature = new NativeArray <bool>(1, Allocator.TempJob);
var immaturityJob = new NativeArrayMultiContainsJob
{
symbols = target.symbols,
symbolsToCheckFor = nativeData.Data.immaturityMarkerSymbols,
doesContainSymbols = isImmature
};
dependency = immaturityJob.Schedule(dependency);
nativeData.RegisterDependencyOnData(dependency);
}
return(dependency);
}
public TurtleStringReadingCompletable(
Mesh targetMesh,
int totalSubmeshes,
DependencyTracker <SymbolString <float> > symbols,
DependencyTracker <NativeTurtleData> nativeData,
int branchStartChar,
int branchEndChar,
TurtleState defaultState,
CustomRuleSymbols customSymbols,
TurtleVolumeWorldReferences volumetrics,
Matrix4x4 localToWorldTransform)
{
this.targetMesh = targetMesh;
this.nativeData = nativeData;
UnityEngine.Profiling.Profiler.BeginSample("turtling job");
JobHandleWrapper volumetricJobHandle = currentJobHandle;
var volumetricHandles = new TurtleVolumetricHandles
{
durabilityWriter = volumetrics.durabilityWriter.GetNextNativeWritableHandle(localToWorldTransform, ref volumetricJobHandle),
universalWriter = volumetrics.universalLayerWriter.GetNextNativeWritableHandle(localToWorldTransform),
volumetricData = volumetrics.world.NativeVolumeData.openReadData.AsReadOnly()
};
currentJobHandle = volumetricJobHandle;
UnityEngine.Profiling.Profiler.BeginSample("allocating");
var tmpHelperStack = new TmpNativeStack <TurtleState>(50, Allocator.TempJob);
organInstances = new NativeList <TurtleOrganInstance>(100, Allocator.TempJob);
newMeshSizeBySubmesh = new NativeArray <TurtleMeshAllocationCounter>(totalSubmeshes, Allocator.TempJob);
UnityEngine.Profiling.Profiler.EndSample();
NativeArray <float> destructionCommandTimestamps;
if (volumetrics.damageFlags != null)
{
destructionCommandTimestamps = volumetrics.damageFlags.GetDestructionCommandTimestampsReadOnly();
}
else
{
destructionCommandTimestamps = new NativeArray <float>(0, Allocator.TempJob);
}
var entitySpawningSystem = World.DefaultGameObjectInjectionWorld.GetOrCreateSystem <BeginSimulationEntityCommandBufferSystem>();
var entitySpawnBuffer = entitySpawningSystem.CreateCommandBuffer();
var turtleCompileJob = new TurtleCompilationJob
{
symbols = symbols.Data,
operationsByKey = nativeData.Data.operationsByKey,
organData = nativeData.Data.allOrganData,
organInstances = organInstances,
newMeshSizeBySubmesh = newMeshSizeBySubmesh,
spawnEntityBuffer = entitySpawnBuffer,
nativeTurtleStack = tmpHelperStack,
branchStartChar = branchStartChar,
branchEndChar = branchEndChar,
currentState = defaultState,
customRules = customSymbols,
volumetricHandles = volumetricHandles,
hasVolumetricDestruction = volumetrics.damageFlags != null,
volumetricDestructionTimestamps = destructionCommandTimestamps,
earliestValidDestructionCommand = volumetrics.damageFlags != null ? Time.time - volumetrics.damageFlags.timeCommandStaysActive : -1
};
currentJobHandle = turtleCompileJob.Schedule(currentJobHandle);
volumetrics.world.NativeVolumeData.RegisterReadingDependency(currentJobHandle);
entitySpawningSystem.AddJobHandleForProducer(currentJobHandle);
volumetrics.damageFlags?.RegisterReaderOfDestructionFlags(currentJobHandle);
volumetrics.durabilityWriter.RegisterWriteDependency(currentJobHandle);
volumetrics.universalLayerWriter.RegisterWriteDependency(currentJobHandle);
nativeData.RegisterDependencyOnData(currentJobHandle);
symbols.RegisterDependencyOnData(currentJobHandle);
currentJobHandle = tmpHelperStack.Dispose(currentJobHandle);
if (volumetrics.damageFlags == null)
{
currentJobHandle = destructionCommandTimestamps.Dispose(currentJobHandle);
}
UnityEngine.Profiling.Profiler.EndSample();
}
public LSystemSymbolReplacementCompletable(
Unity.Mathematics.Random randResult,
LSystemState <float> lastSystemState,
int totalNewSymbolSize,
int totalNewParamSize,
NativeArray <float> globalParamNative,
NativeArray <float> tmpParameterMemory,
NativeArray <LSystemSingleSymbolMatchData> matchSingletonData,
DependencyTracker <SystemLevelRuleNativeData> nativeData,
SymbolStringBranchingCache branchingCache,
CustomRuleSymbols customSymbols)
{
this.lastSystemState = lastSystemState;
this.matchSingletonData = matchSingletonData;
this.branchingCache = branchingCache;
UnityEngine.Profiling.Profiler.BeginSample("allocating");
target = new SymbolString <float>(totalNewSymbolSize, totalNewParamSize, Allocator.Persistent);
UnityEngine.Profiling.Profiler.EndSample();
this.randResult = randResult;
this.nativeData = nativeData;
// 5
UnityEngine.Profiling.Profiler.BeginSample("generating replacements");
var replacementJob = new RuleReplacementJob
{
globalParametersArray = globalParamNative,
parameterMatchMemory = tmpParameterMemory,
matchSingletonData = matchSingletonData,
sourceData = lastSystemState.currentSymbols.Data,
structExpressionSpace = nativeData.Data.structExpressionMemorySpace,
globalOperatorData = nativeData.Data.dynamicOperatorMemory,
replacementSymbolData = nativeData.Data.replacementsSymbolMemorySpace,
outcomeData = nativeData.Data.ruleOutcomeMemorySpace,
targetData = target,
blittableRulesByTargetSymbol = nativeData.Data.blittableRulesByTargetSymbol,
branchingCache = branchingCache,
customSymbols = customSymbols
};
currentJobHandle = replacementJob.Schedule(
matchSingletonData.Length,
100
);
if (customSymbols.hasDiffusion && !customSymbols.independentDiffusionUpdate)
{
diffusionHelper = new DiffusionWorkingDataPack(10, 5, 2, customSymbols, Allocator.TempJob);
var diffusionJob = new ParallelDiffusionReplacementJob
{
matchSingletonData = matchSingletonData,
sourceData = lastSystemState.currentSymbols.Data,
targetData = target,
customSymbols = customSymbols,
working = diffusionHelper
};
currentJobHandle = JobHandle.CombineDependencies(
currentJobHandle,
diffusionJob.Schedule()
);
}
// only parameter modifications beyond this point
lastSystemState.currentSymbols.RegisterDependencyOnData(currentJobHandle);
nativeData.RegisterDependencyOnData(currentJobHandle);
currentJobHandle = JobHandle.CombineDependencies(
JobHandle.CombineDependencies(
ScheduleIdAssignmentJob(currentJobHandle, customSymbols, lastSystemState),
ScheduleIndependentDiffusion(currentJobHandle, customSymbols)
),
JobHandle.CombineDependencies(
ScheduleAutophagyJob(currentJobHandle, customSymbols),
ScheduleImmaturityJob(currentJobHandle)
));
UnityEngine.Profiling.Profiler.EndSample();
}
/// <summary>
///
/// </summary>
/// <param name="lastSystemState"></param>
/// <param name="lSystemNativeData"></param>
/// <param name="globalParameters"></param>
/// <param name="maxMemoryRequirementsPerSymbol"></param>
/// <param name="branchOpenSymbol"></param>
/// <param name="branchCloseSymbol"></param>
/// <param name="includedCharactersByRuleIndex"></param>
/// <param name="customSymbols"></param>
/// <param name="parameterModificationJobDependency">A dependency on a job which only makes changes to the parameters of the source symbol string.
/// the symbols themselves must be constant</param>
public LSystemRuleMatchCompletable(
NativeArray <LSystemSingleSymbolMatchData> matchSingletonData,
int parameterTotalSum,
SymbolStringBranchingCache branchingCache,
LSystemState <float> lastSystemState,
DependencyTracker <SystemLevelRuleNativeData> lSystemNativeData,
float[] globalParameters,
CustomRuleSymbols customSymbols,
JobHandle parameterModificationJobDependency)
{
this.customSymbols = customSymbols;
this.lastSystemState = lastSystemState;
randResult = lastSystemState.randomProvider;
nativeData = lSystemNativeData;
this.matchSingletonData = matchSingletonData;
this.branchingCache = branchingCache;
// 1.
UnityEngine.Profiling.Profiler.BeginSample("allocating");
tmpParameterMemory = new NativeArray <float>(parameterTotalSum, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
globalParamNative = new NativeArray <float>(globalParameters, Allocator.Persistent);
UnityEngine.Profiling.Profiler.EndSample();
// 2.
UnityEngine.Profiling.Profiler.BeginSample("matching");
var prematchJob = new RuleCompleteMatchJob
{
matchSingletonData = matchSingletonData,
sourceData = lastSystemState.currentSymbols.Data,
tmpParameterMemory = tmpParameterMemory,
globalOperatorData = nativeData.Data.dynamicOperatorMemory,
outcomes = nativeData.Data.ruleOutcomeMemorySpace,
globalParams = globalParamNative,
blittableRulesByTargetSymbol = nativeData.Data.blittableRulesByTargetSymbol,
branchingCache = branchingCache,
seed = randResult.NextUInt()
};
var matchingJobHandle = prematchJob.ScheduleBatch(
matchSingletonData.Length,
100,
parameterModificationJobDependency);
UnityEngine.Profiling.Profiler.EndSample();
// 4.
UnityEngine.Profiling.Profiler.BeginSample("replacement counting");
UnityEngine.Profiling.Profiler.BeginSample("allocating");
totalSymbolCount = new NativeArray <int>(1, Allocator.Persistent);
totalSymbolParameterCount = new NativeArray <int>(1, Allocator.Persistent);
UnityEngine.Profiling.Profiler.EndSample();
var totalSymbolLengthJob = new RuleReplacementSizeJob
{
matchSingletonData = matchSingletonData,
totalResultSymbolCount = totalSymbolCount,
totalResultParameterCount = totalSymbolParameterCount,
sourceData = lastSystemState.currentSymbols.Data,
customSymbols = customSymbols
};
currentJobHandle = totalSymbolLengthJob.Schedule(matchingJobHandle);
lastSystemState.currentSymbols.RegisterDependencyOnData(currentJobHandle);
nativeData.RegisterDependencyOnData(currentJobHandle);
UnityEngine.Profiling.Profiler.EndSample();
}
