// Use this for initialization
void Start()
{
float voxelSize = 1.0f;
int size = 33;
Array3 <Voxel> voxels = WorldGenerator.CreateVoxels(size, 0, voxelSize, Vector3.zero);
MeshData data = MarchingCubes.CalculateMeshData(voxels, voxelSize);
data.CalculateNormals();
Mesh mesh = null;
if (data != null)
{
mesh = data.CreateMesh();
}
ChunkObject obj = SplitManager.GetObject();
obj.ov.shouldDraw = true;
obj.mr.material = mat;
obj.mf.mesh = mesh;
Vector3 center = Vector3.one * (size - 1) / 2.0f;
Bounds area = new Bounds(center, Vector3.one * voxelSize * (size - 1));
obj.ov.init(0, 0, center, area, null, Color.red);
}
private void Manager_SpliterCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (e.Error != null)
{
TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.Error, Handle);
MessageBox.Show(e.Error.Message, "Ошибка разделения файла", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else if (e.Cancelled)
{
lblStatus.Text = $"Отменено. Обработано {manager.ItemsSaved} из { manager.ItemsNumber}";
}
else
{
string message = $"Завершено успешно. Создано {manager.ItemsSaved} файлов.";
MessageBox.Show(message, "Завершено", MessageBoxButtons.OK, MessageBoxIcon.Information);
SplitFileParameters p = e.Result as SplitFileParameters;
System.Diagnostics.Process.Start(System.IO.Path.GetDirectoryName(p.FilePath));
lblStatus.Text = "Обработка файла завершена";
this.PrevFinishedParameters = p;
}
SetControlsEnabled(true);
btnStart.Enabled = true;
btnStart.Text = "Начать";
pbProgress.Style = ProgressBarStyle.Continuous;
TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.NoProgress, Handle);
this.manager = null;
if (this.WaitForFinishingToExit)
{
Application.Exit();
}
}
void Start()
{
miner = GameObject.Find("Player").GetComponent <VoxelMining>();
Array3 <Voxel> voxels = WorldGenerator.CreateVoxels(33, 0, 1.0f, Vector3.zero);
//Array3<Voxel> voxels = WorldGenerator.CreateVoxels(64, 0, 1.0f, Vector3.zero);
MeshData data = MarchingCubes.CalculateMeshData(voxels, 1.0f);
Mesh mesh = data.CreateMesh();
go = SplitManager.GetObject();
go.mr.enabled = false;
go.mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
go.mf.sharedMesh = mesh;
go.mr.material = testMat;
MeshData data2 = MarchingTetrahedra.CalculateMeshData(voxels, 1.0f);
data2.CalculateSharedNormals();
Mesh mesh2 = data2.CreateMesh();
go2 = SplitManager.GetObject();
go2.mf.sharedMesh = mesh2;
go2.mr.material = testMat;
go2.mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided;
miner.forceDrawChunk = go2;
}
public void SplitsReturnWithNoRolloutConditionSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
conditionType = ConditionType.WHITELIST,
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
var manager = new SplitManager(splitCache);
//Act
var result = manager.Splits();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Count);
var firstResult = result.Find(x => x.name == "test1");
Assert.AreEqual(firstResult.name, "test1");
Assert.AreEqual(firstResult.changeNumber, 10000);
Assert.AreEqual(firstResult.killed, false);
Assert.AreEqual(firstResult.trafficType, "user");
Assert.AreEqual(firstResult.treatments.Count, 0);
}
public void SplitReturnDefaultTreatmentsWhenNoRolloutCondition()
{
//Arrange
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
conditionType = ConditionType.WHITELIST,
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
},
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.name, "test1");
Assert.AreEqual(conditionWithLogic.partitions.Count, result.treatments.Count);
}
public void SplitNamessWhenCacheIsNotInstancedShouldReturnNull()
{
//Arrange
var manager = new SplitManager(null);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNull(result);
}
public void SplitReturnsNullWhenCacheIsNull()
{
//Arrange
var manager = new SplitManager(null);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNull(result);
}
// called on children getting merged by their parent
void OnGettingMerged()
{
Object.Destroy(obj.mf.mesh);
SplitManager.ReturnObject(obj);
if (col != null)
{
SplitManager.ReturnCollider(col);
col = null;
}
dead = true;
}
public void SplitNamessWhenCacheIsEmptyShouldReturnEmptyList()
{
//Arrange
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var manager = new SplitManager(splitCache);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Count);
}
public void SplitReturnsNullWhenInexistent()
{
//Arrange
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var manager = new SplitManager(splitCache);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNull(result);
}
private void SplitFile(Office.SplitFileParameters splParams)
{
SetControlsEnabled(false);
manager = new Office.SplitManager(mnuUseMultiThreads.Checked);
manager.ProgressChanged += Manager_ProgressChanged;
manager.SpliterCompleted += Manager_SpliterCompleted;
groupBox4.Enabled = true;
this.PrevFinishedParameters = null;
TaskbarManager.Instance.SetProgressState(TaskbarProgressBarState.Normal, Handle);
TaskbarManager.Instance.SetProgressValue(0, 100, Handle);
manager.StartSplit(splParams);
}
public SplitPackageCaseBase(PackageText packageText)
{
RepositoryPackage = packageText.RepositoryPackage;
ExceptedPart = new Dictionary <eSplitterObjectType, string>();
_OraParser = OraParser.Instance();
_package = _OraParser.ParsePackage(RepositoryPackage, false).Result;
_splitter = new Splitter(_package);
_SplitManager = SplitManager.Instance();
_SplitManager.SetOracleParsedPackage(_package);
_SplitManager.SetSplitterPackage(_splitter);
}
public void SplitNamessWhenCacheIsNotInstancedShouldReturnNull()
{
//Arrange
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(null, _blockUntilReadyService.Object);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNull(result);
}
public void SplitReturnsNullWhenCacheIsNull()
{
//Arrange
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(null, _blockUntilReadyService.Object);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNull(result);
}
public void Update()
{
if (hasChildren)
{
if (ShouldMerge())
{
Merge();
}
else
{
for (int i = 0; i < 8; i++)
{
children[i].Update();
}
}
}
else if (!splitting && ShouldSplit())
{
//SplitManager.AddToSplitList(this);
SplitCompute();
}
else if (splitting && childMeshCount >= 8)
{
SplitResolveCompute();
}
else
{
// if at max depth, have valid mesh, and close to cam then should have a collider
if (depth == MAX_DEPTH && !emptyMesh && obj.mf.sharedMesh && GetSqrDistToCamFromCenter() < colliderGenDistance * colliderGenDistance)
{
if (col == null) // if collider is null then spawn one
{
col = SplitManager.GetCollider();
col.go.transform.SetParent(obj.go.transform, false);
col.go.transform.localPosition = Vector3.zero;
col.go.transform.localRotation = Quaternion.identity;
col.mc.sharedMesh = obj.mf.sharedMesh;
}
}
else if (col != null) // otherwise if have collider then return it
{
SplitManager.ReturnCollider(col);
col = null;
}
}
SetGeomorph();
}
public void SetupChunk()
{
obj = SplitManager.GetObject();
//obj.go.name = GetTreeName();
obj.go.transform.parent = body.transform;
obj.go.transform.localPosition = worldPos;
obj.go.transform.localRotation = Quaternion.identity;
//obj.go.transform.position = pos;
obj.mr.material = body.terrainMat; // incase terrain is edited after
//obj.mpb.SetVector(ShaderProps.LocalOffset, worldPos); // not sure what this was for
//obj.UpdatePropBlock();
obj.ov.init(depth, branch, worldPos, localArea, body, depth == 0 ? Color.blue : Color.red);
}
void Start()
{
voxels = WorldGenerator.CreateVoxels(65, 0, 1, Vector3.zero);
data = MarchingCubes.CalculateMeshData(voxels, 1);
data.CalculateVertexSharing();
data.CalculateNormals();
simp = new Simplification(data.vertices, data.triangles);
mesh = data.CreateMesh();
go = SplitManager.GetObject();
go.mr.material = mat;
go.mf.sharedMesh = mesh;
}
public void SplitWithNullNameShouldReturnNull()
{
//Arrange
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
//Act
var result = manager.Split(null);
//Assert
Assert.IsNull(result);
}
public void SplitNamessWhenCacheIsEmptyShouldReturnEmptyList()
{
//Arrange
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(0, result.Count);
}
public void SplitReturnsNullWhenInexistent()
{
//Arrange
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNull(result);
}
public void Start()
{
this.ownerSelectable = this.GetComponent <Selectable>();
this.SetDivisibleReady();
this.playerNetworkView = this.GetComponent <NetworkView>();
this.ownerAttackable = this.GetComponent <Attackable>();
this.canDivide = true;
if (this.spawnUnitPrefab == null)
{
Debug.LogError(new System.NullReferenceException("Spawn Unit Prefab in Divisible is currently null. Please check the owning unit's Divisble component."));
}
this.splitManager = GameObject.Find("Split Manager").GetComponent <SplitManager>();
if (this.splitManager == null)
{
Debug.LogError("Split Manager is wrong here.");
}
}
private void BuildManager()
{
_manager = new SplitManager(_splitCache, _blockUntilReadyService);
}
private void Awake()
{
instance = this;
}
void Start()
{
splitManager = SplitManager.instance;
}
public SplitterView()
{
DataContext = new SplitterViewModel(SplitManager.Instance());
InitializeComponent();
}
public void Split_WithConfigs_ReturnSuccessfully()
{
//Arrange
var configurations = new Dictionary <string, string>
{
{ "On", "\"Name = \"Test Config\"" }
};
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic, configurations = configurations
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic, configurations = configurations
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
manager.BlockUntilReady(1000);
//Act
var result1 = manager.Split("test1");
var result2 = manager.Split("test2");
var result3 = manager.Split("test3");
//Assert
Assert.IsNotNull(result1);
Assert.IsNotNull(result1.configs);
Assert.IsNotNull(result2);
Assert.IsNotNull(result2.configs);
Assert.IsNotNull(result3);
Assert.IsNull(result3.configs);
}
public void SplitNamesReturnSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
manager.BlockUntilReady(1000);
//Act
var result = manager.SplitNames();
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(6, result.Count);
var firstResult = result.Find(x => x == "test1");
Assert.AreEqual(firstResult, "test1");
}
private void window_Loaded(object sender, RoutedEventArgs e)
{
DataContext = new ParserViewModel(_repositoryPackage, (x) => Close(), SplitManager.Instance(), OraParser.Instance());
}
public void SplitReturnSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
conditionType = ConditionType.ROLLOUT,
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 90, treatment = "on"
},
new PartitionDefinition()
{
size = 10, treatment = "off"
}
}
};
conditionsWithLogic.Add(conditionWithLogic);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
_blockUntilReadyService
.Setup(mock => mock.IsSdkReady())
.Returns(true);
var manager = new SplitManager(splitCache, _blockUntilReadyService.Object);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.name, "test1");
Assert.AreEqual(result.changeNumber, 10000);
Assert.AreEqual(result.killed, false);
Assert.AreEqual(result.trafficType, "user");
Assert.AreEqual(result.treatments.Count, 2);
var firstTreatment = result.treatments[0];
Assert.AreEqual(firstTreatment, "on");
var secondTreatment = result.treatments[1];
Assert.AreEqual(secondTreatment, "off");
}
public void SplitReturnRolloutConditionTreatmentsSuccessfully()
{
//Arrange
var conditionsWithLogic = new List <ConditionWithLogic>();
var conditionWithLogic = new ConditionWithLogic()
{
conditionType = ConditionType.WHITELIST,
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 100, treatment = "on"
},
}
};
conditionsWithLogic.Add(conditionWithLogic);
var conditionWithLogic2 = new ConditionWithLogic()
{
conditionType = ConditionType.ROLLOUT,
partitions = new List <PartitionDefinition>()
{
new PartitionDefinition()
{
size = 90, treatment = "on"
},
new PartitionDefinition()
{
size = 10, treatment = "off"
},
}
};
conditionsWithLogic.Add(conditionWithLogic2);
var splitCache = new InMemorySplitCache(new ConcurrentDictionary <string, ParsedSplit>());
splitCache.AddSplit("test1", new ParsedSplit()
{
name = "test1", changeNumber = 10000, killed = false, trafficTypeName = "user", seed = -1, conditions = conditionsWithLogic
});
splitCache.AddSplit("test2", new ParsedSplit()
{
name = "test2", conditions = conditionsWithLogic
});
splitCache.AddSplit("test3", new ParsedSplit()
{
name = "test3", conditions = conditionsWithLogic
});
splitCache.AddSplit("test4", new ParsedSplit()
{
name = "test4", conditions = conditionsWithLogic
});
splitCache.AddSplit("test5", new ParsedSplit()
{
name = "test5", conditions = conditionsWithLogic
});
splitCache.AddSplit("test6", new ParsedSplit()
{
name = "test6", conditions = conditionsWithLogic
});
var manager = new SplitManager(splitCache);
//Act
var result = manager.Split("test1");
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(result.name, "test1");
Assert.AreEqual(result.treatments.Count, 2);
var firstTreatment = result.treatments[0];
Assert.AreEqual(firstTreatment, "on");
var secondTreatment = result.treatments[1];
Assert.AreEqual(secondTreatment, "off");
}
