private void getNodesByteArray()
{
nodesByteData = new byte[0];
foreach (SceneNode node in nodeList)
{
byte[] nodeBinary;
byte[] nodeTypeBinary;
byte[] nodeLengthBinary;
if (node.GetType() == typeof(SceneNodeGeo))
{
nodeTypeBinary = BitConverter.GetBytes((int)NodeType.GEO);
SceneNodeGeo nodeGeo = (SceneNodeGeo)Convert.ChangeType(node, typeof(SceneNodeGeo));
nodeBinary = SceneDataHandler.StructToByteArray <SceneNodeGeo>(nodeGeo);
}
else if (node.GetType() == typeof(SceneNodeSkinnedGeo))
{
nodeTypeBinary = BitConverter.GetBytes((int)NodeType.SKINNEDMESH);
SceneNodeSkinnedGeo nodeGeo = (SceneNodeSkinnedGeo)Convert.ChangeType(node, typeof(SceneNodeSkinnedGeo));
nodeBinary = SceneDataHandler.StructToByteArray <SceneNodeSkinnedGeo>(nodeGeo);
}
else if (node.GetType() == typeof(SceneNodeLight))
{
nodeTypeBinary = BitConverter.GetBytes((int)NodeType.LIGHT);
SceneNodeLight nodeLight = (SceneNodeLight)Convert.ChangeType(node, typeof(SceneNodeLight));
nodeBinary = SceneDataHandler.StructToByteArray <SceneNodeLight>(nodeLight);
}
else if (node.GetType() == typeof(SceneNodeCam))
{
nodeTypeBinary = BitConverter.GetBytes((int)NodeType.CAMERA);
SceneNodeCam nodeCam = (SceneNodeCam)Convert.ChangeType(node, typeof(SceneNodeCam));
nodeBinary = SceneDataHandler.StructToByteArray <SceneNodeCam>(nodeCam);
}
else
{
nodeTypeBinary = BitConverter.GetBytes((int)NodeType.GROUP);
nodeBinary = SceneDataHandler.StructToByteArray <SceneNode>(node);
}
nodeLengthBinary = BitConverter.GetBytes(nodeBinary.Length);
// concate arrays
nodesByteData = SceneDataHandler.Concat <byte>(nodesByteData, nodeLengthBinary);
nodesByteData = SceneDataHandler.Concat <byte>(nodesByteData, nodeTypeBinary);
nodesByteData = SceneDataHandler.Concat <byte>(nodesByteData, nodeBinary);
}
}
public static SceneNode ParseNode(NodeType nodeType, ref byte[] nodesByteData, int dataIdx, int length)
{
switch (nodeType)
{
case NodeType.GROUP:
SceneNode sceneNode = new SceneNode();
SceneDataHandler.ByteArrayToStruct <SceneNode>(ref nodesByteData, out sceneNode, dataIdx, length);
return(sceneNode);
break;
case NodeType.GEO:
SceneNodeGeo sceneNodeGeo = new SceneNodeGeo();
SceneDataHandler.ByteArrayToStruct <SceneNodeGeo>(ref nodesByteData, out sceneNodeGeo, dataIdx, length);
return(sceneNodeGeo);
break;
case NodeType.SKINNEDMESH:
SceneNodeSkinnedGeo sceneNodeSkinnedGeo = new SceneNodeSkinnedGeo();
SceneDataHandler.ByteArrayToStruct <SceneNodeSkinnedGeo>(ref nodesByteData, out sceneNodeSkinnedGeo, dataIdx, length);
return(sceneNodeSkinnedGeo);
break;
case NodeType.LIGHT:
SceneNodeLight sceneNodeLight = new SceneNodeLight();
SceneDataHandler.ByteArrayToStruct <SceneNodeLight>(ref nodesByteData, out sceneNodeLight, dataIdx, length);
return(sceneNodeLight);
break;
case NodeType.CAMERA:
SceneNodeCam sceneNodeCamera = new SceneNodeCam();
SceneDataHandler.ByteArrayToStruct <SceneNodeCam>(ref nodesByteData, out sceneNodeCamera, dataIdx, length);
return(sceneNodeCamera);
break;
}
return(null);
}
public static GameObject BuildNode(ref SceneNode node, Transform parent, GameObject obj, bool resetID, ref List <Tuple <Renderer, string, string[]> > skinnedMeshRootBones)
{
if (resetID)
{
idCount = 0;
}
if (node.GetType() == typeof(SceneNodeGeo))
{
SceneNodeGeo nodeGeo = (SceneNodeGeo)Convert.ChangeType(node, typeof(SceneNodeGeo));
return(CreateObject(nodeGeo, parent));
}
else if (node.GetType() == typeof(SceneNodeSkinnedGeo))
{
SceneNodeSkinnedGeo nodeSkinnedGeo = (SceneNodeSkinnedGeo)Convert.ChangeType(node, typeof(SceneNodeSkinnedGeo));
return(CreateSkinnedObject(nodeSkinnedGeo, parent, ref skinnedMeshRootBones));
}
else if (node.GetType() == typeof(SceneNodeLight))
{
SceneNodeLight nodeLight = (SceneNodeLight)Convert.ChangeType(node, typeof(SceneNodeLight));
GameObject _obj = CreateLight(nodeLight, parent);
SceneLoader.SelectableLights.Add(_obj);
return(_obj);
}
else if (node.GetType() == typeof(SceneNodeCam))
{
SceneNodeCam nodeCam = (SceneNodeCam)Convert.ChangeType(node, typeof(SceneNodeCam));
// make the camera editable
// nodeCam.editable = true;
return(CreateCamera(nodeCam, parent));
}
else if (node.GetType() == typeof(SceneNode))
{
return(CreateNode(node, parent));
}
return(null);
}
public static SceneNode ParseNode(NodeType nodeType, ref byte[] nodesByteData, ref int offset)
{
switch (nodeType)
{
case NodeType.GROUP:
SceneNode sceneNode = SceneDataHandler.ByteArrayToStructure <SceneNode>(ref nodesByteData, ref offset);
return(sceneNode);
break;
case NodeType.GEO:
SceneNodeGeo sceneNodeGeo = SceneDataHandler.ByteArrayToStructure <SceneNodeGeo>(ref nodesByteData, ref offset);
return(sceneNodeGeo);
break;
case NodeType.SKINNEDMESH:
SceneNodeSkinnedGeo sceneNodeSkinnedGeo = SceneDataHandler.ByteArrayToStructure <SceneNodeSkinnedGeo>(ref nodesByteData, ref offset);
return(sceneNodeSkinnedGeo);
break;
case NodeType.LIGHT:
SceneNodeLight sceneNodeLight = SceneDataHandler.ByteArrayToStructure <SceneNodeLight>(ref nodesByteData, ref offset);
return(sceneNodeLight);
break;
case NodeType.CAMERA:
SceneNodeCam sceneNodeCamera = SceneDataHandler.ByteArrayToStructure <SceneNodeCam>(ref nodesByteData, ref offset);
return(sceneNodeCamera);
break;
}
return(null);
}
//!
//! function to create the object from mesh data for skinned meshes
//! @param scnObjKtn object which holds the data
//!
public static GameObject CreateSkinnedObject(SceneNodeSkinnedGeo nodeGeo, Transform parentTransform, ref List <Tuple <Renderer, string, string[]> > skinnedMeshRootBones)
{
GameObject objMain;
// Transform / convert handiness
Vector3 pos = new Vector3(nodeGeo.position[0], nodeGeo.position[1], nodeGeo.position[2]);
// Rotation / convert handiness
Quaternion rot = new Quaternion(nodeGeo.rotation[0], nodeGeo.rotation[1], nodeGeo.rotation[2], nodeGeo.rotation[3]);
// Scale
Vector3 scl = new Vector3(nodeGeo.scale[0], nodeGeo.scale[1], nodeGeo.scale[2]);
if (!parentTransform.Find(Encoding.ASCII.GetString(nodeGeo.name)))
{
// Material Properties and Textures
Material mat;
#if TRUNK
// assign material from material list
if (nodeGeo.materialId > -1 && nodeGeo.materialId < SceneLoader.SceneMaterialList.Count)
{
mat = SceneLoader.SceneMaterialList[nodeGeo.materialId];
}
else // or set standard
{
mat = new Material(Shader.Find("Standard"));
}
#else
mat = new Material(Shader.Find("Standard"));
#endif
// map properties
if (VPETSettings.Instance.doLoadTextures)
{
SceneLoader.MapMaterialProperties(mat, nodeGeo);
}
// set up object basics
objMain = new GameObject();
objMain.name = Encoding.ASCII.GetString(nodeGeo.name);
// Add Material
Renderer renderer;
renderer = objMain.AddComponent <SkinnedMeshRenderer>();
// Add Mesh
if (nodeGeo.geoId > -1 && nodeGeo.geoId < SceneLoader.SceneMeshList.Count)
{
Mesh[] meshes = SceneLoader.SceneMeshList[nodeGeo.geoId];
SkinnedMeshRenderer sRenderer = ((SkinnedMeshRenderer)renderer);
string rootBoneDagPath = nodeGeo.rootBoneDagPath;
skinnedMeshRootBones.Add(new Tuple <Renderer, string, string[]>(renderer, rootBoneDagPath, nodeGeo.skinnedMeshBonesArray.Split('\r')));
VPETSettings.Instance.sceneBoundsMax = Vector3.Max(VPETSettings.Instance.sceneBoundsMax, renderer.bounds.max);
VPETSettings.Instance.sceneBoundsMin = Vector3.Min(VPETSettings.Instance.sceneBoundsMin, renderer.bounds.min);
Bounds bounds = new Bounds(new Vector3(nodeGeo.boundCenter[0], nodeGeo.boundCenter[1], nodeGeo.boundCenter[2]),
new Vector3(nodeGeo.boundExtents[0] * 2f, nodeGeo.boundExtents[1] * 2f, nodeGeo.boundExtents[2] * 2f));
sRenderer.localBounds = bounds;
Matrix4x4[] bindposes = new Matrix4x4[nodeGeo.bindPoseLength];
for (int i = 0; i < nodeGeo.bindPoseLength; i++)
{
bindposes[i] = new Matrix4x4();
bindposes[i][0, 0] = nodeGeo.bindPoses[i * 16];
bindposes[i][0, 1] = nodeGeo.bindPoses[i * 16 + 1];
bindposes[i][0, 2] = nodeGeo.bindPoses[i * 16 + 2];
bindposes[i][0, 3] = nodeGeo.bindPoses[i * 16 + 3];
bindposes[i][1, 0] = nodeGeo.bindPoses[i * 16 + 4];
bindposes[i][1, 1] = nodeGeo.bindPoses[i * 16 + 5];
bindposes[i][1, 2] = nodeGeo.bindPoses[i * 16 + 6];
bindposes[i][1, 3] = nodeGeo.bindPoses[i * 16 + 7];
bindposes[i][2, 0] = nodeGeo.bindPoses[i * 16 + 8];
bindposes[i][2, 1] = nodeGeo.bindPoses[i * 16 + 9];
bindposes[i][2, 2] = nodeGeo.bindPoses[i * 16 + 10];
bindposes[i][2, 3] = nodeGeo.bindPoses[i * 16 + 11];
bindposes[i][3, 0] = nodeGeo.bindPoses[i * 16 + 12];
bindposes[i][3, 1] = nodeGeo.bindPoses[i * 16 + 13];
bindposes[i][3, 2] = nodeGeo.bindPoses[i * 16 + 14];
bindposes[i][3, 3] = nodeGeo.bindPoses[i * 16 + 15];
}
meshes[0].bindposes = bindposes;
sRenderer.sharedMesh = meshes[0];
sRenderer.material = mat;
//Note to commented part below:
//Splitting of meshes disabled as we are using 32bit index buffers now!
/*for (int i = 1; i < meshes.Length; i++)
* {
* GameObject subObj = new GameObject(objMain.name + "_part" + i.ToString());
*
* SkinnedMeshRenderer subRenderer;
* subRenderer = subObj.AddComponent<SkinnedMeshRenderer>();
*
* rootBoneDagPath = nodeGeo.rootBoneDagPath;
* skinnedMeshRootBones.Add(new Tuple<Renderer, string, string[]>(subRenderer, rootBoneDagPath, nodeGeo.skinnedMeshBonesArray.Split('\r')));
* Matrix4x4[] subBindposes = new Matrix4x4[nodeGeo.bindPoseLength];
* for (int j = 0; j < nodeGeo.bindPoseLength; j++)
* {
* subBindposes[j] = new Matrix4x4();
* subBindposes[j].m00 = nodeGeo.bindPoses[j * 16];
* subBindposes[j].m01 = nodeGeo.bindPoses[j * 16 + 1];
* subBindposes[j].m02 = nodeGeo.bindPoses[j * 16 + 2];
* subBindposes[j].m03 = nodeGeo.bindPoses[j * 16 + 3];
* subBindposes[j].m10 = nodeGeo.bindPoses[j * 16 + 4];
* subBindposes[j].m11 = nodeGeo.bindPoses[j * 16 + 5];
* subBindposes[j].m12 = nodeGeo.bindPoses[j * 16 + 6];
* subBindposes[j].m13 = nodeGeo.bindPoses[j * 16 + 7];
* subBindposes[j].m20 = nodeGeo.bindPoses[j * 16 + 8];
* subBindposes[j].m21 = nodeGeo.bindPoses[j * 16 + 9];
* subBindposes[j].m22 = nodeGeo.bindPoses[j * 16 + 10];
* subBindposes[j].m23 = nodeGeo.bindPoses[j * 16 + 11];
* subBindposes[j].m30 = nodeGeo.bindPoses[j * 16 + 12];
* subBindposes[j].m31 = nodeGeo.bindPoses[j * 16 + 13];
* subBindposes[j].m32 = nodeGeo.bindPoses[j * 16 + 14];
* subBindposes[j].m33 = nodeGeo.bindPoses[j * 16 + 15];
* }
* meshes[i].bindposes = bindposes;
* subRenderer.sharedMesh = meshes[i];
*
* subRenderer.material = mat;
* subObj.transform.parent = objMain.transform;
* VPETSettings.Instance.sceneBoundsMax = Vector3.Max(VPETSettings.Instance.sceneBoundsMax, subRenderer.bounds.max);
* VPETSettings.Instance.sceneBoundsMin = Vector3.Min(VPETSettings.Instance.sceneBoundsMin, subRenderer.bounds.min);
* Bounds subBounds = new Bounds(new Vector3(nodeGeo.boundCenter[0], nodeGeo.boundCenter[1], nodeGeo.boundCenter[2]),
* new Vector3(nodeGeo.boundExtents[0], nodeGeo.boundExtents[1], nodeGeo.boundExtents[2]));
* subRenderer.localBounds = bounds;
* }*/
Vector3 sceneExtends = VPETSettings.Instance.sceneBoundsMax - VPETSettings.Instance.sceneBoundsMin;
VPETSettings.Instance.maxExtend = Mathf.Max(Mathf.Max(sceneExtends.x, sceneExtends.y), sceneExtends.z);
}
//place object back at original position
objMain.transform.parent = parentTransform;
}
else
{
objMain = parentTransform.Find(Encoding.ASCII.GetString(nodeGeo.name)).gameObject;
}
objMain.transform.localPosition = pos; // new Vector3( 0, 0, 0 );
objMain.transform.localRotation = rot; // Quaternion.identity;
objMain.transform.localScale = scl; // new Vector3( 1, 1, 1 );
if (nodeGeo.editable)
{
SceneObject sceneObject = objMain.AddComponent <SceneObject>();
sceneObject.id = idCount++;
}
return(objMain);
}
//!
//! function to create the object from mesh data for skinned meshes
//! @param scnObjKtn object which holds the data
//!
public static GameObject CreateSkinnedObject(SceneNodeSkinnedGeo nodeGeo, Transform parentTransform, ref List <Tuple <Renderer, GameObject, int[]> > skinnedMeshRootBones)
{
GameObject objMain;
// Transform / convert handiness
Vector3 pos = new Vector3(nodeGeo.position[0], nodeGeo.position[1], nodeGeo.position[2]);
// Rotation / convert handiness
Quaternion rot = new Quaternion(nodeGeo.rotation[0], nodeGeo.rotation[1], nodeGeo.rotation[2], nodeGeo.rotation[3]);
// Scale
Vector3 scl = new Vector3(nodeGeo.scale[0], nodeGeo.scale[1], nodeGeo.scale[2]);
if (!parentTransform.Find(Encoding.ASCII.GetString(nodeGeo.name)))
{
// Material Properties and Textures
Material mat;
#if TRUNK
// assign material from material list
if (nodeGeo.materialId > -1 && nodeGeo.materialId < SceneLoader.SceneMaterialList.Count)
{
mat = SceneLoader.SceneMaterialList[nodeGeo.materialId];
}
else // or set standard
{
mat = new Material(Shader.Find("Standard"));
}
#else
mat = new Material(Shader.Find("Standard"));
#endif
// map properties
if (VPETSettings.Instance.doLoadTextures)
{
SceneLoader.MapMaterialProperties(mat, nodeGeo);
}
// set up object basics
objMain = new GameObject();
objMain.name = Encoding.ASCII.GetString(nodeGeo.name);
// Add Material
Renderer renderer;
renderer = objMain.AddComponent <SkinnedMeshRenderer>();
// Add Mesh
if (nodeGeo.geoId > -1 && nodeGeo.geoId < SceneLoader.SceneMeshList.Count)
{
Mesh[] meshes = SceneLoader.SceneMeshList[nodeGeo.geoId];
SkinnedMeshRenderer sRenderer = ((SkinnedMeshRenderer)renderer);
skinnedMeshRootBones.Add(new Tuple <Renderer, GameObject, int[]>(renderer, objMain, nodeGeo.skinnedMeshBoneIDs));
VPETSettings.Instance.sceneBoundsMax = Vector3.Max(VPETSettings.Instance.sceneBoundsMax, renderer.bounds.max);
VPETSettings.Instance.sceneBoundsMin = Vector3.Min(VPETSettings.Instance.sceneBoundsMin, renderer.bounds.min);
Bounds bounds = new Bounds(new Vector3(nodeGeo.boundCenter[0], nodeGeo.boundCenter[1], nodeGeo.boundCenter[2]),
new Vector3(nodeGeo.boundExtents[0] * 2f, nodeGeo.boundExtents[1] * 2f, nodeGeo.boundExtents[2] * 2f));
sRenderer.localBounds = bounds;
Matrix4x4[] bindposes = new Matrix4x4[nodeGeo.bindPoseLength];
for (int i = 0; i < nodeGeo.bindPoseLength; i++)
{
bindposes[i] = new Matrix4x4();
bindposes[i][0, 0] = nodeGeo.bindPoses[i * 16];
bindposes[i][0, 1] = nodeGeo.bindPoses[i * 16 + 1];
bindposes[i][0, 2] = nodeGeo.bindPoses[i * 16 + 2];
bindposes[i][0, 3] = nodeGeo.bindPoses[i * 16 + 3];
bindposes[i][1, 0] = nodeGeo.bindPoses[i * 16 + 4];
bindposes[i][1, 1] = nodeGeo.bindPoses[i * 16 + 5];
bindposes[i][1, 2] = nodeGeo.bindPoses[i * 16 + 6];
bindposes[i][1, 3] = nodeGeo.bindPoses[i * 16 + 7];
bindposes[i][2, 0] = nodeGeo.bindPoses[i * 16 + 8];
bindposes[i][2, 1] = nodeGeo.bindPoses[i * 16 + 9];
bindposes[i][2, 2] = nodeGeo.bindPoses[i * 16 + 10];
bindposes[i][2, 3] = nodeGeo.bindPoses[i * 16 + 11];
bindposes[i][3, 0] = nodeGeo.bindPoses[i * 16 + 12];
bindposes[i][3, 1] = nodeGeo.bindPoses[i * 16 + 13];
bindposes[i][3, 2] = nodeGeo.bindPoses[i * 16 + 14];
bindposes[i][3, 3] = nodeGeo.bindPoses[i * 16 + 15];
}
meshes[0].bindposes = bindposes;
sRenderer.sharedMesh = meshes[0];
sRenderer.material = mat;
Vector3 sceneExtends = VPETSettings.Instance.sceneBoundsMax - VPETSettings.Instance.sceneBoundsMin;
VPETSettings.Instance.maxExtend = Mathf.Max(Mathf.Max(sceneExtends.x, sceneExtends.y), sceneExtends.z);
}
//place object back at original position
objMain.transform.parent = parentTransform;
}
else
{
objMain = parentTransform.Find(Encoding.ASCII.GetString(nodeGeo.name)).gameObject;
}
objMain.transform.localPosition = pos; // new Vector3( 0, 0, 0 );
objMain.transform.localRotation = rot; // Quaternion.identity;
objMain.transform.localScale = scl; // new Vector3( 1, 1, 1 );
if (nodeGeo.editable)
{
SceneObject sceneObject = objMain.AddComponent <SceneObject>();
sceneObject.id = idCount++;
}
return(objMain);
}
//!
//! Recursively iterate over scene and prepare data to be send to clients
//!
private bool iterLocation(Transform location)
{
// check LOD and retur if not match
if (location.gameObject.layer != lodLowLayer && location.gameObject.layer != lodMixedLayer)
{
return(false);
}
SceneNode node = new SceneNode();
// print("Location: " + location);
if (location.GetComponent <Light>() != null)
{
SceneNodeLight nodeLight = new SceneNodeLight();
Light light = location.GetComponent <Light>();
nodeLight.intensity = light.intensity;
nodeLight.color = new float[3] {
light.color.r, light.color.g, light.color.b
};
nodeLight.lightType = light.type;
nodeLight.exposure = 0;
nodeLight.angle = light.spotAngle;
nodeLight.range = light.range;
node = nodeLight;
node.editable = true;
SceneObject sObj = location.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
}
else if (location.GetComponent <Camera>() != null)
{
SceneNodeCam nodeCamera = new SceneNodeCam();
Camera camera = location.GetComponent <Camera>();
nodeCamera.fov = camera.fieldOfView;
nodeCamera.near = camera.nearClipPlane;
nodeCamera.far = camera.farClipPlane;
node = nodeCamera;
node.editable = true;
SceneObject sObj = location.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
}
else if (location.GetComponent <MeshFilter>() != null)
{
SceneNodeGeo nodeGeo = new SceneNodeGeo();
nodeGeo.color = new float[4] {
0, 0, 0, 0
};
nodeGeo.geoId = processGeometry(location.GetComponent <MeshFilter>().sharedMesh);
if (location.GetComponent <Renderer>() != null && location.GetComponent <Renderer>().sharedMaterial != null)
{
Material mat = location.GetComponent <Renderer>().sharedMaterial;
#if TRUNK
// if materials's shader is not standard, add this material to material package.
// Currently this will only get the material name and try to load it on client side. If this fails, it will fallback to Standard.
nodeGeo.materialId = processMaterial(location.GetComponent <Renderer>().sharedMaterial);
#endif
if (mat.HasProperty("_Color"))
{
nodeGeo.color = new float[4] {
mat.color.r, mat.color.g, mat.color.b, mat.color.a
};
}
if (mat.HasProperty("_Glossiness"))
{
nodeGeo.roughness = mat.GetFloat("_Glossiness");
}
if (mat.mainTexture != null)
{
Texture2D mainTex = (Texture2D)mat.mainTexture;
nodeGeo.textureId = processTexture(mainTex);
}
else
{
nodeGeo.textureId = -1;
}
}
else
{
nodeGeo.textureId = -1;
}
node = nodeGeo;
if (location.gameObject.tag == "editable")
{
node.editable = true;
bool gotHighLod = false;
foreach (Transform child in location.parent)
{
if (child.name == location.name && child.gameObject.layer == lodHighLayer)
{
SceneObject sObj = child.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
gotHighLod = true;
}
}
if (!gotHighLod)
{
SceneObject sObj = location.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
}
}
else
{
node.editable = false;
}
}
else if (location.GetComponent <SkinnedMeshRenderer>() != null)
{
SkinnedMeshRenderer sRenderer = location.GetComponent <SkinnedMeshRenderer>();
SceneNodeSkinnedGeo nodeGeo = new SceneNodeSkinnedGeo();
Material mat = location.GetComponent <Renderer>().sharedMaterial;
#if TRUNK
// if materials's shader is not standard, add this material to material package.
// Currently this will only get the material name and try to load it on client side. If this fails, it will fallback to Standard.
nodeGeo.materialId = processMaterial(location.GetComponent <Renderer>().sharedMaterial);
#endif
nodeGeo.color = new float[4] {
0, 0, 0, 0
};
nodeGeo.geoId = processGeometry(sRenderer.sharedMesh);
nodeGeo.rootBoneID = gameObjectList.IndexOf(sRenderer.rootBone.gameObject);
nodeGeo.boundCenter = new float[3] {
sRenderer.localBounds.center.x, sRenderer.localBounds.center.y, sRenderer.localBounds.center.z
};
nodeGeo.boundExtents = new float[3] {
sRenderer.localBounds.extents.x, sRenderer.localBounds.extents.y, sRenderer.localBounds.extents.z
};
nodeGeo.bindPoseLength = sRenderer.sharedMesh.bindposes.Length;
//Debug.Log("Bindpose Length: " + sRenderer.sharedMesh.bindposes.Length.ToString());
nodeGeo.bindPoses = new float[nodeGeo.bindPoseLength * 16];
for (int i = 0; i < nodeGeo.bindPoseLength; i++)
{
nodeGeo.bindPoses[i * 16] = sRenderer.sharedMesh.bindposes[i].m00;
nodeGeo.bindPoses[i * 16 + 1] = sRenderer.sharedMesh.bindposes[i].m01;
nodeGeo.bindPoses[i * 16 + 2] = sRenderer.sharedMesh.bindposes[i].m02;
nodeGeo.bindPoses[i * 16 + 3] = sRenderer.sharedMesh.bindposes[i].m03;
nodeGeo.bindPoses[i * 16 + 4] = sRenderer.sharedMesh.bindposes[i].m10;
nodeGeo.bindPoses[i * 16 + 5] = sRenderer.sharedMesh.bindposes[i].m11;
nodeGeo.bindPoses[i * 16 + 6] = sRenderer.sharedMesh.bindposes[i].m12;
nodeGeo.bindPoses[i * 16 + 7] = sRenderer.sharedMesh.bindposes[i].m13;
nodeGeo.bindPoses[i * 16 + 8] = sRenderer.sharedMesh.bindposes[i].m20;
nodeGeo.bindPoses[i * 16 + 9] = sRenderer.sharedMesh.bindposes[i].m21;
nodeGeo.bindPoses[i * 16 + 10] = sRenderer.sharedMesh.bindposes[i].m22;
nodeGeo.bindPoses[i * 16 + 11] = sRenderer.sharedMesh.bindposes[i].m23;
nodeGeo.bindPoses[i * 16 + 12] = sRenderer.sharedMesh.bindposes[i].m30;
nodeGeo.bindPoses[i * 16 + 13] = sRenderer.sharedMesh.bindposes[i].m31;
nodeGeo.bindPoses[i * 16 + 14] = sRenderer.sharedMesh.bindposes[i].m32;
nodeGeo.bindPoses[i * 16 + 15] = sRenderer.sharedMesh.bindposes[i].m33;
}
nodeGeo.skinnedMeshBoneIDs = Enumerable.Repeat(-1, 99).ToArray <int>();
for (int i = 0; i < sRenderer.bones.Length; i++)
{
nodeGeo.skinnedMeshBoneIDs[i] = gameObjectList.IndexOf(sRenderer.bones[i].gameObject);
}
if (sRenderer.material != null)
{
mat = sRenderer.material;
if (mat.HasProperty("_Color"))
{
nodeGeo.color = new float[4] {
mat.color.r, mat.color.g, mat.color.b, mat.color.a
};
}
if (mat.HasProperty("_Glossiness"))
{
nodeGeo.roughness = mat.GetFloat("_Glossiness");
}
if (mat.mainTexture != null)
{
Texture2D mainTex = (Texture2D)mat.mainTexture;
nodeGeo.textureId = processTexture(mainTex);
}
else
{
nodeGeo.textureId = -1;
}
}
else
{
nodeGeo.textureId = -1;
}
node = nodeGeo;
if (location.gameObject.tag == "editable")
{
node.editable = true;
bool gotHighLod = false;
foreach (Transform child in location.parent)
{
if (child.name == location.name && child.gameObject.layer == lodHighLayer)
{
SceneObject sObj = child.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
gotHighLod = true;
}
}
if (!gotHighLod)
{
SceneObject sObj = location.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
}
}
else
{
node.editable = false;
}
}
else if (location.gameObject.tag == "editable")
{
node.editable = true;
SceneObject sObj = location.gameObject.AddComponent <SceneObject>();
sObj.id = globalID;
globalID++;
}
Animator animator = location.GetComponent <Animator>();
if (animator != null)
{
animator.logWarnings = false;
processCharacter(animator);
}
//if (location.gameObject.tag == "editable")
//{
// node.editable = true;
// SceneObject sObj = location.gameObject.AddComponent<SceneObject>();
// sObj.id = globalID;
// globalID++;
//}
//else
// node.editable = false;
node.position = new float[3] {
location.localPosition.x, location.localPosition.y, location.localPosition.z
};
node.scale = new float[3] {
location.localScale.x, location.localScale.y, location.localScale.z
};
node.rotation = new float[4] {
location.localRotation.x, location.localRotation.y, location.localRotation.z, location.localRotation.w
};
node.name = new byte[256];
byte[] tmpName = Encoding.ASCII.GetBytes(location.name);
for (int i = 0; i < tmpName.Length; i++)
{
node.name[i] = tmpName[i];
}
if (location.name != "root")
{
// print("Added: " + location.name);
nodeList.Add(node);
}
// recursive children
int childCounter = 0;
if (location.childCount > 0)
{
foreach (Transform child in location)
{
if (!child.gameObject.activeSelf)
{
continue;
}
if (iterLocation(child))
{
childCounter++;
}
}
}
node.childCount = childCounter;
if (doAssignSceneObjects)
{
if (location.gameObject.tag == "editable")
{
#if UNITY_EDITOR
// add recorder
if (sceneName != "" && shotName != "" && takeName != "")
{
UnityAnimationRecorder animRecorder = location.gameObject.AddComponent <UnityAnimationRecorder>();
animRecorder.savePath = recordPath;
animRecorder.fileName = String.Format("{0}_{1}_{2}_{3}", sceneName, shotName, takeName, location.name);
animRecorder.showLogGUI = true;
}
#endif
}
else if (location.GetComponent <Light>() != null)
{
// Add light prefab
GameObject lightUber = Resources.Load <GameObject>("VPET/Prefabs/UberLight");
GameObject _lightUberInstance = Instantiate(lightUber);
_lightUberInstance.name = lightUber.name;
_lightUberInstance.transform.SetParent(location, false);
SceneNodeLight nodeLight = (SceneNodeLight)Convert.ChangeType(node, typeof(SceneNodeLight));
Light lightComponent = _lightUberInstance.GetComponent <Light>();
lightComponent.type = nodeLight.lightType;
lightComponent.color = new Color(nodeLight.color[0], nodeLight.color[1], nodeLight.color[2]);
lightComponent.intensity = nodeLight.intensity * VPETSettings.Instance.lightIntensityFactor;
lightComponent.spotAngle = Mathf.Min(150, nodeLight.angle);
lightComponent.range = nodeLight.range;
location.GetComponent <Light>().enabled = false;
#if UNITY_EDITOR
// add recorder
if (sceneName != "" && shotName != "" && takeName != "")
{
UnityAnimationRecorder animRecorder = location.gameObject.AddComponent <UnityAnimationRecorder>();
animRecorder.savePath = recordPath;
animRecorder.fileName = String.Format("{0}_{1}_{2}_{3}", sceneName, shotName, takeName, location.name);
animRecorder.showLogGUI = true;
}
#endif
}
else if (location.GetComponent <Camera>() != null)
{
// add camera dummy mesh
GameObject cameraObject = Resources.Load <GameObject>("VPET/Prefabs/cameraObject");
GameObject cameraInstance = Instantiate(cameraObject);
cameraInstance.SetActive(false);
cameraInstance.name = cameraObject.name;
cameraInstance.transform.SetParent(location.transform, false);
cameraInstance.transform.localScale = new Vector3(1, 1, 1);
cameraInstance.transform.localPosition = new Vector3(0, 0, -0.5f);
#if UNITY_EDITOR
// add recorder
if (sceneName != "" && shotName != "" && takeName != "")
{
UnityAnimationRecorder animRecorder = location.gameObject.AddComponent <UnityAnimationRecorder>();
animRecorder.savePath = recordPath;
animRecorder.fileName = String.Format("{0}_{1}_{2}_{3}", sceneName, shotName, takeName, location.name);
animRecorder.showLogGUI = true;
}
#endif
}
}
return(true);
}