private void SliceTryFinished(SliceTry sliceTry)
{
BzSliceTryResult result = null;
if (sliceTry.sliced)
{
result = ApplyChanges(sliceTry);
}
if (result == null)
{
result = new BzSliceTryResult(false, sliceTry.sliceData.addData);
}
else
{
InvokeEvents(result.outObjectNeg, result.outObjectPos);
}
OnSliceFinished(result);
if (sliceTry.callBack != null)
{
sliceTry.callBack(result);
}
}
private static void SaveSliceData(string filePath, SliceTry sliceTry)
{
IBzSliceAdapter[] adapters = new IBzSliceAdapter[sliceTry.items.Length];
using (XmlWriter writer = XmlWriter.Create(filePath, new XmlWriterSettings {
Encoding = Encoding.UTF8
}))
{
writer.WriteStartDocument();
writer.WriteStartElement("root");
SerializeObject("position", sliceTry.position, writer);
SerializeObject("rotation", sliceTry.position, writer);
SerializeObject("plane", sliceTry.sliceData.plane, writer);
writer.WriteStartElement("adapters");
for (int i = 0; i < sliceTry.items.Length; i++)
{
// save adapter
var adapter = sliceTry.items[i].meshDissector.Adapter;
adapters[i] = adapter;
writer.WriteStartElement(_adapterElementName);
writer.WriteElementString("adapterType", adapter.GetType().AssemblyQualifiedName);
SerializeObject("adapterData", adapter, writer);
writer.WriteEndElement();
}
writer.WriteEndElement(); // end "adapters" element
writer.WriteEndDocument();
}
}
private BzSliceTryResult ApplyChanges(SliceTry sliceTry)
{
// duplicate object
GameObject resultObjA, resultObjB;
GetNewObjects(out resultObjA, out resultObjB);
var renderersNeg = GetRenderers(resultObjA);
var renderersPos = GetRenderers(resultObjB);
if (renderersNeg.Length != renderersPos.Length |
sliceTry.items.Length != renderersPos.Length)
{
// if something wrong happaned with object, and during slicing it was changed
// disallow slicing
return(null);
}
sliceTry.sliceData.componentManager.OnSlicedMainThread(resultObjA, resultObjB, renderersNeg, renderersPos);
BzSliceTryResult result = new BzSliceTryResult(true, sliceTry.sliceData.addData);
result.meshItems = new BzMeshSliceResult[sliceTry.items.Length];
for (int i = 0; i < sliceTry.items.Length; i++)
{
var sliceTryItem = sliceTry.items[i];
if (sliceTryItem == null)
{
continue;
}
var rendererNeg = renderersNeg[i];
var rendererPos = renderersPos[i];
if (sliceTryItem.SliceResult == SliceResult.Sliced)
{
sliceTryItem.meshDissector.RebuildNegMesh(rendererNeg);
sliceTryItem.meshDissector.RebuildPosMesh(rendererPos);
var itemResult = GetItemResult(sliceTryItem, rendererNeg, rendererPos);
result.meshItems[i] = itemResult;
}
if (sliceTryItem.SliceResult == SliceResult.Neg)
{
DeleteRenderer(rendererPos);
}
if (sliceTryItem.SliceResult == SliceResult.Pos)
{
DeleteRenderer(rendererNeg);
}
}
result.outObjectNeg = resultObjA;
result.outObjectPos = resultObjB;
return(result);
}
private void SliceTryFinished(SliceTry sliceTry)
{
BzSliceTryResult result = null;
if (sliceTry.sliced)
{
Profiler.BeginSample("ApplyChanges");
result = ApplyChanges(sliceTry);
Profiler.EndSample();
}
if (result == null)
{
result = new BzSliceTryResult(false, sliceTry.sliceData.addData);
}
else
{
lastSuccessfulSlice = sliceTry;
result.outObjectNeg.GetComponent <BzSliceableBase>().lastSuccessfulSlice = sliceTry;
result.outObjectPos.GetComponent <BzSliceableBase>().lastSuccessfulSlice = sliceTry;
Profiler.BeginSample("InvokeEvents");
InvokeEvents(result.outObjectNeg, result.outObjectPos);
Profiler.EndSample();
}
Profiler.BeginSample("OnSliceFinished");
OnSliceFinished(result);
Profiler.EndSample();
if (result.sliced)
{
var runnerNeg = result.outObjectNeg.GetComponent <LazyActionRunner>();
if (runnerNeg != null)
{
runnerNeg.RunLazyActions();
}
var runnerPos = result.outObjectPos.GetComponent <LazyActionRunner>();
if (runnerPos != null)
{
runnerPos.RunLazyActions();
}
}
if (sliceTry.callBack != null)
{
Profiler.BeginSample("CallBackMethod");
sliceTry.callBack(result);
Profiler.EndSample();
}
}
/// <summary>
/// Start slicing process
/// </summary>
/// <param name="addData">You can pass any object. You will </param>
/// <returns>Returns true if pre-slice conditions was succeeded and task was added to the queue</returns>
private void StartSlice(BzSliceTryData sliceTryData, IBzSliceAdapter[] adapters, Action <BzSliceTryResult> callBack)
{
Renderer[] renderers = GetRenderers(gameObject);
SliceTryItem[] items = new SliceTryItem[renderers.Length];
for (int i = 0; i < renderers.Length; i++)
{
var renderer = renderers[i];
var adapterAndMesh = GetAdapterAndMesh(renderer);
if (adapterAndMesh == null)
{
continue;
}
Mesh mesh = adapterAndMesh.mesh;
IBzSliceAdapter adapter = adapters == null ? adapterAndMesh.adapter : adapters[i];
var configuration = renderer.gameObject.GetComponent <BzSliceConfiguration>();
var confDto = configuration == null?BzSliceConfiguration.GetDefault() : configuration.GetDto();
var meshDissector = new BzMeshDataDissector(mesh, sliceTryData.plane, renderer.sharedMaterials, adapter, confDto);
meshDissector.DefaultSliceMaterial = defaultSliceMaterial;
SliceTryItem sliceTryItem = new SliceTryItem();
sliceTryItem.meshRenderer = renderer;
sliceTryItem.meshDissector = meshDissector;
items[i] = sliceTryItem;
}
SliceTry sliceTry = new SliceTry();
sliceTry.items = items;
sliceTry.callBack = callBack;
sliceTry.sliceData = sliceTryData;
sliceTry.position = transform.position;
sliceTry.rotation = transform.rotation;
if (asynchronously)
{
StartWorker(WorkForWorker, sliceTry);
_sliceTrys.Enqueue(sliceTry);
}
else
{
Work(sliceTry);
SliceTryFinished(sliceTry);
}
}
void Work(SliceTry sliceTry)
{
bool somethingOnNeg = false;
bool somethingOnPos = false;
for (int i = 0; i < sliceTry.items.Length; i++)
{
var sliceTryItem = sliceTry.items[i];
if (sliceTryItem == null)
{
continue;
}
var meshDissector = sliceTryItem.meshDissector;
sliceTryItem.SliceResult = meshDissector.Slice();
if (sliceTryItem.SliceResult == SliceResult.Neg |
sliceTryItem.SliceResult == SliceResult.Duplicate |
sliceTryItem.SliceResult == SliceResult.Sliced)
{
somethingOnNeg = true;
}
if (sliceTryItem.SliceResult == SliceResult.Pos |
sliceTryItem.SliceResult == SliceResult.Duplicate |
sliceTryItem.SliceResult == SliceResult.Sliced)
{
somethingOnPos = true;
}
}
sliceTry.sliced = somethingOnNeg & somethingOnPos;
if (sliceTry.sliced)
{
sliceTry.sliceData.componentManager.OnSlicedWorkerThread(sliceTry.items);
}
OnSliceFinishedWorkerThread(sliceTry.sliced, sliceTry.sliceData.addData);
}
private BzSliceTryResult ApplyChanges(SliceTry sliceTry)
{
// duplicate object
GameObject resultObjNeg, resultObjPos;
GetNewObjects(out resultObjNeg, out resultObjPos);
var renderersNeg = GetRenderers(resultObjNeg);
var renderersPos = GetRenderers(resultObjPos);
resultObjNeg.AddComponent <LazyActionRunner>();
resultObjPos.AddComponent <LazyActionRunner>();
if (renderersNeg.Length != renderersPos.Length |
renderersNeg.Length != sliceTry.items.Length)
{
// if something wrong happaned with object, and during slicing it was changed
// reject this slice try
return(null);
}
Profiler.BeginSample("ComponentManager.OnSlicedMainThread");
sliceTry.sliceData.componentManager.OnSlicedMainThread(resultObjNeg, resultObjPos, renderersNeg, renderersPos);
Profiler.EndSample();
BzSliceTryResult result = new BzSliceTryResult(true, sliceTry.sliceData.addData);
result.meshItems = new BzMeshSliceResult[sliceTry.items.Length];
for (int i = 0; i < sliceTry.items.Length; i++)
{
var sliceTryItem = sliceTry.items[i];
if (sliceTryItem == null)
{
continue;
}
var rendererNeg = renderersNeg[i];
var rendererPos = renderersPos[i];
if (sliceTryItem.SliceResult == SliceResult.Sliced)
{
sliceTryItem.meshDissector.RebuildNegMesh(rendererNeg);
sliceTryItem.meshDissector.RebuildPosMesh(rendererPos);
var itemResult = GetItemResult(sliceTryItem, rendererNeg, rendererPos);
result.meshItems[i] = itemResult;
}
if (sliceTryItem.SliceResult == SliceResult.Neg)
{
DeleteRenderer(rendererPos);
}
if (sliceTryItem.SliceResult == SliceResult.Pos)
{
DeleteRenderer(rendererNeg);
}
}
result.outObjectNeg = resultObjNeg;
result.outObjectPos = resultObjPos;
return(result);
}
