// Use this for initialization
void Start()
{
renal = GameObject.Find("RenalSystemColor");
backups = save_mesh(renal);
//renal.GetComponent<Renderer>().enabled = false;
ppanel = GameObject.Find("PracticePanel");
ppanel.SetActive(false);
fimgpanel = GameObject.Find("FemaleImagePanel");
mimgpanel = GameObject.Find("MaleImagePanel");
}
/// <summary>
/// Initializes a new instance of the <see cref="MeshModelPart"/> class.
/// </summary>
/// <param name="metaData">The meta data.</param>
/// <param name="meshes">The meshes.</param>
/// <param name="edges">The edges.</param>
/// <param name="meshValueLists">A list of data values for this model (deviations, minima, maxima, mean values, etc.).</param>
/// <param name="thumbnail">The thumbnail.</param>
public MeshModelPart(MeshModelMetadata metaData, IEnumerable <Mesh> meshes, IEnumerable <Edge> edges = null, IEnumerable <MeshValueList> meshValueLists = null, byte[] thumbnail = null)
{
ConstructGeometry(meshes, edges);
Metadata = metaData;
UpdateTriangulationHash();
MeshValues = (meshValueLists ?? new MeshValueList[0]).ToArray();
CheckMeshValueIntegrity();
Metadata.MeshValueEntries = MeshValues.Select(m => m.Entry).ToArray();
Thumbnail = thumbnail;
}
/// <summary>
/// Creates the specified <paramref name="subFolder"/> in the specified <paramref name="zipFile"/> and writes the serialized data into it.
/// If the <paramref name="subFolder"/> is null or empty, the data will be serialized into the root directory of the zip archive .
/// </summary>
public void Serialize(ZipArchive zipFile, string subFolder = "")
{
Metadata.MeshValueEntries = MeshValues.Select(v => v.Entry).ToArray();
using (var entryStream = zipFile.CreateNormalizedEntry(Path.Combine(subFolder, "Metadata.xml"), CompressionLevel.Optimal).Open())
{
Metadata.WriteTo(entryStream, true);
}
// Vorschaubild
if (HasThumbnail)
{
using (var entryStream = zipFile.CreateNormalizedEntry(Path.Combine(subFolder, "PreviewImage.png"), CompressionLevel.NoCompression).Open())
{
entryStream.Write(_Thumbnail, 0, _Thumbnail.Length);
}
}
// Triangulierungsdaten schreiben
using (var entryStream = zipFile.CreateNormalizedEntry(Path.Combine(subFolder, "Meshes.dat"), CompressionLevel.Fastest).Open())
using (var binaryWriter = new BinaryWriter(entryStream, Encoding.UTF8, true))
{
binaryWriter.Write(Meshes.Length);
foreach (var mesh in Meshes)
{
mesh.Write(binaryWriter);
}
}
// Edgedaten schreiben
using (var entryStream = zipFile.CreateNormalizedEntry(Path.Combine(subFolder, "Edges.dat"), CompressionLevel.Fastest).Open())
using (var binaryWriter = new BinaryWriter(entryStream, Encoding.UTF8, true))
{
binaryWriter.Write(Edges.Length);
foreach (var edge in Edges)
{
edge.Write(binaryWriter);
}
}
// Datenwerte schreiben
foreach (var entry in MeshValues)
{
using (var entryStream = zipFile.CreateNormalizedEntry(Path.Combine(subFolder, entry.Entry.Filename), CompressionLevel.Fastest).Open())
using (var binaryWriter = new BinaryWriter(entryStream, Encoding.UTF8, true))
{
entry.Write(binaryWriter);
}
}
}
/// <summary>
/// Returns the dataset with the specified <paramref name="dataSetIndex" /> from the <see cref="MeshValueList" /> with the specified <paramref name="dataType" />.
/// If no <paramref name="dataSetIndex" /> is specified, the method will return the first dataset or <code>null</code>, in case the list is empty.
/// </summary>
/// <param name="dataType">Type of the data.</param>
/// <param name="dataSetIndex">Index of the data set.</param>
/// <returns></returns>
public MeshValueList GetMeshValueList(string dataType, int dataSetIndex = -1)
{
var meshValueList = MeshValues.Where(list => list.Entry.DataType == dataType).ToArray();
if (meshValueList.Length == 0)
{
return(null);
}
if (dataSetIndex < 0)
{
return(meshValueList[0]);
}
if (meshValueList.Length > 0 && dataSetIndex >= 0 && dataSetIndex < meshValueList.Length)
{
return(meshValueList[dataSetIndex]);
}
return(null);
}
private static void restore_mesh(GameObject obj, MeshValues mv)
{
var smr = obj.GetComponent <SkinnedMeshRenderer>();
var fsm = obj.GetComponent <FlexShapeMatching>();
var fp = obj.GetComponent <FlexParticles>();
fsm.m_shapeRestPositions = mv.shapeRestPositions;
fsm.m_shapeCenters = mv.shapeCenters;
fsm.m_shapeTranslations = mv.shapeTranslations;
fsm.m_shapeRotations = mv.shapeRotations;
fsm.m_shapeIndices = mv.shapeIndices;
fsm.m_shapeOffsets = mv.shapeOffsets;
fsm.m_shapeIndicesCount = mv.shapeIndices.Length;
//smr.sharedMesh = Instantiate(mv.mesh);
var mesh = Instantiate(smr.sharedMesh) as Mesh;
smr.sharedMesh.MarkDynamic();
smr.sharedMesh.Clear();
smr.sharedMesh.vertices = mv.mesh_vertices;
smr.sharedMesh.subMeshCount = mv.mesh_indices.Length;
for (int i = 0; i < mv.mesh_indices.Length; i++)
{
smr.sharedMesh.SetIndices(mv.mesh_indices[i], MeshTopology.Triangles, i);
}
//smr.sharedMesh.SetTriangles(mv.mesh_triangles.ToList(), 0);
smr.sharedMesh.boneWeights = mv.mesh_weights;
smr.sharedMesh.SetNormals(mv.mesh_normals.ToList());
smr.sharedMesh.SetUVs(0, mv.mesh_uv.ToList());
smr.sharedMesh.bindposes = mv.bind_poses;
//smr.sharedMesh = mesh;
//smr.sharedMesh.UploadMeshData(true);
smr.sharedMesh.UploadMeshData(false);
fp.m_particles = mv.flex_particles;
for (int i = 0; i < mv.shape_transforms.Length; ++i)
{
mv.shape_transforms[i].obj.transform.position = mv.shape_transforms[i].pos;
mv.shape_transforms[i].obj.transform.rotation = mv.shape_transforms[i].rot;
}
}
/// <summary>
/// Returns all <see cref="MeshValueList" /> with the specified <paramref name="dataType" />.
/// </summary>
/// <param name="dataType">Type of the data.</param>
/// <returns></returns>
public MeshValueList[] GetMeshValueLists(string dataType)
{
return(MeshValues.Where(list => string.Equals(list.Entry.DataType, dataType, StringComparison.OrdinalIgnoreCase)).ToArray());
}
/// <summary>
/// Determines whether the <see cref="MeshValues"/> of this instance contain an entry with the specified <paramref name="dataType"/>.
/// </summary>
/// <param name="dataType">Type of the data.</param>
public bool ContainsMeshValueList(string dataType)
{
return(string.IsNullOrEmpty(dataType) || (MeshValues != null && MeshValues.Any(m => string.Equals(m.Entry.DataType, dataType, StringComparison.OrdinalIgnoreCase))));
}
