public static void CacheItem(string url, Mesh mesh)
{
string path = Path.Combine(Application.persistentDataPath, url);
byte[] bytes = MeshSerializer.WriteMesh(mesh, true);
File.WriteAllBytes(path, bytes);
}
public void SaveChunk(Mesh mesh)
{
string path = Path.Combine(Application.persistentDataPath, "chunkData/" + mesh.name);
byte[] bytes = MeshSerializer.WriteMesh(mesh, true);
File.WriteAllBytes(path, bytes);
}
// Use this for initialization
public byte[] SaveMesh()
{
Mesh inputMesh = GetComponent <MeshFilter>().mesh;
string fullFileName = Application.dataPath + "/" + fileName;
feedSave = MeshSerializer.WriteMesh(inputMesh, saveTangents);
print("Saved " + name + " mesh to " + fullFileName);
return(feedSave);
}
public void sendSpatialMesh(Mesh mesh)
{
//PointsMessage message = new PointsMessage();
//message.vertices = vertices;
//message.uvs = uvs;
//message.triangles = triangles;
//myClient.Send(SpatialMeshMsg.meshMsg, message);
var data = MeshSerializer.WriteMesh(mesh, true);
photonView.RPC("TransferMesh", PhotonTargets.All, SpatialMeshMsg.meshMsg, data);
}
//public void sendMessage(Vector3[] vertices, Vector2[] uvs, int[] triangles)
public void sendMessage(Mesh mesh)
{
//PointsMessage message = new PointsMessage();
//message.vertices = vertices;
//message.uvs = uvs;
//message.triangles = triangles;
//NetworkServer.SendToAll(CustomMessage.hiMessage, message);
var data = MeshSerializer.WriteMesh(mesh, true);
photonView.RPC("TransferMesh", PhotonTargets.All, CustomMessage.hiMessage, data);
}
public void SetCurrentState() // 현재상태 불러오기
{
sd.mFurniture = gameObject.name;
sd.mPosition = gameObject.transform.position;
sd.mRotation = gameObject.transform.rotation;
sd.mScale = gameObject.transform.lossyScale;
if (gameObject.GetComponent <changeColor>() != null)
{
sd.mColor = gameObject.GetComponent <changeColor>().GetColor();
}
if (gameObject.GetComponent <MeshFilter>() != null)
{
sd.mesh = MeshSerializer.WriteMesh(gameObject.GetComponent <MeshFilter>().mesh, true);
}
}
{ //With help of: https://dzone.com/articles/convert-object-byte-array-and, FullSerializer, SerializeHelper
protected override fsResult DoSerialize(GameObject model, Dictionary <string, fsData> serialized)
{
var result = fsResult.Success;
if (model.hideFlags != HideFlags.None)
{
model.hideFlags = HideFlags.None;
}
if (!model.GetComponent <MeshRenderer>().enabled)
{
model.GetComponent <MeshRenderer>().enabled = true;
}
GameObject go = Object.Instantiate(model);
go.name = model.name;
//We should check for Editing Mode (because it's only required if we are serializing the desried GameObject in Editor),
//but, why? It's more safe and more slow :) (This remember me to PHP haha)
GameObject foundGo = null;
Mesh mesh = PluginsHelper.FindMesh(go, ref foundGo);
if (mesh != null)
{
MeshSerializer.WriteMesh(mesh, true).SaveAsAsset(mesh, foundGo.name);
}
byte[] bytes = go.SaveObjectTree();
string path = bytes.SaveAsAsset(go, go.name);
if (Application.isPlaying)
{
Object.Destroy(go);
}
else
{
Object.DestroyImmediate(go);
}
result += SerializeMember(serialized, null, "path", path);
return(result);
}
public static void Bundle(string[] inputFiles, string outputFile)
{
AssetDatabase.Refresh();
Debug.Log(string.Format("Bundling output: {0}", outputFile));
Debug.Log(string.Join(", ", inputFiles));
//UnityEngine.Object[] allAssets = inputFiles.SelectMany(f=>AssetDatabase.LoadAllAssetsAtPath(f,typeof(UnityEngine.Object)).ToList()).Where (f=>f is Mesh).ToArray();
UnityEngine.Mesh[] meshes = inputFiles.Select(f => AssetDatabase.LoadAssetAtPath(Path.Combine("Assets", f), typeof(Mesh)) as Mesh).Where(m => m != null).ToArray();
if (meshes.Length == 0)
{
throw new UnityException("No meshes found to process!");
}
/*
* List<Mesh> meshes = new List<Mesh>();
*
* foreach( string file in inputFiles ){
* var objects = AssetDatabase.LoadAssetAtPath("Assets/"+file,typeof(MeshFilter));
* Debug.Log ( string.Join(", ",objects.Select(o=>o.name).ToArray() ) );
* }
*/
foreach (Mesh mesh in meshes)
{
Debug.Log(string.Format("Serializing mesh {0}", outputFile));
byte[] meshData = MeshSerializer.WriteMesh(mesh, true);
File.WriteAllBytes(outputFile, meshData);
break;
}
/*
* BuildPipeline.BuildAssetBundle(allAssets[0],
* allAssets,
* outputFile,
* BuildAssetBundleOptions.CollectDependencies |
* BuildAssetBundleOptions.CompleteAssets |
* BuildAssetBundleOptions.DeterministicAssetBundle,
* BuildTarget.Android);
*/
}
public static void SaveMesh(string filename, Mesh mesh)
{
filename = filename.Replace(":", "-");
try
{
Byte[] bytes = MeshSerializer.WriteMesh(mesh, true);
string path = Application.persistentDataPath + "/" + filename + ".mesh";
System.IO.File.WriteAllBytes(path, bytes);
if (verbose)
{
Debug.Log("Mesh saved @ " + path);
}
}
catch (System.Exception e)
{
if (verbose)
{
Debug.Log("Save Mesh Exception: " + e.Message);
}
}
}
public void sendSpatialMesh(Mesh mesh)
{
var data = MeshSerializer.WriteMesh(mesh, true);
photonView.RPC("TransferMesh", PhotonTargets.All, SpatialMeshMsg.meshMsg, data);
}
public static void SaveAssetToDisk(MeshFilter meshFilter, string filePath, string Extension)
{
var bin = MeshSerializer.WriteMesh(meshFilter.sharedMesh, true);
File.WriteAllBytes(filePath, bin);
}
//Vector3 CompareVectorPos(Vector3 a, Vector3 b, bool bMin)
//{
// if (bMin)
// {
// if (a.x > b.x)
// {
// a.x = b.x;
// }
// if (a.y > b.y)
// {
// a.y = b.y;
// }
// if (a.z > b.z)
// {
// a.z = b.z;
// }
// }
// else
// {
// if (a.x < b.x)
// {
// a.x = b.x;
// }
// if (a.y < b.y)
// {
// a.y = b.y;
// }
// if (a.z < b.z)
// {
// a.z = b.z;
// }
// }
// return a;
//}
void CopyMesh()
{
if (tMapper != null)
{
int lstIndex = 0;
short index = 0;
Dictionary <short, byte[]> tempDic = new Dictionary <short, byte[]>();
//GameObject cubeObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
//Mesh cubeMesh = cubeObj.GetComponent<MeshFilter>().sharedMesh;
//Destroy(cubeObj);
foreach (GameObject obj in tMapper.meshIdToGameObjectMap.Values)
{
Mesh tMesh = obj.GetComponent <MeshFilter>().sharedMesh;
Destroy(obj);
if (tMesh.vertices.Length == 0)
{
continue;
}
//Vector3 min = new Vector3(999f, 999f, 999f);
//Vector3 max = new Vector3(-999f, -999f, -999f);
//for (int i = 0; i < tMesh.vertices.Length; i++)
//{
// min = CompareVectorPos(min, tMesh.vertices[i], true);
// max = CompareVectorPos(max, tMesh.vertices[i], false);
//}
//Debug.Log(index+". Lenth " +tMesh.vertices.Length);
//Vector3 center = tMesh.bounds.center;
//Vector3 size = tMesh.bounds.size;
//Vector3 min = tMesh.bounds.min;
//Vector3 max = tMesh.bounds.max;
//Vector3 edge1 = new Vector3(min.x,max.y,min.z);
//Vector3 edge2 = new Vector3(max.x, min.y, max.z);
////obj.transform.position = center;
////obj.transform.localScale = size;
////tMesh = cubeMesh;
//tMesh.Clear();
//tMesh.SetVertices(new Vector3[] {min,edge1,edge2,max});
//tMesh.SetUVs(0, new Vector2[] { Vector2.zero, Vector2.zero, Vector2.zero, Vector2.zero });
//tMesh.SetTriangles(new int[] { 0, 1, 2, 3, 1, 2}, 0);
//tMesh.RecalculateNormals();
////tMesh.Simplify(); //MeshSimplification.Simplify(tMesh);
//Debug.LogError(index + ". Lenth " + tMesh.vertices.Length);
if (tMesh.triangles.Length / 3 > 250)
{
Debug.LogError(index + ". Tris " + tMesh.triangles.Length / 3);
}
tempDic.Add(index, MeshSerializer.WriteMesh(tMesh, false));
index++;
if (index > 100)
{
meshDic.Add(tempDic);
tempDic = new Dictionary <short, byte[]>();
lstIndex++;
index = 0;
}
}
meshDic.Add(tempDic);
Debug.LogError("Create");
iStep = 1;
tMapper.transform.parent.gameObject.SetActive(false);
if (SenderObj == null)
{
SenderObj = PhotonNetwork.Instantiate(this.tParent.name, Vector3.zero, Quaternion.identity, 0);
}
}
}
public MemoryPart(Part part, VesselControl vesselControl)
{
kspPart = part;
byteCount = 0;
name = part.name;
uniqueID = part.gameObject.GetInstanceID();
try
{
parentID = part.parent.gameObject.GetInstanceID();
}
catch { Debug.Log(part.name + " does not have a parent"); }
var modelMeshes = part.FindModelComponents <MeshFilter>();
//var modelSkinnedMeshes = part.FindModelComponents<SkinnedMeshRenderer>();
// var combinedArray = new Mesh[modelMeshes.Count + modelSkinnedMeshes.Count];
// modelMeshes.CopyTo(combinedArray);
offset = vesselControl.adjustedVessel.InverseTransformPoint(part.transform.position);//vesselControl.adjustedVessel.InverseTransformPoint(filter.transform.position);
var tempParent = part.transform.parent;
part.transform.SetParent(vesselControl.adjustedVessel);//vesselControl.vesselCOM);
// var rotOffset = Quaternion.Inverse(part.vessel.vesselTransform.rotation) * filter.transform.rotation;
rotOffset = part.transform.localEulerAngles;
part.transform.SetParent(tempParent);
meshList = new List <ModelFilter>();
//for uniqueID
byteCount += 4;
//for parent uniqueID
byteCount += 4;
//for meshfilter count
byteCount += 4;
//for localPosition vector3
byteCount += 12;
//for localRot vector3
byteCount += 12;
//for part name string count
byteCount += 4;
//for part name
nameBytePackage = Encoding.ASCII.GetBytes(name);
byteCount += nameBytePackage.Length;
foreach (var filter in modelMeshes)
{
Debug.Log(filter.transform.name + " filter found on part " + part.name);
bool serialize = false;
if (!filter.name.ToLower().Contains("col"))
{
var gearModule = part.GetComponent <ModuleWheelBase>();
if (!gearModule)
{
serialize = true;
}
}
else
{
var engineModule = part.GetComponent <ModuleEngines>();
if (engineModule)
{
serialize = true;
}
}
if (serialize)
{
ModelFilter modelFilter = new ModelFilter();
byteCount += 12;
byteCount += 12;
byteCount += 12;
modelFilter.vesselPartOffset = part.transform.InverseTransformPoint(filter.transform.position); //vesselControl.adjustedVessel.InverseTransformPoint(filter.transform.position);
tempParent = filter.transform.parent;
filter.transform.SetParent(part.transform); //vesselControl.vesselCOM);
// var rotOffset = Quaternion.Inverse(part.vessel.vesselTransform.rotation) * filter.transform.rotation;
modelFilter.vesselPartLocalEuler = filter.transform.localEulerAngles;
filter.transform.SetParent(tempParent);
modelFilter.lossyScale = filter.transform.lossyScale;
//for mesh length
byteCount += 4;
var mesh = filter.mesh;
modelFilter.byteArrMesh = MeshSerializer.WriteMesh(mesh, true);
meshList.Add(modelFilter);
byteCount += modelFilter.byteArrMesh.Length;
}
}
//Texture2D texture = part.FindModelComponent<MeshRenderer>().material.GetTexture("_MainTex") as Texture2D;
////var tex = new Texture2D(texture.height, texture.width, TextureFormat.RGB24, false);
////Graphics.ConvertTexture(texture, tex);
//Color32[] pix = texture.GetPixels32();
//System.Array.Reverse(pix);
//Texture2D destTex = new Texture2D(texture.width, texture.height);
//destTex.SetPixels32(pix);
//destTex.Apply();
//byteArrTexture = destTex.GetRawTextureData();
// byteCount = byteArrMesh.Length;// + byteArrTexture.Length;
// Debug.Log(part.name + " mesh byte length " + byteArrMesh.Length);
//byteArrayList.Add(MeshSerializer.WriteMesh(mesh, true));
}
