private ButtonState checkClick(OVRInput.Button button, OVRInput.Controller controller, string key, string eventName)
{
if (OVRInput.Get(button, controller))
{
if (clickTime[key] > 0)
{
return(ButtonState.Pressed); // Pressed
}
clickTime[key] = Time.timeSinceLevelLoad;
clickPosition[key] = userCamera.transform.position;
return(ButtonState.Down); // Down
}
else if (clickTime[key] > 0)
{
Infos info = new Infos(1);
info.Add("Duration", Time.timeSinceLevelLoad - clickTime[key]);
VadRAnalyticsManager.RegisterEvent(eventName, clickPosition[key], filterDictionary[key], info, clickTime[key]);
VadRLogger.debug("Event Registered: " + eventName);
clickTime[key] = 0.0f;
return(ButtonState.Up); // Up
}
else
{
clickTime[key] = 0.0f;
return(ButtonState.None);
}
}
public static bool ExportWholeSelectionToSingle(string sceneId, string directoryName, bool includeTextures)
{
if (!CreateTargetFolder(directoryName))
{
VadRLogger.error("Vadr Scene Exporter failed to create target folder: " + directoryName);
return(false);
}
string[] fileParts = directoryName.Split('/');
string fileName = fileParts[fileParts.Length - 1];
using (StreamWriter sw = new StreamWriter(directoryName + "/" + fileName + ".obj"))
{
sw.Write("mtllib ./" + fileName + ".mtl\n");
}
Clear();
bool meshFlag = ExportMeshes(directoryName, fileName, includeTextures);
bool skinnedMeshFlag = ExportSkinnedMeshes(directoryName, fileName, includeTextures);
bool terrainFlag = ExportTerrains(directoryName, fileName, includeTextures);
bool flag = meshFlag | skinnedMeshFlag | terrainFlag;
if (!flag)
{
VadRLogger.warning("No objects found in the scene : " + sceneId + ". Nothing to export");
}
else
{
CompressModel(directoryName + "/" + fileName + ".obj", directoryName + "/" + fileName + ".drc");
}
return(flag);
}
public void setup()
{
userCamera = DataCollectionManager.Instance.userCamera;
lastTime = Time.time;
lastPosition = userCamera.transform.position;
VadRLogger.info("PositionCollector initialized");
}
private void updateStatusError(Exception e, string[] args)
{
if (!this.errorFlag)
{
this.errorFlag = true;
string msg = "Error Uploading model for scene " + this.sceneName +
". Please try after sometime";
switch (e.GetType().ToString())
{
case "System.Net.WebException":
if (((WebException)e).Response != null)
{
using (var stream = ((WebException)e).Response.GetResponseStream())
{
using (var reader = new StreamReader(stream))
{
string error = reader.ReadToEnd();
var parsedError = JSON.Parse(error);
if (parsedError == null || parsedError["message"] == null)
{
VadRLogger.error(msg);
if (this.error != null)
{
this.error(this.sceneName, msg);
}
}
else
{
VadRLogger.error("Error in uploading model for scene "
+ this.sceneName + " Error: " + parsedError["message"]);
if (this.error != null)
{
this.error(this.sceneName, "Error in uploading model for scene "
+ this.sceneName + " Error: " + parsedError["message"]);
}
}
}
}
}
else
{
VadRLogger.error(msg);
if (this.error != null)
{
this.error(this.sceneName, msg);
}
}
break;
default:
VadRLogger.error(msg);
if (this.error != null)
{
this.error(this.sceneName, msg);
}
break;
}
}
}
public void setup()
{
userCamera = DataCollectionManager.Instance.userCamera;
totalFrames = 0;
fpsSum = 0;
VadRLogger.info("PerformanceCollector initialized");
calculateCpuUsage();
calculateRamUsage();
}
void calculateCpuUsage()
{
#if UNITY_ANDROID
cpuFlag = true;
if (Application.platform == RuntimePlatform.Android)
{
Thread oThread = new Thread(() =>
{
while (cpuFlag)
{
float currentTotalCpu = 0.0f, currentProcessCpu = 0.0f;
try
{
System.Diagnostics.Process currentProcess = System.Diagnostics.Process.GetCurrentProcess();
string[] linesCpu = File.ReadAllLines("/proc/stat");
string[] linesCpuProcess = File.ReadAllLines("/proc/" + currentProcess.Id + "/stat");
if (linesCpu.Length > 0)
{
string[] cpuParts = linesCpu[0].Split(' ');
if (cpuParts.Length > 8)
{
for (int i = 2; i < 9; i++)
{
currentTotalCpu += float.Parse(cpuParts[i]);
}
}
}
if (linesCpuProcess.Length > 0)
{
string[] cpuParts = linesCpuProcess[0].Split(' ');
if (cpuParts.Length >= 15)
{
currentProcessCpu = float.Parse(cpuParts[13]) + float.Parse(cpuParts[14]); //13 is for user time and 14 is for kernal time
}
}
if (previousTotalCpu > 0 && previousProcessCpu > 0)
{
cpuUsage = 100 * ((currentProcessCpu - previousProcessCpu) / (currentTotalCpu - previousTotalCpu));
}
previousTotalCpu = currentTotalCpu;
previousProcessCpu = currentProcessCpu;
Thread.Sleep((int)(timeInterval * 1000));
}
catch (Exception e)
{
VadRLogger.warning("Error in collecting cpu data: " + e.Message);
}
}
VadRLogger.debug("Cpu Calculation stopped");
});
oThread.Start();
}
#endif
}
void uploadFileErrorCallback(string filepath, string msg)
{
if (!this.errorFlag)
{
string message = "Error in uploading model for scene: " + this.sceneName + ". Error: " + msg;
VadRLogger.error(message);
this.errorFlag = true;
if (this.error != null)
{
this.error(this.sceneName, message);
}
}
}
/// <summary>
/// Add GameObject to the list of track objectss
/// </summary>
/// <param name="trackObject">Object to track</param>
public void AddTrackObject(GameObject trackObject)
{
VadRLogger.debug("Adding tracked object: " + trackObject.name);
for (int i = 0; i < trackObjects.Count; i++)
{
if (trackObjects[i] == trackObject)
{
return;
}
}
VadRLogger.debug("Added tracked object: " + trackObject.name);
trackObjects.Add(trackObject);
trackObjectsMetadata.Add(new ObjectTrackMetadata(trackObject, 0, calculateSize(trackObject)));
}
void calculateRamUsage()
{
#if UNITY_ANDROID
memFlag = true;
if (Application.platform == RuntimePlatform.Android)
{
Thread oThread = new Thread(() =>
{
while (memFlag)
{
try
{
System.Diagnostics.Process currentProcess = System.Diagnostics.Process.GetCurrentProcess();
string[] linesCpuProcess = File.ReadAllLines("/proc/" + currentProcess.Id + "/status");
for (int i = 0; i < linesCpuProcess.Length; i++)
{
string line = linesCpuProcess[i];
string[] parts = line.Split(':');
if (parts.Length > 1)
{
if (parts[0].Trim().ToLower() == "vmrss")
{
residentStorage = float.Parse(parts[1].Trim().Split(' ')[0]) / 1000.0f;
}
else if (parts[0].Trim().ToLower() == "vmswap")
{
swapStorage = float.Parse(parts[1].Trim().Split(' ')[0]) / 1000.0f;
}
}
}
Thread.Sleep((int)(timeInterval * 1000));
}
catch (Exception e)
{
VadRLogger.warning("Error in collecting Memory Data: " + e.Message);
}
}
VadRLogger.debug("Memory data collection stopped");
});
oThread.Start();
}
#endif
}
// Checking one object in a frame for better performance.
IEnumerator CheckObjectTracking()
{
rayCastHit = new RaycastHit();
objectHit = Physics.Raycast(userCamera.transform.position, cameraForward,
out rayCastHit, Mathf.Infinity);
planes = GeometryUtility.CalculateFrustumPlanes(userCamera);
for (int i = 0; i < trackObjectsMetadata.Count; i++)
{
if (trackObjectsMetadata[i].gameObject != null)
{
if (isInView(trackObjectsMetadata[i], planes) ||
(objectHit && isParent(rayCastHit.transform, trackObjectsMetadata[i].gameObject.transform)))
{
if (isInSight(trackObjectsMetadata[i].gameObject))
{
// Assuming object is visible for more than one second for observable
if (Time.time - trackObjectsMetadata[i].timeVisible > 1.0f)
{
cameraForward = userCamera.transform.forward;
// Ray Cast in camera froward direction to see if it hit the object.
// If hit the object angle = 0.
objectAngle = 0;
if (objectHit && isParent(rayCastHit.transform, trackObjectsMetadata[i].gameObject.transform))
{
objectAngle = 0;
infoGaze = new Infos(1);
filterGaze = new Filters(1);
filterGaze.Add("Object", trackObjectsMetadata[i].gameObject.name);
infoGaze.Add("Time", Time.time - trackObjectsMetadata[i].lastCheckTime);
VadRLogger.debug("Object Gazed: " + trackObjectsMetadata[i].gameObject.name + (Time.time - trackObjectsMetadata[i].lastCheckTime));
VadRAnalyticsManager.RegisterEvent("vadrObject Gaze", rayCastHit.transform.position,
filterGaze, infoGaze);
}
else
{
objectAngle = angleBetweenVectors(cameraForward,
trackObjectsMetadata[i].gameObject.transform.position - userCamera.transform.position);
}
objectDistance = Vector3.Distance(userCamera.transform.position,
trackObjectsMetadata[i].gameObject.transform.position);
focusIndex = calculateFocus(objectAngle, objectDistance, trackObjectsMetadata[i].size);
if (focusIndex > 0)
{
filter = new Filters(1);
filter.Add("Object", trackObjectsMetadata[i].gameObject.name);
info = new Infos(1);
info.Add("Focus", focusIndex);
VadRAnalyticsManager.RegisterEvent("vadrObject Focus", userCamera.transform.position,
filter, info);
}
}
}
else
{
trackObjectsMetadata[i].timeVisible = Time.time; // Resetting time if not visible
}
}
else
{
trackObjectsMetadata[i].timeVisible = Time.time; // Resetting time if not visible
}
}
trackObjectsMetadata[i].lastCheckTime = Time.time;
yield return(null);
}
}
private static void MeshMaterialsToFile(Dictionary <string, ObjMaterial> materialList, string folder, string filename)
{
string sceneName = SceneManager.GetActiveScene().name;
using (StreamWriter sw = new StreamWriter(folder + "/" + filename + ".mtl"))
{
int materialCount = materialList.Count;
int i = 0;
foreach (KeyValuePair <string, ObjMaterial> kvp in materialList)
{
i++;
EditorUtility.DisplayProgressBar("Exporting Textures for scene: " + sceneName, kvp.Key + " Material",
(i / (float)materialCount) / 2 + 0.5f);
Material m = kvp.Value.material;
Color c = Color.white;
if (m.HasProperty("_Color"))
{
c = m.GetColor("_Color");
}
sw.Write("\n");
sw.Write("newmtl {0}\n", kvp.Key);
sw.Write("Ka 0.6 0.6 0.6\n");
sw.Write("Kd " + c.r + " " + c.g + " " + c.b + "\n");
sw.Write("Ks 0.0 0.0 0.0\n");
sw.Write("d 1.0\n");
sw.Write("Ns 96.0\n");
sw.Write("Ni 1.0\n");
sw.Write("illum 1\n");
//TODO some bug where unused textures are still exported?
if (kvp.Value.textureName != null)
{
string destinationFile = "";
int stripIndex = destinationFile.LastIndexOf('/');
if (stripIndex >= 0)
{
destinationFile = destinationFile.Substring(stripIndex + 1).Trim();
}
destinationFile = folder + "/" + destinationFile;
try
{
bool readable;
TextureImporterFormat format;
if (GetTextureImportFormat((Texture2D)m.mainTexture, out readable, out format))
{
Texture2D originalTexture = m.mainTexture as Texture2D;
SetTextureImporterFormat(originalTexture, true, TextureImporterFormat.RGBA32);
int size = 4; //TODO have this adjustable in editorprefs
Texture2D outputMiniTexture = RescaleForExport(originalTexture, Mathf.NextPowerOfTwo(originalTexture.width) / size, Mathf.NextPowerOfTwo(originalTexture.height) / size);
byte[] bytes = outputMiniTexture.EncodeToPNG();
File.WriteAllBytes(destinationFile + m.mainTexture.name + ".png", bytes);
SetTextureImporterFormat(originalTexture, readable, format);
}
else
{
Texture2D tex = new Texture2D(2, 2);
tex.SetPixel(0, 0, Color.grey);
tex.SetPixel(1, 1, Color.grey);
byte[] bytes = tex.EncodeToPNG();
File.WriteAllBytes(destinationFile + m.mainTexture.name + ".png", bytes);
//this sometimes happens when exporting built-in unity textures, such as Default Checker
VadRLogger.warning("Vadr Scene Exporter could not find texture '" + m.mainTexture.name + "'. Creating placeholder texture");
}
}
catch
{
}
sw.Write("map_Kd {0}", m.mainTexture.name + ".png");
}
sw.Write("\n\n\n");
}
}
EditorUtility.ClearProgressBar();
}
private static string SkinnedMeshToString(SkinnedMeshRenderer smr, Dictionary <string, ObjMaterial> materialList)
{
Mesh m = smr.sharedMesh;
if (m == null)
{
return("");
}
if (!smr.enabled || !smr.gameObject.activeInHierarchy)
{
return("");
}
if (m.uv.Length == 0)
{
//TODO figure out why all the vertices explode when uvs not set
VadRLogger.error("Skipping export of skinned mesh \"" + smr.name + "\". Exporting meshes must be unwrapped");
return("");
}
Material[] mats = smr.sharedMaterials;
StringBuilder sb = new StringBuilder();
sb.Append("o ").Append(smr.name).Append("\n");
foreach (Vector3 lv in m.vertices)
{
Vector3 wv = smr.transform.TransformPoint(lv);
//This is sort of ugly - inverting x-component since we're in
//a different coordinate system than "everyone" is "used to".
sb.Append(string.Format("v {0} {1} {2}\n", -wv.x, wv.y, wv.z));
}
sb.Append("\n");
foreach (Vector3 lv in m.normals)
{
Vector3 wv = smr.transform.TransformDirection(lv);
sb.Append(string.Format("vn {0} {1} {2}\n", -wv.x, wv.y, wv.z));
}
sb.Append("\n");
Vector2 textureScale = Vector3.one;
if (mats.Length > 0 && mats[0] != null && mats[0].HasProperty("_MainTex"))
{
textureScale = mats[0].GetTextureScale("_MainTex");
}
foreach (Vector3 v in m.uv)
{
//scale uvs to deal with tiled textures
sb.Append(string.Format("vt {0} {1}\n", v.x * textureScale.x, v.y * textureScale.y));
}
for (int material = 0; material < m.subMeshCount; material++)
{
sb.Append("\n");
if (material >= mats.Length)
{
continue;
}
if (mats[material] == null)
{
sb.Append("usemtl ").Append("null").Append("\n");
}
else
{
sb.Append("usemtl ").Append(mats[material].name).Append("\n");
//sb.Append("usemap ").Append(mats[material].name).Append("\n");
}
//See if this material is already in the materiallist.
try
{
if (mats[material] == null)
{
ObjMaterial objMaterial = new ObjMaterial();
objMaterial.name = "null";
objMaterial.textureName = null;
objMaterial.material = new Material(Shader.Find("Unlit/Color"));
objMaterial.material.color = Color.magenta;
materialList.Add(objMaterial.name, objMaterial);
}
else
{
ObjMaterial objMaterial = new ObjMaterial();
objMaterial.name = mats[material].name;
if (mats[material].mainTexture)
{
objMaterial.textureName = AssetDatabase.GetAssetPath(mats[material].mainTexture);
}
else
{
objMaterial.textureName = null;
}
objMaterial.material = mats[material];
materialList.Add(objMaterial.name, objMaterial);
}
}
catch (ArgumentException)
{
//Already in the dictionary
}
int[] triangles = m.GetTriangles(material);
for (int i = 0; i < triangles.Length; i += 3)
{
//Because we inverted the x-component, we also needed to alter the triangle winding.
sb.Append(string.Format("f {1}/{1}/{1} {0}/{0}/{0} {2}/{2}/{2}\n",
triangles[i] + 1 + vertexOffset, triangles[i + 1] + 1 + normalOffset, triangles[i + 2] + 1 + uvOffset));
}
}
vertexOffset += m.vertices.Length;
normalOffset += m.normals.Length;
uvOffset += m.uv.Length;
return(sb.ToString());
}
