private void FillStartZeros(PackedSpace space) { for (var x = 0; x < spaceSize; x++) { space[x] = 0; } }
public PackedSpace EmulateInPlace() { var packer = rule.packer; var prevPrevSpace = new PackedSpace(packer, spaceSize); fillStart(prevPrevSpace); var prevSpace = new PackedSpace(packer, spaceSize); fillStart(prevSpace); var space = new PackedSpace(packer, spaceSize); for (var t = 2; t < timeSize; t++) { rule.FillSpace(space, prevSpace, prevPrevSpace); fillBorder(space); var tmpSpace = prevPrevSpace; prevPrevSpace = prevSpace; prevSpace = space; space = prevPrevSpace; } return(space); }
public IEnumerable <PackedSpace> Emulate() { var packer = rule.packer; var prevPrevSpace = new PackedSpace(packer, spaceSize); fillStart(prevPrevSpace); yield return(prevPrevSpace); var prevSpace = new PackedSpace(packer, spaceSize); fillStart(prevSpace); yield return(prevSpace); for (var t = 2; t < timeSize; t++) { var space = new PackedSpace(packer, spaceSize); rule.FillSpace(space, prevSpace, prevPrevSpace); fillBorder(space); yield return(space); prevPrevSpace = prevSpace; prevSpace = space; } }
private void FillStartRandom(PackedSpace space) { var stateCount = rule.stateCount; for (var x = 0; x < spaceSize; x++) { space[x] = random.Next(stateCount); } }
public void FillBorderZeros(PackedSpace space) { var snr = Rule.spaceNeighbourhoodRadius; for (var x = 0; x < snr; x++) { space[x] = 0; space[spaceSize - snr + x] = 0; } }
public void FillBorderRandom(PackedSpace space) { var snr = Rule.spaceNeighbourhoodRadius; var stateCount = rule.stateCount; for (var x = 0; x < snr; x++) { space[x] = random.Next(stateCount); space[spaceSize - snr + x] = random.Next(stateCount); } }
public void Emulate() { using (var measureTime = new MeasureTime()) { var random = useSeed ? new Random(seed) : new Random(); var packer = new Packer(stateCount); var rule = new Rule(packer, BigInteger.Parse(ruleCode), tablePackN); measureTime.Mark("After rule inst"); if (spacetime == null || spacetime.Length != timeSize || spacetime[0].spaceSize != spaceSize) { spacetime = new PackedSpace[timeSize]; for (var t = 0; t < spacetime.Length; t++) { spacetime[t] = new PackedSpace(packer, spaceSize); } } var emulator = new Emulator( rule, timeSize, spaceSize, startFill, borderFill, random); measureTime.Mark("After raw spacetime creation"); emulator.Emulate(spacetime); measureTime.Mark("After emulate itself"); var material = GetComponent <Renderer>().material; material.SetInt("_TimeSize", timeSize); material.SetInt("_SpaceSize", spaceSize); var spaceSizePacked = spacetime[0].packedSize; var bufferSize = timeSize * spaceSizePacked; if (buffer is null || buffer.count != bufferSize) { buffer?.Dispose(); buffer = new ComputeBuffer(bufferSize, sizeof(UInt32)); } for (var t = 0; t < spacetime.Length; t++) { buffer.SetData(spacetime[t].packed, 0, t * spaceSizePacked, spaceSizePacked); } material.SetBuffer("_SpacetimePacked", buffer); measureTime.Mark("After shader"); } }
public void Test() { if (shader is null || shader.shader != shaderRef) { shader?.DisposeBuffers(); shader = new EmulateComputeShader(shaderRef); } using (var measureTime = new MeasureTime()) { // if (rules == null) { // UpdateRules(); // measureTime.Mark("After UpdateRules"); // } shader.Emulate(stateCount, spaceSize, timeSize, randSeed, rules, inPlace); measureTime.Mark("After Dispatch"); var fs = new float[parallelRules]; var packer = rules[0].packer; var timeSize1 = inPlace ? 2 : timeSize; var packedSpaceSize = packer.GetPackedSize(spaceSize); var layerSize = packedSpaceSize * timeSize1; for (var i = 0; i < parallelRules; i++) { var space = new PackedSpace(packer, spaceSize); shader.spacetimePackedBuffer.GetData( space.packed, 0, layerSize * i + packedSpaceSize * (timeSize1 - 1), packedSpaceSize); fs[i] = RuleSpacetimeAnalyzer.RenderAnalyze(packer, spaceSize, space.Convolute(), patternLength); } measureTime.Mark("After Analyze"); SetDisplays(rules.Select(rule => rule.code.ToString()).ToArray(), fs); measureTime.Mark("After SetDisplays"); } }
public void FillSpace( PackedSpace t0Space, PackedSpace tm1Space, PackedSpace tm2Space ) { var cellSizeBits = packer.cellSizeBits; var cellsPerPack = packer.cellsPerPack; var ss = t0Space.spaceSize; var ps = t0Space.packedSize; var n = tablePackN; var tableN = tablePackedNCell; var nCellShift = n * cellSizeBits; var np2CellShift = (n + 2) * cellSizeBits; var np2CellMask = (1 << np2CellShift) - 1; var indexSize = n + n + 2; var combinedStateShift = indexSize * cellSizeBits; var combinedStateMask = ~(-1 << combinedStateShift); int GetStateNCell(int _pcn, int _n1cnn2) { var combinedState = ((_pcn << np2CellShift) | (_n1cnn2 & np2CellMask)) & combinedStateMask; return(tableN[combinedState]); } for (var px = 0; px < ps; px++) { var ptm1n1 = (px - 1 >= 0) ? tm1Space.packed[px - 1] : 0; var ptm1c = tm1Space.packed[px]; var ptm1n2 = (px + 1 < ps) ? tm1Space.packed[px + 1] : 0; var ptm2c = tm2Space.packed[px]; int pack = 0; var _ptm1c = packer.AppendToPack(ptm1n1, ptm1c, cellsPerPack - 1); for (var sx = 0; sx < cellsPerPack - 2; sx += n) { var shift = sx * cellSizeBits; var state = GetStateNCell(ptm2c >> shift, _ptm1c >> shift); pack |= state << shift; } _ptm1c = packer.AppendToPack(ptm1c, ptm1n2, 1); pack = pack & ~(-1 << ((cellsPerPack - 2) * cellSizeBits)); for (var sx = cellsPerPack - 2; sx < cellsPerPack; sx += n) { var shift = sx * cellSizeBits; var state = GetStateNCell( ptm2c >> shift, _ptm1c >> (shift - 2 * cellSizeBits)); pack |= state << shift; } t0Space.packed[px] = pack; } }
public void Emulate( int stateCount, int spaceSize, int timeSize, int randSeed, Rule[] rules, bool inPlace ) { Debug.Assert(rules[0].tablePackN == tablePackN); var packer = rules[0].packer; var spaceSizePacked = packer.GetPackedSize(spaceSize); var timestepsPerCall = (timeSize - Rule.timeNeighbourhoodRadius); if (usePackedPacked) { var packedRule = new PackedSpace( new Packer(4 * 4), rules[0].tablePackedNCell.Length); ComputeShaderEx.EnsureBuffer( ref ruleTablePackedNCellBuffer, rules.Length * packedRule.packed.Length, sizeof(int)); for (var i = 0; i < rules.Length; i++) { var rule = rules[i]; for (var j = 0; j < rule.tablePackedNCell.Length; j++) { packedRule[j] = rule.tablePackedNCell[j]; } ruleTablePackedNCellBuffer.SetData( packedRule.packed, 0, i * packedRule.packed.Length, packedRule.packed.Length); } } else { ComputeShaderEx.EnsureBuffer( ref ruleTablePackedNCellBuffer, rules.Length * rules[0].tablePackedNCell.Length, sizeof(int)); for (var i = 0; i < rules.Length; i++) { var rule = rules[i]; ruleTablePackedNCellBuffer.SetData( rule.tablePackedNCell, 0, i * rule.tablePackedNCell.Length, rule.tablePackedNCell.Length); } } var spacetimePackedBufferSize = rules.Length * spaceSizePacked * (inPlace ? 2 : timeSize); ComputeShaderEx.EnsureBuffer( ref spacetimePackedBuffer, spacetimePackedBufferSize, sizeof(int)); ComputeShaderEx.EnsureBuffer( ref flagBuffer, 1, sizeof(int)); shader.Set("_RandSeed", randSeed); shader.Set("_SpaceSize", spaceSize); shader.Set("_TimeSize", inPlace ? 2 : timeSize); shader.Set("_TimeTo", timeSize); var fillStartRandomKernel = this.fillStartRandomKernel; fillStartRandomKernel.SetBuffer( "_SpacetimePacked", spacetimePackedBuffer); fillStartRandomKernel.Dispatch(spaceSizePacked, rules.Length); var emulateKernelName = "CSEmulate"; var emulateKernel = new ShaderKernel(shader, emulateKernelName); emulateKernel.Set( "_SpacetimePacked", spacetimePackedBuffer); emulateKernel.Set( "_Flag", flagBuffer); emulateKernel.Set( "_RuleTablePackedNCell", ruleTablePackedNCellBuffer); var tnr = Rule.timeNeighbourhoodRadius; for (var t = tnr; t < timeSize; t += timestepsPerCall) { shader.SetInt("_TimeStep", t); emulateKernel.Dispatch( spaceSizePacked, rules.Length); } var data = new int[1]; flagBuffer.GetData(data); }
public static float RenderAnalyze(PackedSpace space, int[] convolution, int size) => RenderAnalyze(space.packer, space.spaceSize, convolution, size);