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();
}
}
public BzMeshDataEditor(BzMeshData meshData, Plane planeLocal, IBzSliceAdapter adapter)
{
_meshData = meshData;
_adapter = adapter;
_planeLocal = planeLocal;
_chashedOuterLines = new Dictionary <IndexVector, int>();
}
/// <summary>
/// Transfom vertices from modal space to plane space and convert them to Vector2[]
/// </summary>
private Vector2[] ConvertV3ToV2(IBzSliceAdapter adapter, Vector3 normal)
{
normal = adapter.InverseTransformDirection(normal);
Quaternion rotation;
if (Vector3.Dot(normal, Vector3.back) < 0f)
{
// required to have deterministic texture rotation
rotation = Quaternion.Euler(180f, 0f, 0f) * Quaternion.FromToRotation(-normal, Vector3.back);
}
else
{
rotation = Quaternion.FromToRotation(normal, Vector3.back);
}
var v2s = new Vector2[edgeLoop.size];
var edge = edgeLoop.first;
for (int i = 0; i < edgeLoop.size; i++)
{
Vector3 v3 = adapter.GetLocalPos(meshData, edge.value);
v3 = rotation * v3;
v2s[i] = v3;
edge = edge.next;
}
return(v2s);
}
public BzMeshDataEditor(BzMeshData meshData, Plane plane, IBzSliceAdapter adapter, bool skipIfNotClosed)
{
_meshData = meshData;
_adapter = adapter;
_skipIfNotClosed = skipIfNotClosed;
_plane = plane;
_chashedOuterLines = new Dictionary <IndexVector, int>();
}
/// <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);
}
}
public BzMeshDataDissector(Mesh mesh, Plane plane, Material[] materials, IBzSliceAdapter adapter, SliceConfigurationDto configuration)
{
_adapter = adapter;
_plane = plane;
Configuration = configuration;
_meshDataNeg = new BzMeshData(mesh, materials);
_meshDataPos = new BzMeshData(mesh, materials);
_subMeshes = new int[mesh.subMeshCount][];
for (int subMeshIndex = 0; subMeshIndex < mesh.subMeshCount; ++subMeshIndex)
{
_subMeshes[subMeshIndex] = mesh.GetTriangles(subMeshIndex);
}
}
private static void ReadAdapter(List <IBzSliceAdapter> adapters, XmlReader reader)
{
using (var r = reader.ReadSubtree())
{
string adapterTypeStr = null;
IBzSliceAdapter adapter = null;
while (!r.EOF)
{
if (r.NodeType != XmlNodeType.Element)
{
r.Read();
continue;
}
switch (r.Name)
{
case "adapterType":
adapterTypeStr = r.ReadElementContentAsString();
break;
case "adapterData":
if (adapterTypeStr == null)
{
throw new InvalidOperationException("adapterType should be declared first");
}
Type adapterType = Type.GetType(adapterTypeStr);
using (var rr = reader.ReadSubtree())
{
object o = new XmlSerializer(adapterType, new XmlRootAttribute(r.Name)).Deserialize(rr);
adapter = (IBzSliceAdapter)o;
}
break;
default:
r.Read();
break;
}
}
if (adapter == null)
{
throw new InvalidOperationException("adapterData element not found");
}
adapters.Add(adapter);
}
}
/// <summary>
/// Transfom vertices from modal space to plane space and convert them to Vector2[]
/// </summary>
private Vector2[] ConvertV3ToV2(IBzSliceAdapter adapter, Vector3 normal)
{
var rotation = Quaternion.FromToRotation(normal, Vector3.back);
var v2s = new Vector2[edgeLoop.size];
var edge = edgeLoop.first;
for (int i = 0; i < edgeLoop.size; i++)
{
Vector3 v3 = adapter.GetWorldPos(meshData, edge.value);
v3 = rotation * v3;
v2s[i] = v3;
edge = edge.next;
}
return(v2s);
}
/// <param name="vertices">Chain of vertices for polygon</param>
/// <param name="normal">Normal the polygon is facing to</param>
public BzPolyLoop(BzMeshData meshData, LinkedLoop <int> edgeLoop, Vector3 normal, IBzSliceAdapter adapter)
{
this.meshData = meshData;
this.edgeLoop = edgeLoop;
if (edgeLoop.size < 3)
{
return;
}
Profiler.BeginSample("ConvertV3ToV2");
polyVertices2D = ConvertV3ToV2(adapter, normal);
Profiler.EndSample();
Profiler.BeginSample("MakeMesh");
var newTriangles1 = MakeMesh(true);
var newTriangles2 = MakeMesh(false);
Profiler.EndSample();
// get triangle list with more vertices
OuterLoop = newTriangles1.Count >= newTriangles2.Count;
if (OuterLoop)
{
triangles = newTriangles1;
}
else
{
triangles = newTriangles2;
}
if (triangles.Count != 0)
{
CalculateMetodata();
Created = true;
}
}
