private Schematic ProcessShaderPatina(Schematic schematic)
{
using (ProgressBar progressBar = new ProgressBar())
{
int index = 0;
List <Voxel> allVoxels = schematic.GetAllVoxels();
int colorChanged = 0;
foreach (Voxel voxel in allVoxels)
{
if (Grows(schematic, voxel))
{
uint newColor = GetCrowColor(schematic, voxel);
if (voxel.Color != newColor)
{
schematic.ReplaceVoxel(voxel, newColor);
colorChanged++;
}
}
progressBar.Report(index++ / (float)(allVoxels.Count));
}
Console.WriteLine("COLOR CHANGED: " + colorChanged);
if (colorChanged == 0)
{
mShouldBreak = true;
Console.WriteLine("[INFO] NO COLORS CHANGED, BREAK");
}
}
return(schematic);
}
public async Task <Schematic> CreateSchematicAsync(Schematic schematic, string forkedFrom, CancellationToken cancellationToken)
{
var definition = _StringSerializer.Serialize(schematic);
var results = await DefineCommand(
"INSERT INTO Schematics (SchematicName, ForkedFrom, InitialState, Schematic) " +
"VALUES (@SchematicName, @ForkedFrom, @InitialState, @Schematic);" +
"\r\n\r\n" +
"SELECT * FROM Schematics WHERE SchematicName = @SchematicName")
.SendNullValues()
.WithResultsAs <SchematicRecord>()
.Compile()
.ExecuteAsync(DatabaseManagerPool.DatabaseManager, new
{
schematic.SchematicName,
ForkedFrom = forkedFrom,
schematic.InitialState,
Schematic = definition
}, cancellationToken).ConfigureAwait(false);
var schematicRecord = results.Single();
var schematicResult = _StringSerializer.Deserialize <Schematic>(schematicRecord.Schematic);
return(schematicResult);
}
private uint GetCrowColor(Schematic schematic, Voxel voxel)
{
float distance = MinDistanceToWall(schematic, voxel, mShaderPatina.Thickness);
float index = mShaderPatina.TargetColorIndex + mShaderPatina.AdditionalColorRange * (distance / MathF.Sqrt(MathF.Pow(mShaderPatina.Thickness, 2) * 3));
return(schematic.GetColorAtPaletteIndex((int)index));
}
protected HashSet <Voxel> FillHoles(uint[,,] blocks, Schematic schematic)
{
Console.WriteLine("[LOG] Started to fill holes...");
int max = schematic.Width * schematic.Height * schematic.Length * 2;
int index = 0;
using (ProgressBar progressBar = new ProgressBar())
{
for (int i = 0; i < 2; i++)
{
for (ushort y = 0; y < schematic.Height; y++)
{
for (ushort z = 0; z < schematic.Length; z++)
{
for (ushort x = 0; x < schematic.Width; x++)
{
if (blocks[x, y, z] == 0 && x > 0 && x <= schematic.Width && y > 0 && y <= schematic.Height && z > 0 && z <= schematic.Length)
{
blocks = Check1X1X1Hole(blocks, x, y, z);
blocks = Check1X2X1Hole(blocks, x, y, z);
blocks = Check2X1X1Hole(blocks, x, y, z);
blocks = Check1X1X2Hole(blocks, x, y, z);
}
progressBar.Report(index / (float)max);
index++;
}
}
}
}
}
Console.WriteLine("[LOG] Done.");
return(blocks.ToHashSetFrom3DArray());
}
public Schematic WriteSchematic()
{
Schematic finalSchematic = new Schematic();
if (mSchematic != null)
{
finalSchematic = new Schematic(mSchematic.GetAllVoxels());
}
Console.WriteLine("[INFO] Count steps: " + mHeightmapData.Steps.Length);
for (int index = 0; index < mHeightmapData.Steps.Length; index++)
{
Console.WriteLine("[INFO] Start parse heightmap for step : " + index);
HeightmapStep step = mHeightmapData.Steps[index];
step.ValidateSettings();
step.DisplayInfo();
Bitmap bitmap = new Bitmap(new FileInfo(step.TexturePath).FullName);
Bitmap bitmapColor = null;
if (!string.IsNullOrEmpty(step.ColorTexturePath))
{
bitmapColor = new Bitmap(new FileInfo(step.ColorTexturePath).FullName);
}
Schematic schematicStep = ImageUtils.WriteSchematicFromImage(bitmap, bitmapColor, step);
finalSchematic = SchematicMerger.Merge(finalSchematic, schematicStep, step);
}
return(finalSchematic);
}
//For now we're assuming (probably ignorantly) that schematics don't have the same block count issues as structures.
//If this gives weird counts, then we need to refactor the nbt reading to take the things in those straight brackets as properties
//and turn them into structure style blocks. Then we need to use the structure version of determine block count.
private Dictionary <int, int> SetBlockCounts(Schematic schematic, Dictionary <int, int> itemDictionary)
{
foreach (int block in schematic.BlockData)
{
var blockPalette = schematic.Palette.FirstOrDefault(x => x.SchemBlockId == block);
string blockMinecraftId = null;
if (blockPalette != null)
{
blockMinecraftId = blockPalette.MinecraftId;
}
if (blockMinecraftId == null)
{
continue;
}
var blockId = blockMinecraftId.GetItemId();
var palette = schematic.Palette.First(x => x.SchemBlockId == block);
if (blockMinecraftId.Contains("slab") && !palette.Properties.Values.Contains("top"))
{
var truth = "Her I am";
}
itemDictionary = ParsePropertyBasedCounts(itemDictionary, palette, blockId);
}
return(itemDictionary);
}
protected HashSet <Voxel> FixLonelyVoxels(uint[,,] blocks, Schematic schematic)
{
Console.WriteLine("[LOG] Started to delete lonely voxels...");
int max = schematic.Width * schematic.Height * schematic.Length * 2;
int index = 0;
using (ProgressBar progressBar = new ProgressBar())
{
for (ushort y = 0; y < schematic.Height; y++)
{
for (ushort z = 0; z < schematic.Length; z++)
{
for (ushort x = 0; x < schematic.Width; x++)
{
if (blocks[x, y, z] != 0 && x > 0 && x < schematic.Width && y > 0 && y < schematic.Height && z > 0 && z < schematic.Length)
{
if (blocks[x - 1, y, z] == 0 && blocks[x + 1, y, z] == 0 && blocks[x, y - 1, z] == 0 && blocks[x, y + 1, z] == 0 && blocks[x, y, z - 1] == 0 && blocks[x, y, z + 1] == 0)
{
blocks[x, y, z] = 0;
}
}
progressBar.Report(index / (float)max);
index++;
}
}
}
}
Console.WriteLine("[LOG] Done.");
return(blocks.ToHashSetFrom3DArray());
}
private static bool SchematicToVox(AbstractToSchematic converter)
{
Schematic schematic = converter.WriteSchematic();
Console.WriteLine($"[INFO] Vox Width: {schematic.Width}");
Console.WriteLine($"[INFO] Vox Length: {schematic.Length}");
Console.WriteLine($"[INFO] Vox Height: {schematic.Height}");
if (schematic.Width > Schematic.MAX_WORLD_WIDTH || schematic.Length > Schematic.MAX_WORLD_LENGTH || schematic.Height > Schematic.MAX_WORLD_HEIGHT)
{
Console.WriteLine("[ERROR] Model is too big ! MagicaVoxel can't support model bigger than 2000x2000x1000");
return(false);
}
VoxWriter writer = new VoxWriter();
if (INPUT_PALETTE_FILE != null)
{
PaletteSchematicConverter converterPalette = new PaletteSchematicConverter(INPUT_PALETTE_FILE);
schematic = converterPalette.ConvertSchematic(schematic);
return(writer.WriteModel(FormatOutputDestination(OUTPUT_PATH), converterPalette.GetPalette(), schematic));
}
if (INPUT_SHADER_FILE != null)
{
JsonToSchematic jsonParser = new JsonToSchematic(INPUT_SHADER_FILE, schematic);
schematic = jsonParser.WriteSchematic();
}
return(writer.WriteModel(FormatOutputDestination(OUTPUT_PATH), null, schematic));
}
private void viewDXF(string source)
{
DXFFile fileRep = new DXFFile(source);
drawing = new Schematic(fileRep, this, mainCanvas);
drawing.draw(mainCanvas);
}
public override Schematic WriteSchematic()
{
List <Voxel> list = Quantization.ApplyQuantization(mSchematic.GetAllVoxels(), ColorLimit);
Schematic schematic = new Schematic(list);
return(schematic);
}
protected void AddMultipleBlocks(ref Schematic schematic, int minZ, int maxZ, int x, int y, Color color)
{
for (int z = minZ; z < maxZ; z++)
{
AddBlock(ref schematic, new Voxel((ushort)x, (ushort)z, (ushort)y, color.ColorToUInt()));
}
}
private Schematic Convert(List <VoxelDTO> voxels)
{
int minX = voxels.Min(x => x.X);
int minY = voxels.Min(x => x.Y);
int minZ = voxels.Min(x => x.Z);
Schematic schematic = new Schematic();
Console.WriteLine("[INFO] Started to write schematic from qb...");
Console.WriteLine("[INFO] Qb Width: " + schematic.Width);
Console.WriteLine("[INFO] Qb Length: " + schematic.Length);
Console.WriteLine("[INFO] Qb Height: " + schematic.Height);
using (ProgressBar progressbar = new ProgressBar())
{
for (var index = 0; index < voxels.Count; index++)
{
VoxelDTO voxel = voxels[index];
voxel.X -= minX;
voxel.Y -= minY;
voxel.Z -= minZ;
ushort x = (ushort)voxel.X;
ushort y = (ushort)voxel.Y;
ushort z = (ushort)voxel.Z;
schematic.AddVoxel(x, y, z, FctExtensions.ByteArrayToUInt(voxel.R, voxel.G, voxel.B, 1));
progressbar.Report((index / (float)voxels.Count));
}
}
Console.WriteLine("[INFO] Done.");
return(schematic);
}
public SchematicIterator(ConstructionArea area, string schematicName, Schematic.Rotation rotation)
{
this.area = area;
positionMin = area.Minimum;
positionMax = area.Maximum;
iterationChunkLocation = positionMin;
cursor = positionMin;
SchematicName = schematicName;
if (SchematicReader.TryGetSchematic(SchematicName, area.Owner.ColonyID, iterationChunkLocation, out var schematic))
{
BuilderSchematic = schematic;
if (rotation >= Schematic.Rotation.Right)
{
BuilderSchematic.Rotate();
}
if (rotation >= Schematic.Rotation.Back)
{
BuilderSchematic.Rotate();
}
if (rotation >= Schematic.Rotation.Left)
{
BuilderSchematic.Rotate();
}
}
}
public override Schematic WriteSchematic()
{
float minX = _blocks.MinBy(t => t.X).X;
float minY = _blocks.MinBy(t => t.Y).Y;
float minZ = _blocks.MinBy(t => t.Z).Z;
float maxX = _blocks.MaxBy(t => t.X).X;
float maxY = _blocks.MaxBy(t => t.Y).Y;
float maxZ = _blocks.MaxBy(t => t.Z).Z;
Schematic schematic = new Schematic()
{
Length = (ushort)(Math.Abs(maxZ - minZ)),
Width = (ushort)(Math.Abs(maxX - minX)),
Heigth = (ushort)(Math.Abs(maxY - minY)),
Blocks = new HashSet <Block>()
};
LoadedSchematic.LengthSchematic = schematic.Length;
LoadedSchematic.WidthSchematic = schematic.Width;
LoadedSchematic.HeightSchematic = schematic.Heigth;
List <Block> list = Quantization.ApplyQuantization(_blocks);
list.ApplyOffset(new Vector3(minX, minY, minZ));
HashSet <Block> hashSet = list.ToHashSet();
//RemoveHoles(ref hashSet, schematic);
schematic.Blocks = hashSet;
return(schematic);
}
/// <summary>
/// BitmapをSchematicに変換
/// </summary>
/// <param name="bitmap"></param>
/// <returns></returns>
public TagCompound ToSchematic(Bitmap bitmap)
{
var schematic = new Schematic(bitmap.Width, 1, bitmap.Height);
var result = Convert(bitmap);
for (var y = 0; y < bitmap.Height; y++)
{
for (var x = 0; x < bitmap.Width; x++)
{
var blockColor = result[x, y];
try
{
var block = AnvilImprovedDataProvider.Instance.GetBlock("minecraft:" + blockColor.BlockName);
schematic.SetBlock(x, 0, y, block.DefaultBlockSet);
}
catch (Exception)
{
MessageBox.Show(blockColor.BlockName);
}
}
convertFile.Complete++;
}
return(schematic.BuildTag());
}
public async Task BulkCreateMachineFromSchematicAsync()
{
// Arrange
var schematic = new Schematic <string, string>
{
SchematicName = "schematic name",
InitialState = "initial state",
States = new[] { new State <string, string> {
Value = "initial state"
} }
};
var schematicBytes = MessagePackSerializer.Serialize(schematic, ContractlessStandardResolver.Instance);
var metadataEnumerable = new List <Dictionary <string, string> >();
var firstKey = "first key";
var firstValue = "first value";
var firstMetadataEntry = new Dictionary <string, string> {
{ firstKey, firstValue }
};
var secondKey = "second key";
var secondValue = "second value";
var secondMetadataEntry = new Dictionary <string, string> {
{ secondKey, secondValue }
};
metadataEnumerable.Add(firstMetadataEntry);
metadataEnumerable.Add(secondMetadataEntry);
_localAdapterMock
.Setup(_ => _.BulkCreateMachineFromSchematicAsync <string, string>(
It.Is <Schematic <string, string> >(it => it.SchematicName == schematic.SchematicName),
It.IsAny <IEnumerable <IDictionary <string, string> > >(),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(
new BulkCreateMachineResponse
{
MachineIds = new[] { "a", "b" }
}));
// Act
var response = await _stateMachineServiceMock.Object
.BulkCreateMachineFromSchematicAsync(new BulkCreateMachineFromSchematicRequest
{
SchematicBytes = schematicBytes,
Metadata = metadataEnumerable
});
// Assert
// Note: first parameter has to be checked for It.Is, other parameters CANNOT or the verify will fail
_localAdapterMock.Verify(
expression: _ => _.BulkCreateMachineFromSchematicAsync(
It.Is <Schematic <string, string> >(it => it.SchematicName == schematic.SchematicName),
metadataEnumerable,
CancellationToken.None),
times: Times.Once());
Assert.NotNull(response);
Assert.NotNull(response.MachineIds);
Assert.Collection(response.MachineIds, Assert.NotNull, Assert.NotNull);
Assert.Collection(response.MachineIds, machineId => Assert.Equal("a", machineId), machineId => Assert.Equal("b", machineId));
}
public Schematic ApplyShader(Schematic schematic, ShaderStep shaderStep)
{
List <Voxel> allVoxels = schematic.GetAllVoxels();
int index = 0;
using (ProgressBar progressBar = new ProgressBar())
{
foreach (Voxel voxel in allVoxels)
{
int x = voxel.X;
int y = voxel.Y;
int z = voxel.Z;
if (x == 0 || y == 0 || z == 0)
{
continue;
}
if (schematic.GetColorAtVoxelIndex(x - 1, y, z) == 0 &&
schematic.GetColorAtVoxelIndex(x + 1, y, z) == 0 &&
schematic.GetColorAtVoxelIndex(x, y - 1, z) == 0 &&
schematic.GetColorAtVoxelIndex(x, y + 1, z) == 0 &&
schematic.GetColorAtVoxelIndex(x, y, z - 1) == 0 &&
schematic.GetColorAtVoxelIndex(x, y, z + 1) == 0)
{
schematic.RemoveVoxel(x, y, z);
}
progressBar.Report(index++ / (float)allVoxels.Count);
}
}
Console.WriteLine("[INFO] Done.");
return(schematic);
}
public async Task GetSchematicAsync()
{
// Arrange
var schematicName = "schematic name";
var schematic = new Schematic <string, string> {
SchematicName = "schematic name"
};
var schematicBytes = MessagePackSerializer.Serialize(schematic, ContractlessStandardResolver.Instance);
_localAdapterMock
.Setup(_ => _.GetSchematicAsync <string, string>(
It.Is <string>(it => it == schematicName),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetSchematicResponse
{
SchematicBytes = schematicBytes
});
// Act
var response = await _stateMachineServiceMock.Object
.GetSchematicAsync(new GetSchematicRequest
{
SchematicName = schematicName
});
// Assert
Assert.NotNull(response);
Assert.Equal(schematicBytes, response.SchematicBytes);
}
public Schematic ConvertSchematic(Schematic schematic)
{
Console.WriteLine("[INFO] Started to convert all colors of blocks to match the palette");
Schematic newSchematic = new Schematic(GetPaletteUint());
List <uint> colors = schematic.UsedColors;
Dictionary <uint, int> paletteDictionary = new Dictionary <uint, int>();
foreach (uint color in colors)
{
int index = ColorComparison.CompareColorRGB(_colors, color.UIntToColor());
paletteDictionary[color] = index;
}
using (ProgressBar progressbar = new ProgressBar())
{
int i = 0;
List <Voxel> allVoxels = schematic.GetAllVoxels();
foreach (Voxel block in allVoxels)
{
newSchematic.AddVoxel(block.X, block.Y, block.Z,
_colors[paletteDictionary[block.Color]].ColorToUInt());
progressbar.Report(i++ / (float)allVoxels.Count);
}
}
Console.WriteLine("[INFO] Done.");
return(newSchematic);
}
private void AddMultipleBlocks(ref Schematic schematic, int minZ, int maxZ, int x, int y, Color color)
{
for (int z = minZ; z < maxZ; z++)
{
AddBlock(ref schematic, new Block((short)x, (short)z, (short)y, color.ColorToUInt()));
}
}
public override Schematic WriteSchematic()
{
float minX = _blocks.MinBy(t => t.X).X;
float minY = _blocks.MinBy(t => t.Y).Y;
float minZ = _blocks.MinBy(t => t.Z).Z;
Schematic schematic = new Schematic();
List <Voxel> list = Quantization.ApplyQuantization(_blocks, _colorLimit);
list.ApplyOffset(new Vector3(minX, minY, minZ));
HashSet <Voxel> hashSet = list.ToHashSet();
if (_holes)
{
hashSet = FillHoles(hashSet.To3DArray(schematic), schematic);
}
if (_flood)
{
hashSet = FillInvisiblesVoxels(hashSet.To3DArray(schematic), schematic);
}
if (_lonely)
{
hashSet = FixLonelyVoxels(hashSet.To3DArray(schematic), schematic);
}
schematic.Blocks = hashSet;
return(schematic);
}
private static void SchematicToVox(AbstractToSchematic converter, string outputPath)
{
Schematic schematic = converter.WriteSchematic();
Console.WriteLine($"[INFO] Vox Width: {schematic.Width}");
Console.WriteLine($"[INFO] Vox Length: {schematic.Length}");
Console.WriteLine($"[INFO] Vox Height: {schematic.Height}");
if (schematic.Width > MAX_WORLD_WIDTH || schematic.Length > MAX_WORLD_LENGTH || schematic.Height > MAX_WORLD_HEIGHT)
{
Console.WriteLine("[ERROR] Voxel model is too big ! MagicaVoxel can't support model bigger than 2000^3");
return;
}
VoxWriter writer = new VoxWriter();
if (_inputPaletteFile != null)
{
PaletteSchematicConverter converterPalette = new PaletteSchematicConverter(_inputPaletteFile, _colorLimit);
schematic = converterPalette.ConvertSchematic(schematic);
writer.WriteModel(_chunkSize, outputPath + ".vox", converterPalette.GetPalette(), schematic);
}
else
{
writer.WriteModel(_chunkSize, outputPath + ".vox", null, schematic);
}
}
private Schematic GetSchematic()
{
int width = Math.Min(Math.Max(TerrainEnvironment.Instance.WorldTerrainData.Width, TerrainEnvironment.Instance.WorldTerrainData.Length), 2000);
int chunkXZDistance = width / 2;
int chunkYDistance = 1000 / 2;
int visibleXMin = -chunkXZDistance;
int visibleXMax = chunkXZDistance - 1;
int visibleZMin = -chunkXZDistance;
int visibleZMax = chunkXZDistance - 1;
int visibleYMin = -chunkYDistance;
int visibleYMax = chunkYDistance - 1;
uint[,,] voxels = TerrainEnvironment.Instance.GetVoxels(new Vector3(visibleXMin, visibleYMin, visibleZMin), new Vector3(visibleXMax, visibleYMax, visibleZMax));
Schematic schematic = new Schematic();
for (int y = 0; y < voxels.GetLength(0); y++)
{
for (int z = 0; z < voxels.GetLength(1); z++)
{
for (int x = 0; x < voxels.GetLength(2); x++)
{
if (voxels[y, z, x] != 0)
{
schematic.Blocks.Add(new Voxel((ushort)x, (ushort)y, (ushort)z, voxels[y, z, x]));
}
}
}
}
return(schematic);
}
public string PreviewDiagram(Schematic schematic)
{
var machine = _stateMachineFactory
.ConstructFromConfiguration(_apiKey, null, schematic);
return(machine.ToString());
}
private float DistanceAverage(Schematic schematic, Voxel currentVoxel, List <Voxel> voxels)
{
float sum = voxels.Where(v => v != null).Aggregate <Voxel, float>(0, (current, voxel) => current + Distance(schematic.GetPaletteIndex(currentVoxel.Color), schematic.GetPaletteIndex(voxel.Color)));
sum /= voxels.Count(v => v != null);
return(sum);
}
public Schematic ApplyShader(Schematic schematic, ShaderStep shaderStep)
{
ShaderFill shaderFill = shaderStep as ShaderFill;
if (shaderFill.TargetColorIndex == -1)
{
schematic = ProcessSchematicInDeleteMode(schematic, shaderFill);
}
else
{
switch (shaderFill.RotationMode)
{
case RotationMode.X:
schematic = ProcessSchematicInXAxis(schematic, shaderFill);
break;
case RotationMode.Y:
schematic = ProcessSchematicInYAxis(schematic, shaderFill);
break;
case RotationMode.Z:
schematic = ProcessSchematicInZAxis(schematic, shaderFill);
break;
}
}
return(schematic);
}
private float MinDistanceToWall(Schematic schematic, Voxel voxel, int distance)
{
float minDistance = distance + 1;
for (int x = -distance; x <= distance; x++)
{
for (int y = -distance; y <= distance; y++)
{
for (int z = -distance; z <= distance; z++)
{
if (schematic.GetVoxel(voxel.X + x, voxel.Y + y, voxel.Z + z, out Voxel foundVoxel))
{
if (!IsGrowColor(schematic, foundVoxel))
{
float d = MathF.Sqrt(MathF.Pow(x, 2) + MathF.Pow(y, 2) + MathF.Pow(z, 2));
if (minDistance > d)
{
minDistance = d;
}
}
}
}
}
}
return(minDistance);
}
private Schematic ProcessSchematicInXAxis(Schematic schematic, ShaderFill shaderFill)
{
int min = shaderFill.Limit;
uint color = schematic.GetColorAtPaletteIndex(shaderFill.TargetColorIndex);
for (int y = 0; y < schematic.Height; y++)
{
for (int z = 0; z < schematic.Length; z++)
{
if (shaderFill.FillDirection == FillDirection.PLUS)
{
for (int x = min; x < schematic.Width; x++)
{
schematic.AddVoxel(x, y, z, color, shaderFill.Replace);
}
}
else
{
for (int x = min; x >= 0; x--)
{
schematic.AddVoxel(x, y, z, color, shaderFill.Replace);
}
}
}
}
return(schematic);
}
private bool GrowsDown(Schematic schematic, Voxel voxel)
{
if (schematic.GetVoxel(voxel.X, voxel.Y + 1, voxel.Z, out Voxel foundVoxel) && IsGrowColor(schematic, foundVoxel))
{
return(true);
}
if (schematic.GetVoxel(voxel.X + 1, voxel.Y, voxel.Z, out foundVoxel) && IsGrowColor(schematic, foundVoxel))
{
return(true);
}
if (schematic.GetVoxel(voxel.X - 1, voxel.Y, voxel.Z, out foundVoxel) && IsGrowColor(schematic, foundVoxel))
{
return(true);
}
if (schematic.GetVoxel(voxel.X, voxel.Y, voxel.Z - 1, out foundVoxel) && IsGrowColor(schematic, foundVoxel))
{
return(true);
}
if (schematic.GetVoxel(voxel.X, voxel.Y, voxel.Z + 1, out foundVoxel) && IsGrowColor(schematic, foundVoxel))
{
return(true);
}
return(false);
}
private Schematic WriteSchematicFromBinvox()
{
using (LineReader lineReader = new LineReader(File.Open(_path, FileMode.Open), Encoding.UTF8))
{
ReadHeader(lineReader);
ReadVoxels(lineReader);
Schematic schematic = new Schematic();
int xmult = (int)(mDimensions.Z * mDimensions.Y);
int zmult = (int)(mDimensions.Z);
for (int Y = 0; Y < mDimensions.Y; Y++)
{
for (int Z = 0; Z < mDimensions.Z; Z++)
{
for (int X = 0; X < mDimensions.X; X++)
{
int index = X * xmult + Z * zmult + Y;
if (mVoxels[index] == 1)
{
schematic.Blocks.Add(new Voxel((ushort)X, (ushort)Y, (ushort)Z, Color.Wheat.ColorToUInt()));
}
}
}
}
return(schematic);
}
}
//builds from schema
public Transform createActor(Schematic schema)
{
if (schema == null)
return null;
if (schema.parts.Count < 1)
return null;
Transform core = createPart (schema.getPart (0));
if (core == null)
return null;
assembleActor (core, schema, 0);
return core;
}
public void assembleActor(Transform parentPart, Schematic schema, int index)
{
//reads node data to create child parts
Part thisPart = schema.getPart (index);
if (thisPart == null)
return;
else {
for(int i=0; i<thisPart.nodes.Length; i+=1) {
Node thisNode = thisPart.getNode(i);
if(thisNode == null) continue;
if(thisNode.equipped) {
Debug.Log("node:yes");
PartTag attachedTag = thisNode.getPartTag ();
if (attachedTag == null)
continue; //nothing attached
Part attachedPart = schema.getPart (attachedTag.index);
//now that we pulled the data we need..
Transform partObject = createPart(attachedPart);
if(partObject) {
partObject.SetParent(parentPart);
partObject.localPosition.Set (thisNode.localPosition.x,thisNode.localPosition.y,thisNode.localPosition.z);
partObject.localRotation = Quaternion.Euler(thisNode.localRotation.x,thisNode.localRotation.y,thisNode.localRotation.z);
assembleActor(partObject, schema, attachedTag.index);
}
else Debug.Log("Gag! no part!");
}
}
}
}
private void GenerateLayoutCode(Eagle.eagle eagle, Schematic.TestBench TestBench_obj)
{
// write layout file
string layoutFile = Path.Combine(this.mainParameters.OutputDirectory, "layout-input.json");
new Layout.LayoutGenerator(eagle.drawing.Item as Eagle.schematic, TestBench_obj, Logger).Generate(layoutFile);
}
public MainForm()
{
this.schematic = new Schematic();
InitializeComponent();
}
public OutputForm()
{
this.schematic = new Schematic();
InitializeComponent();
}
public void BuildSchematic(string schmaticpath)
{
int maxl = 0;
int maxlw = 0;
foreach (var i in Methods)
{
if (i.Value.Count > maxl)
{
maxl = i.Value.Count;
}
foreach (var iyy in i.Value)
{
var iz = iyy;
if (iz.StartsWith("|"))
{
iz = iz.TrimStart('|');
maxlw += int.Parse(iz + 2); // 2 exstra repeaters to give script time
}
}
}
Schematic s = new Schematic();
s.Height = 1;
s.Width = (short)((Methods.Count * 2) + maxlw + 5) ;
s.Length = (short)(maxl * 2 + 2 + 5);
s.Fill();
int x = 0;
foreach (var ii in Methods)
{
int z = 1;
s.SetBlock(x, 0, 0, new Block() { ID = 93, Metta = 2 });
foreach (var iyy in ii.Value)
{
var i = iyy;
if (i.StartsWith("|"))
{
i = i.TrimStart('|');
for (int iu = 0; iu < int.Parse(i); iu++)
{
s.SetBlock(x, 0, z, new Block() { ID = 93, Metta = 14 }); // full tic repeater
z++;
}
}
else
{
int b = 2;
if (!i.StartsWith("/"))
{
b = 6;
}
if (i.StartsWith("#"))
{
i = i.TrimStart('#');
s.SetBlock(x, 0, z + 1, new Block() { ID = 149, Metta = 2 });
}
else
{
s.SetBlock(x, 0, z + 1, new Block() { ID = 93, Metta = b });
}
s.SetBlock(x, 0, z, new Block() { ID = 137, Metta = 0, Command = i });
z += 2;
}
}
s.SetBlock(x, 0, z, new Block() { ID = 137, Metta = 0, Command = "/setblock ~ ~ ~-" + (z + 1) + " minecraft:air" });
x += 2;
}
s.Save(schmaticpath);
}
