public override void NotifyVerticalSliceBundleLoaded(VerticalActivitySlice[] slices)
{
base.NotifyVerticalSliceBundleLoaded(slices);
if (fpsInfoGraph != null)
fpsInfoGraph.UpdateDataBundle(slices);
if (memoryInfoGraph != null)
memoryInfoGraph.UpdateDataBundle(slices);
}
protected override string CollectHoverData(VerticalActivitySlice slice)
{
float div = 1048576;
string result = "Textures 2D/3D: " + (slice.systemInfo.activeTextures != -1 ? (slice.systemInfo.activeTextures + " [" + (slice.systemInfo.activeTextureMemory / div) + " mb]\n") : "n/a\n");
result += "Render textures: " + (slice.systemInfo.activeRenderTextures != -1 ? (slice.systemInfo.activeRenderTextures + " [" + (slice.systemInfo.activeRenderTextureMemory / div) + " mb]\n") : "n/a\n");
result += "Audio clips: " + (slice.systemInfo.activeAudioClips != -1 ? (slice.systemInfo.activeAudioClips + " [" + (slice.systemInfo.activeAudioClipMemory / div) + " mb]\n") : "n/a\n");
result += "Animation clips: " + (slice.systemInfo.activeAnimations != -1 ? (slice.systemInfo.activeAnimations + " [" + (slice.systemInfo.activeAnimationMemory/ div) + " mb]\n") : "n/a\n");
result += "Mesh data: " + (slice.systemInfo.activeMeshes != -1 ? (slice.systemInfo.activeMeshes + " [" + (slice.systemInfo.activeMeshMemory / div) + " mb]\n") : "n/a\n");
result += "Materials: " + (slice.systemInfo.activeMaterials != -1 ? (slice.systemInfo.activeMaterials + " [" + (slice.systemInfo.activeMaterialsMemory / div) + " mb]\n") : "n/a\n");
return result;
}
protected override float[] GetSliceGraphData(VerticalActivitySlice slice)
{
return new float[]
{
slice.systemInfo.activeTextureMemory,
slice.systemInfo.activeRenderTextureMemory,
slice.systemInfo.activeAudioClipMemory,
slice.systemInfo.activeAnimationMemory,
slice.systemInfo.activeMeshMemory,
slice.systemInfo.activeMaterialsMemory
};
}
public static SMesh GetMeshFromSlice(VerticalActivitySlice slice, int meshGoInstanceID)
{
if (slice == null || slice.meshData == null)
return null;
foreach (SWorldObject wo in slice.meshData.worldObjects) {
if (wo == null || wo.meshes == null)
continue;
foreach (SMesh mesh in wo.meshes) {
if (mesh != null && mesh.header.goInstanceID == meshGoInstanceID)
return mesh;
}
}
return null;
}
public static VerticalActivitySlice Deserialize(byte[] input)
{
ComposedByteStream stream = ComposedByteStream.FromByteArray(input);
if (stream == null)
return null;
VerticalActivitySlice result = new VerticalActivitySlice();
result.header = VerticalSliceHeaderData.Deserialize(stream.ReadNextStream<byte>());
result.systemInfo = SystemInfoSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.debugLogs = DebugLogSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.humanInput = HumanInputSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.meshData = MeshDataSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.particleData = ParticleDataSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.materialData = MaterialDataSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.gameObjectsSnapshot = GameObjectsSnapshot.Deserialize(stream.ReadNextStream<byte>());
result.screenCapture = ScreenCaptureSnapshot.Deserialize(stream.ReadNextStream<byte>());
return result;
}
public ExposedGameObject[] GetChildren(int instanceID, VerticalActivitySlice slice)
{
if (slice == null || slice.gameObjectsSnapshot == null || slice.gameObjectsSnapshot.gameObjects == null)
return null;
long key = vBugMathHelper.CombineInts(instanceID, slice.header.frameNumber);
if (childrenPerGO.ContainsKey(key)) {
return childrenPerGO[key];
} else {
List<ExposedGameObject> result = new List<ExposedGameObject>();
ExposedGameObject[] allGameObjects = slice.gameObjectsSnapshot.gameObjects;
int i = allGameObjects.Length;
while (--i > -1) {
if (allGameObjects[i].parentID == instanceID)
result.Add(allGameObjects[i]);
}
ExposedGameObject[] resultArray = result.ToArray();
childrenPerGO.Add(key, resultArray);
return resultArray;
}
}
public ExposedComponent[] GetComponents(ExposedGameObject go, VerticalActivitySlice slice)
{
if (go == null || go.components == null)
return null;
if (slice == null || slice.gameObjectsSnapshot == null || slice.gameObjectsSnapshot.components == null)
return null;
long key = vBugMathHelper.CombineInts(go.transformID, slice.header.frameNumber);
if (componentsPerGO.ContainsKey(key)) {
return componentsPerGO[key];
} else {
int i = go.components.Length;
ExposedComponent[] allComponents = slice.gameObjectsSnapshot.components;
ExposedComponent[] result = new ExposedComponent[i];
while (--i > -1)
result[i] = allComponents[go.components[i]];
componentsPerGO.Add(key, result);
return result;
}
}
public override void DrawQuads(Transform parent, Vector3 localScale, VerticalActivitySlice slice)
{
if (slice == null || slice.humanInput == null) {
DestroyAllQuads();
return;
}
if (mouseNormal == null)
InitQuads();
foreach (HumanInputProviderData provider in slice.humanInput.providersData){
if (provider == null)
continue;
if (provider.providerType == "MouseInputProvider") {
if (provider.basicInput != null && provider.basicInput.Length > 0)
DrawMouseQuads(provider, parent, slice.header.screenWidth, slice.header.screenHeight);
break;
}
}
return;
}
public void UpdateDataBundle(VerticalActivitySlice[] bundle)
{
UpdateMouseOverInfo(bundle);
canvasDirty = true;
}
public override void DrawSettingsLayout(VerticalActivitySlice slice, bool showAlpha)
{
base.DrawSettingsLayout(slice, showAlpha);
Rect icon = GUILayoutUtility.GetRect(32, 32);
VisualResources.DrawIcon(EditorIcon.playbackOptions, 3, new Vector2(icon.x, icon.y + 5), 1f, false);
//--------------- Check cam names --------------------
if (slice != null && slice.screenCapture != null && slice.screenCapture.camNames != null) {
foreach (string name in slice.screenCapture.camNames) {
if (!camNames.Contains(name)) {
camNames.Add(name);
camStates.Add(true);
}
}
}
//--------------- Check cam names --------------------
//--------------- Draw toggles --------------------
scrollPos = GUILayout.BeginScrollView(scrollPos);
GUILayout.BeginHorizontal();
if (camNames.Count > 0) {
for (int i = 0; i < camNames.Count; i++)
camStates[i] = GUILayout.Toggle(camStates[i], camNames[i], EditorHelper.styleToggle);
if (GUI.changed)
isDirty = true;
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.EndScrollView();
//--------------- Draw toggles --------------------
}
public virtual void DrawSettingsLayout(VerticalActivitySlice slice, bool showAlpha)
{
this.showAlpha = showAlpha;
}
public override void NotifyVerticalSliceBundleLoaded(VerticalActivitySlice[] slices)
{
base.NotifyVerticalSliceBundleLoaded(slices);
UpdateOverlays(vBugWindowMediator.currentFrameNumber);
Repaint();
}
private void DrawSettingsOptions(float startY, VerticalActivitySlice slice)
{
VisualResources.DrawTexture(new Rect(0, startY, this.position.width, optionsBarHeight), VisualResources.proConsoleRowDark);
Rect layoutRect = new Rect(0f, startY, this.position.width, dragBarRect.y - startY);
GUILayout.BeginArea(layoutRect);
GUILayout.BeginHorizontal();
//--------------- Rotations options --------------------
//GUILayout.Space(45);
Rect icon = GUILayoutUtility.GetRect(40, optionsBarHeight);
VisualResources.DrawIcon(EditorIcon.playbackOptions, 1, new Vector2(icon.x + 10, icon.y + 5), 1f, false);
GUILayout.BeginVertical(GUILayout.Width(100));
GUILayout.Space(5);
rotOptionIdx = EditorGUILayout.Popup(rotOptionIdx, rotationsOptions, EditorHelper.stylePopup);
rotationMode = (PlaybackScreenRotationMode)rotOptionIdx;
GUILayout.BeginHorizontal();
GUI.enabled = rotationMode != PlaybackScreenRotationMode.none;
rotationZOnly = GUILayout.Toggle(rotationZOnly, "'Z' axis only", EditorHelper.styleToggle);
GUI.enabled = true;
showAlpha = GUILayout.Toggle(showAlpha, "alpha", EditorHelper.styleToggle);
GUILayout.EndHorizontal();
GUILayout.EndVertical();
//--------------- Rotations options --------------------
//--------------- VertBar --------------------
GUILayout.Space(10);
Rect vertBar = GUILayoutUtility.GetRect(5, optionsBarHeight);
VisualResources.DrawTexture(new Rect(vertBar.x, vertBar.y +5, 5, optionsBarHeight - 10), VisualResources.proConsoleRowLight);
GUILayout.Space(10);
//--------------- VertBar --------------------
//--------------- Overlay options --------------------
foreach (BasePlaybackOverlay overlay in overlays) {
overlay.DrawSettingsLayout(slice, showAlpha);
}
//--------------- Overlay options --------------------
GUILayout.EndHorizontal();
GUILayout.EndArea();
}
private void UpdateMouseOverInfo(VerticalActivitySlice[] bundle)
{
foreach (VerticalActivitySlice slice in bundle) {
if (!ValidateSlice(slice))
continue;
string info = CollectHoverData(slice);
if (mouseOverInfo.ContainsKey(slice.header.frameNumber)) {
mouseOverInfo[slice.header.frameNumber] = info;
} else {
mouseOverInfo.Add(slice.header.frameNumber, info);
}
}
}
private void DrawGameObjectsRecursive(VerticalActivitySlice slice, ExposedGameObject[] gameObjects, bool parentActive, bool allowMouseClick)
{
EventType eventType = Event.current.type;
GUILayout.BeginVertical();
Rect lastRect = default(Rect);
foreach (ExposedGameObject go in gameObjects) {
ExposedGameObject[] children = GetChildren(go.transformID, slice);
bool isFoldout = children != null && children.Length > 0;
//--------------- Draw recursive --------------------
if (!hierarchyFoldoutStates.ContainsKey(go.transformID))
hierarchyFoldoutStates.Add(go.transformID, false);
bool localActive = parentActive && go.activeSelf;
string label = go.name;
GUI.color = localActive ? Color.white : new Color(0.6f, 0.6f, 0.6f);
if (go.isHiddenOrDontSave && go.transformID != nextSelectedID) {
GUI.color = new Color(0.1f, 0.1f, 0.1f);
label = "[hidden]" + label;
} else if (go.isStatic) {
GUI.color = new Color(0.8f, 0.8f, 0.8f);
label = "[static] " + label;
} else {
GUI.color = Color.white;
}
string currentControlName = "hierarchy_" + go.transformID;
GUI.SetNextControlName(currentControlName);
controllIndexing.Add(currentControlName);
bool drawInspIcon = eventType == EventType.repaint && go.components != null && go.components.Length > 0;
bool drawEOLIcon = TestEOL(go.transformID, slice.header.frameNumber);
bool drawBirthIcon = TestBirth(go.transformID, slice.header.frameNumber);
int offset = 0;
if (isFoldout) {
bool newState = EditorGUILayout.Foldout(hierarchyFoldoutStates[go.transformID], label, EditorHelper.styleHierarchyFoldout);
lastRect = GUILayoutUtility.GetLastRect();
if (newState != hierarchyFoldoutStates[go.transformID]) {
SetNextSelection(go.transformID);
if (newState)
SortReflectedObjectsByName(children);
}
hierarchyFoldoutStates[go.transformID] = newState;
if (newState) {
GUILayout.BeginHorizontal();
GUILayout.Space(16);
DrawGameObjectsRecursive(slice, children, localActive, allowMouseClick);
GUILayout.EndHorizontal();
}
if (hasFocus && eventType == EventType.mouseUp && GUI.GetNameOfFocusedControl() == currentControlName)
SetNextSelection(go.transformID);
} else {
GUILayout.BeginHorizontal();
GUILayout.Space(18);
offset = 14;
if (GUILayout.Button(label, EditorHelper.styleHierarchyLabel, GUILayout.Height(16)))
SetNextSelection(go.transformID);
lastRect = GUILayoutUtility.GetLastRect();
GUILayout.EndHorizontal();
}
if (drawInspIcon)
VisualResources.DrawIcon(EditorIcon.hierarchyAndInspector, 1, new Vector2(lastRect.x - 12 - offset, lastRect.y + 2), 1f, false);
if (drawEOLIcon)
VisualResources.DrawIcon(EditorIcon.hierarchyAndInspector, 3, new Vector2(lastRect.x - 24 - offset, lastRect.y + 2), 1f, false);
if (drawBirthIcon)
VisualResources.DrawIcon(EditorIcon.hierarchyAndInspector, 0, new Vector2(lastRect.x - 36 - offset, lastRect.y + 2), 1f, false);
//--------------- Draw recursive --------------------
}
GUILayout.EndVertical();
GUI.color = GUI.contentColor = GUI.backgroundColor = Color.white;
}
public override void NotifyVerticalSliceBundleLoaded(VerticalActivitySlice[] slices)
{
base.NotifyVerticalSliceBundleLoaded(slices);
ClearDictionaries();
SetCurrentSlice(vBugWindowMediator.currentFrameNumber);
}
public override void NotifyVerticalSliceBundleLoaded(VerticalActivitySlice[] slices)
{
base.NotifyVerticalSliceBundleLoaded(slices);
RebuildCachedData(slices);
Repaint();
}
private void RebuildCachedData(VerticalActivitySlice[] bundle)
{
if (bundle == null || bundle.Length == 0)
return;
bool doUpdate = false;
for (int i = 0; i < bundle.Length; i++) {
VerticalActivitySlice slice = bundle[i];
if (slice == null || slice.debugLogs == null)
continue;
//--------------- Remove if already present --------------------
int doubleIdx = cachedCallsData.FindIndex(item => item.frameNumber == slice.header.frameNumber);
if (doubleIdx != -1)
cachedCallsData.RemoveAt(doubleIdx);
//--------------- Remove if already present --------------------
//--------------- Add new! --------------------
if (slice.debugLogs.calls.Length > 0) {
int jMax = slice.debugLogs.calls.Length;
string[] niceTimeStamps = new string[jMax];
for (int j = 0; j < jMax; j++)
niceTimeStamps[j] = vBugEnvironment.ToUnixDateTime(slice.debugLogs.calls[j].unixTimeStamp).ToString("yyyy-MM-dd HH:mm:ss:fff");
string niceFrameNumber = vBugEnvironment.GetNiceFrameNumber(slice.header.frameNumber);
cachedCallsData.Add(new CallCachdeData() {
calls = slice.debugLogs.calls,
frameNumber = slice.header.frameNumber,
niceFrameNumber = niceFrameNumber,
niceTimeStamp = niceTimeStamps
});
doUpdate = true;
}
//--------------- Add new! --------------------
}
//--------------- Sort & Update position --------------------
if (doUpdate) {
cachedCallsData.Sort((a, b) => a.frameNumber.CompareTo(b.frameNumber));
int totalHeight = 0;
foreach (CallCachdeData call in cachedCallsData) {
int newHeight = call.calls.Length * ElementHeight;
call.height = newHeight;
call.y = totalHeight;
totalHeight += newHeight;
}
}
//--------------- Sort & Update position --------------------
}
public override void DrawQuads(Transform parent, Vector3 localScale, VerticalActivitySlice slice)
{
if(slice == null)
return;
if (isDirty || screenCaptureFrameNr != slice.header.frameNumber || quads.Count == 0)
{
if (slice.screenCapture != null && slice.screenCapture.camRenders != null && slice.screenCapture.camRenders.Length != 0)
{
isDirty = false;
screenCaptureFrameNr = slice.header.frameNumber;
DisposeTextures();
int iMax = slice.screenCapture.camRenders.Length;
if (quads.Count > iMax)
{
int i = quads.Count;
while (--i > iMax - 1)
{
UnityEngine.Object.DestroyImmediate(quads[i]);
quads.RemoveAt(i);
}
}
else if (quads.Count < iMax)
{
for (int i = quads.Count; i < iMax; i++)
{
GameObject quad = CreateQuad();
Transform qTransform = quad.transform;
qTransform.parent = parent;
qTransform.localPosition = Vector3.zero;
qTransform.localRotation = Quaternion.identity;
quads.Add(quad);
}
}
for (int i = 0; i < iMax; i++)
{
ScreenCaptureSnapshot screenShot = slice.screenCapture;
Texture2D texture = TextureHelper.SetBytes(screenShot.camRenders[i], showAlpha && i != 0, PlayerSettings.colorSpace == ColorSpace.Linear);
textures.Add(texture);
Rect rect = screenShot.camRects[i];
GameObject quad = quads[i];
Renderer renderer = quad.GetComponent<Renderer>();
if (renderer != null)
renderer.sharedMaterial.SetTexture("_MainTex", texture);
Vector2 size = Vector3.Scale(localScale, new Vector2(rect.width, rect.height));
Vector2 screenPos = new Vector2(-localScale.x, -localScale.y) / 2f; //Center == Left bottom corner
screenPos += (size / 2f); //makes it fullscreen if size = 1x1;
screenPos += new Vector2( //Adds the offset of the camRect accordingly
rect.x * localScale.x,
rect.y * localScale.y
);
quad.transform.localScale = size;
quad.transform.localPosition = screenPos;
string name = screenShot.camNames[i];
if (camNames.Contains(name))
quad.SetActive(camStates[camNames.IndexOf(name)]);
}
}
}
}
protected virtual string CollectHoverData(VerticalActivitySlice slice)
{
throw new NotImplementedException();
}
protected virtual float[] GetSliceGraphData(VerticalActivitySlice slice)
{
throw new NotImplementedException();
}
private int FindScrollPosByID(ExposedGameObject[] gameObjects, VerticalActivitySlice slice, int instanceID, int currentScrollPos, ref ExposedGameObject selectedGO)
{
if (gameObjects == null || instanceID == -1) {
selectedGO = null;
return -1;
}
//--------------- Scan children second --------------------
int offset = 0;
int increment = 16;
foreach (ExposedGameObject obj in gameObjects) {
if (obj.transformID == instanceID) {
selectedGO = obj;
return currentScrollPos + offset;
} else {
ExposedGameObject[] children = GetChildren(obj.transformID, slice);
if (children != null && children.Length > 0) {
increment = 18;
int result = FindScrollPosByID(children, slice, instanceID, currentScrollPos + offset + increment, ref selectedGO);
if (result != -1) {
if (hierarchyFoldoutStates.ContainsKey(obj.transformID)) {
hierarchyFoldoutStates[obj.transformID] = true;
} else {
hierarchyFoldoutStates.Add(obj.transformID, true);
}
return result;
}
} else {
increment = 16;
}
}
offset += increment;
}
//--------------- Scan children second --------------------
return -1;
}
private bool ValidateSlice(VerticalActivitySlice slice)
{
if (slice != null && slice.systemInfo != null) {
if (requiresMemoryCapture) {
if (slice.systemInfo.memoryProfiled)
return true;
} else {
return true;
}
}
return false;
}
private void SetCurrentSlice(int frameNumber)
{
currentSlice = null;
int iMin = Mathf.Max(VerticalSliceDatabase.minRange, frameNumber - vBugEditorSettings.PlaybackHierarchySearchRange);
for (int i = frameNumber; i >= iMin; i--) {
currentSlice = VerticalSliceDatabase.GetSlice(i);
if (currentSlice != null && currentSlice.gameObjectsSnapshot != null && currentSlice.gameObjectsSnapshot.gameObjects != null) {
currentSelection = null;
break;
}
}
}
private void UpdateCameraSettings(Transform quadParent, VerticalActivitySlice slice, Vector2 localScale)
{
if (slice == null || slice.screenCapture == null || cam == null)
return;
ScreenCaptureSnapshot sc = slice.screenCapture;
Vector3 rotation = Vector3.zero;
cam.fieldOfView = 70f;
switch (rotationMode) {
case PlaybackScreenRotationMode.none:
cam.orthographic = true;
cam.orthographicSize = (localScale.y / 2f) + 0.01f; //(Mathf.Min(localScale.x, localScale.y) / 2f) + 0.01f;
break;
case PlaybackScreenRotationMode.posMainCam:
cam.orthographic = false;
rotation = sc.mainCamWorldRotation;
break;
case PlaybackScreenRotationMode.negMainCam:
cam.orthographic = false;
rotation = -(Vector3)sc.mainCamWorldRotation;
break;
case PlaybackScreenRotationMode.posAcceleration:
cam.orthographic = false;
rotation = sc.inputAcceleration;
break;
case PlaybackScreenRotationMode.negAcceleration:
cam.orthographic = false;
rotation = -(Vector3)sc.inputAcceleration;
break;
}
if (rotationZOnly)
rotation.x = rotation.y = 0f;
quadParent.eulerAngles = rotation;
}
public static void NotifyVerticalSliceBundleLoaded(VerticalActivitySlice[] slices)
{
if (EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode)
return;
foreach (vBugBaseWindow window in vBugBaseWindow.GetAllWindows())
window.NotifyVerticalSliceBundleLoaded(slices);
}
public virtual void DrawQuads(Transform parent, Vector3 localScale, VerticalActivitySlice slice)
{
throw new NotImplementedException();
}
public ExposedGameObject[] GetRootObjects(VerticalActivitySlice slice)
{
if (slice == null || slice.gameObjectsSnapshot == null || slice.gameObjectsSnapshot.gameObjects == null)
return null;
if (rootGOs.ContainsKey(slice.header.frameNumber)) {
return rootGOs[slice.header.frameNumber];
} else {
ExposedGameObject[] allGameObjects = slice.gameObjectsSnapshot.gameObjects;
List<ExposedGameObject> result = new List<ExposedGameObject>();
int i = allGameObjects.Length;
while (--i > -1) {
if (allGameObjects[i].parentID == -1)
result.Add(allGameObjects[i]);
}
ExposedGameObject[] resultArray = result.ToArray();
SortReflectedObjectsByName(resultArray);
rootGOs.Add(slice.header.frameNumber, resultArray);
return resultArray;
}
}
public void Dispose()
{
if (slice != null)
slice.Dispose();
slice = null;
path = null;
}
public void Prune()
{
if (slice != null)
slice.Dispose();
slice = null;
state = State.idle;
requestTimeStamp = 0;
}
