private void CopyMeshFromSerializedMesh(Mesh targetMesh, SerializableMesh sMesh)
{
int[] triangles = targetMesh.triangles;
tangentTemp = targetMesh.tangents;
uv2Temp = targetMesh.uv2;
uv3Temp = targetMesh.uv3;
int l = tangentTemp.Length;
for (int i = 0; i < l; i++)
{
tangentTemp[i].Set(
sMesh._tangents[i].x,
sMesh._tangents[i].y,
sMesh._tangents[i].z,
sMesh._tangents[i].w);
uv2Temp[i].Set(
sMesh._uv2[i].x,
sMesh._uv2[i].y
);
uv3Temp[i].Set(
sMesh._uv3[i].x,
sMesh._uv3[i].y
);
}
targetMesh.tangents = tangentTemp;
targetMesh.uv2 = uv2Temp;
targetMesh.uv3 = uv3Temp;
}
private static AnimationMesh CreateMesh(SerializableMesh meshContent)
{
AnimationMesh mesh = new AnimationMesh(meshContent.name);
AnimationVertex[] vertices = new AnimationVertex[meshContent.vertices.Length];
for (int i = 0; i < vertices.Length; i++)
{
SerializableVertex vertexContent = meshContent.vertices[i];
vertices[i] = new AnimationVertex
{
position = vertexContent.position,
normal = vertexContent.normal,
texture = vertexContent.texture,
blendweights = vertexContent.blendweights,
blendindices = vertexContent.blendindices
};
}
mesh.SetIndices(meshContent.indices);
mesh.SetVertices(vertices);
mesh.SetTextureName(meshContent.textureName);
return(mesh);
}
private void ProcessGeometry(GeometryContent xnaGeometry)
{
// find and process the geometry's bone weights
for (int i = 0; i < xnaGeometry.Vertices.Channels.Count; i++)
{
string channelName = xnaGeometry.Vertices.Channels[i].Name;
string baseName = VertexChannelNames.DecodeBaseName(channelName);
if (baseName == "Weights")
{
ProcessWeightsChannel(xnaGeometry, i, outputModel.skeleton);
}
}
// retrieve the four vertex channels we require for CPU skinning. we ignore any
// other channels the model might have.
string normalName = VertexChannelNames.EncodeName(Microsoft.Xna.Framework.Graphics.VertexElementUsage.Normal, 0);
string texCoordName = VertexChannelNames.EncodeName(Microsoft.Xna.Framework.Graphics.VertexElementUsage.TextureCoordinate, 0);
string blendWeightName = VertexChannelNames.EncodeName(Microsoft.Xna.Framework.Graphics.VertexElementUsage.BlendWeight, 0);
string blendIndexName = VertexChannelNames.EncodeName(Microsoft.Xna.Framework.Graphics.VertexElementUsage.BlendIndices, 0);
VertexChannel <Vector3> normals = xnaGeometry.Vertices.Channels[normalName] as VertexChannel <Vector3>;
VertexChannel <Vector2> texCoords = xnaGeometry.Vertices.Channels[texCoordName] as VertexChannel <Vector2>;
VertexChannel <Vector4> blendWeights = xnaGeometry.Vertices.Channels[blendWeightName] as VertexChannel <Vector4>;
VertexChannel <Vector4> blendIndices = xnaGeometry.Vertices.Channels[blendIndexName] as VertexChannel <Vector4>;
// create our array of vertices
int triangleCount = xnaGeometry.Indices.Count / 3;
SerializableVertex[] vertices = new SerializableVertex[xnaGeometry.Vertices.VertexCount];
for (int i = 0; i < vertices.Length; i++)
{
vertices[i] = new SerializableVertex
{
position = xnaGeometry.Vertices.Positions[i],
normal = normals[i],
texture = texCoords[i],
blendweights = blendWeights[i],
blendindices = blendIndices[i]
};
}
int[] indices = new int[xnaGeometry.Indices.Count];
for (int i = 0; i < xnaGeometry.Indices.Count; i++)
{
indices[i] = xnaGeometry.Indices[i];
}
SerializableMesh mesh = new SerializableMesh();
mesh.name = string.Format("mesh_{0}_{1}", outputModel.meshList.Count, xnaGeometry.Name);
mesh.textureName = GetTextureName(xnaGeometry);
mesh.vertices = vertices;
mesh.indices = indices;
outputModel.meshList.Add(mesh);
}
protected TreeObject(SerializationInfo info, StreamingContext context) : base(info, context)
{
type = (TreeType)info.GetValue(KEY_TYPE, typeof(TreeType));
SerializableMesh sMesh = (SerializableMesh)info.GetValue(KEY_MESH, typeof(SerializableMesh));
if (sMesh != null)
{
mesh = sMesh.toMesh();
}
}
private void SetPaintableObjects(GameObject[] paintableObjects, string sceneryObjPath)
{
BinaryFormatter bf = new BinaryFormatter();
for (int i = 0; i < paintableObjects.Length; i++)
{
FileStream file = File.Open(sceneryObjPath + i.ToString() + ".gd", FileMode.Open);
SerializableMesh sMesh = (SerializableMesh)bf.Deserialize(file);
file.Close();
Mesh mesh = paintableObjects[i].GetComponent <MeshFilter>().mesh;
CopyMeshFromSerializedMesh(mesh, sMesh);
}
}
private void SaveSceneriesToDisk()
{
initializedSceneries.ForEach((sceneryName) =>
{
GameObject scenery = GameObject.Find(sceneryName).transform.GetChild(0).gameObject;
MeshFilter[] meshFilters = scenery.GetComponentsInChildren <MeshFilter>();
BinaryFormatter bf = new BinaryFormatter();
for (int i = 0; i < meshFilters.Length; i++)
{
Mesh mesh = meshFilters[i].mesh;
SerializableMesh sMesh = new SerializableMesh(mesh.tangents, mesh.uv2, mesh.uv3);
FileStream file = File.Create(Application.persistentDataPath + "/saved" + sceneryName + i.ToString() + ".gd");
bf.Serialize(file, sMesh);
file.Close();
}
});
}
public static SerializableMesh SerializeMesh(Mesh mesh)
{
SerializableMesh sMesh = new SerializableMesh();
sMesh.vertices = SerializeVector3Array(mesh.vertices);
sMesh.triangles = mesh.triangles;
//Colors
List <SerializableVector3> liste = new List <SerializableVector3>();
foreach (var c in mesh.colors)
{
SerializableVector3 vec = new SerializableVector3();
vec.x = c.r / 1f;
vec.y = c.g / 1f;
vec.z = c.b / 1f;
liste.Add(vec);
}
sMesh.colors = liste.ToArray();
return(sMesh);
}
protected Chunk(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
throw new ArgumentNullException("info");
}
x = info.GetInt32(KEY_X);
z = info.GetInt32(KEY_Z);
generated = info.GetBoolean(KEY_GENERATED);
SerializableMesh sMesh = (SerializableMesh)info.GetValue(KEY_MESH, typeof(SerializableMesh));
if (sMesh != null)
{
mesh = sMesh.toMesh();
}
objs = (List <MapObject>)info.GetValue(KEY_OBJECTS, typeof(List <MapObject>));
for (int a = 0; a < objs.Count; a++)
{
objs [a].chunk = this;
}
}
Serializable Serialize(GameObject sObject)
{
Serializable output = new Serializable();
CustomScript cs = sObject.GetComponent <CustomScript>();
for (int j = 0; j < cs.componentList.Length; j++)
{
/*Adds the Transform object for serialization*/
if (cs.componentList[j].GetType().Name.Contains("Transform"))
{
Debug.Log("Added Transform");
SerializableTransform sTransform = new SerializableTransform();
sTransform.name = "Transform";
sTransform.position = cs.gameObject.transform.position;
sTransform.rotation = cs.gameObject.transform.eulerAngles;
sTransform.scale = cs.gameObject.transform.localScale;
output.components.Add(sTransform);
}
else if (cs.componentList[j].GetType().Name.Contains("Renderable"))
{
SerializableMesh sRenderable = new SerializableMesh();
sRenderable.name = "Renderable";
Renderable r = cs.gameObject.GetComponent <Renderable>();
if (sRenderable != null)
{
sRenderable.mesh = r.data.mesh;
sRenderable.material = r.data.material;
sRenderable.albedo = r.data.albedo;
sRenderable.metal = r.data.metal;
sRenderable.roughness = r.data.roughness;
sRenderable.normal = r.data.normal;
sRenderable.height = r.data.height;
sRenderable.ao = r.data.ao;
sRenderable.emissive = r.data.emissive;
}
output.components.Add(sRenderable);
}
else if (cs.componentList[j].GetType().Name.Contains("MeshFilter")) /*Adds the MeshFilter object for serialization*/
{
Debug.Log("MeshRenderer Serialization is deprecated. It will probably be removed in a future update");
//Debug.Log("Added MeshFilter");
//SerializableMesh sMesh = new SerializableMesh();
//sMesh.name = "MeshFilter";
//MeshFilter mf = cs.gameObject.GetComponent<MeshFilter>();
//MeshRenderer mr = cs.gameObject.GetComponent < MeshRenderer>();
//sMesh.mesh = mf.sharedMesh.name;
//sMesh.material = mr.sharedMaterial.name;
//sMesh.castShadows = mr.shadowCastingMode == UnityEngine.Rendering.ShadowCastingMode.On;
//output.components.Add(sMesh);
}
else if (cs.componentList[j].GetType().Name.Contains("MeshRenderer")) /*Adds the MeshRenderer object for serialization*/
{
Debug.Log("MeshRenderer Serialization is deprecated. It will probably be removed in a future update");
// Debug.Log("Added MeshRenderer");
// SerializableMeshRenderer sMeshRenderer = new SerializableMeshRenderer();
// sMeshRenderer.name = "MeshRenderer";
// MeshRenderer mr = cs.gameObject.GetComponent<MeshRenderer>();
// sMeshRenderer.material = mr.sharedMaterial.name;
// sMeshRenderer.castShadows = mr.shadowCastingMode == UnityEngine.Rendering.ShadowCastingMode.On;
// output.components.Add(sMeshRenderer);
}
else if (cs.componentList[j].GetType().Name.Contains("Rigidbody")) /*Adds the Rigidbody object for serialization */
{
Debug.Log("Added Rigidbody");
SerializableRigidbody sRigidbody = new SerializableRigidbody();
sRigidbody.name = "Rigidbody";
Rigidbody rb = cs.gameObject.GetComponent <Rigidbody>();
sRigidbody.mass = rb.mass;
sRigidbody.drag = rb.drag;
sRigidbody.angularDrag = rb.angularDrag;
sRigidbody.useGravity = rb.useGravity;
sRigidbody.isKinematic = rb.isKinematic;
sRigidbody.freezeXPos = rb.constraints == RigidbodyConstraints.FreezePositionX;
sRigidbody.freezeYPos = rb.constraints == RigidbodyConstraints.FreezePositionY;
sRigidbody.freezeZPos = rb.constraints == RigidbodyConstraints.FreezePositionZ;
sRigidbody.freezeXRot = rb.constraints == RigidbodyConstraints.FreezeRotationX;
sRigidbody.freezeYRot = rb.constraints == RigidbodyConstraints.FreezeRotationY;
sRigidbody.freezeZRot = rb.constraints == RigidbodyConstraints.FreezeRotationZ;
output.components.Add(sRigidbody);
}
else if (cs.componentList[j].GetType().Name.Contains("Collider")) /*Adds the Collider object for serialization*/
{
Debug.Log("Added Collider");
if (cs.gameObject.GetComponent <BoxCollider>())
{
SerializableBoxCollider sBCollider = new SerializableBoxCollider();
sBCollider.name = "BoxCollider";
BoxCollider bc = cs.gameObject.GetComponent <BoxCollider>();
sBCollider.isTrigger = bc.isTrigger;
sBCollider.center = bc.center;
sBCollider.size = bc.size;
output.components.Add(sBCollider);
}
else if (cs.gameObject.GetComponent <SphereCollider>())
{
SerializableSphereCollider sSCollider = new SerializableSphereCollider();
sSCollider.name = "SphereCollider";
SphereCollider sc = cs.gameObject.GetComponent <SphereCollider>();
sSCollider.isTrigger = sc.isTrigger;
sSCollider.center = sc.center;
sSCollider.radius = sc.radius;
output.components.Add(sSCollider);
}
}
else
{
SerializableComponent Script = new SerializableComponent();
string fName = cs.componentList[j].GetType().ToString();
if (cs.componentList[j].GetType().ToString().Contains("UnityEngine."))
{
Debug.Log(fName.Length);
Script.name = fName.Substring(12);
}
else
{
Script.name = fName;
}
output.components.Add(Script);
}
}
return(output);
}
