Feature/interactivity

Assets/Resources/depthShader.shader

@@ -0,0 +1,75 @@
+
+Shader "InterDigital/depthShader" {
+	Properties
+	{
+
+	}
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" }
+
+		Pass
+		{
+
+			CGPROGRAM
+			// to use the built-in helper functions
+			#include "UnityCG.cginc"
+			// use "vert" function as the vertex shader
+			#pragma vertex vert
+			// use "frag" function as the pixel (fragment) shader
+			#pragma fragment frag
+
+			#pragma target 3.0
+
+			// vertex shader inputs
+			struct vertIn
+			{
+				float4 vertex : POSITION; // vertex position
+			};
+
+			// vertex shader outputs
+			struct vertOut
+			{
+				float depth       : TEXCOORD0;   // linear depth
+				float4 projPos    : SV_POSITION; // clip space position
+			};
+
+			// fragment shader outputs
+			struct fragOut
+			{
+				float4 color : SV_Target;
+			};
+
+
+			// vertex shader
+			vertOut vert(vertIn v)
+			{
+				vertOut o;
+
+				// computes the linear depth
+				o.depth = COMPUTE_DEPTH_01;
+
+				// calculates the clip space position
+				o.projPos = UnityObjectToClipPos(v.vertex.xyz);
+
+				return o;
+
+			}
+
+
+			// fragment shader
+			fragOut frag(vertOut i)
+			{
+				fragOut o;
+
+				// outputs the linear depth
+				o.color = float4(i.depth, 0.0, 0.0, 0.0);
+
+				return o;
+
+			}
+			ENDCG
+		}
+	}
+	Fallback off
+}

Assets/Resources/visibilityComputationShader.shader

@@ -0,0 +1,114 @@
+
+Shader "InterDigital/visibilityComputationShader"
+{
+	Properties
+	{
+
+	}
+
+	SubShader
+	{
+		Tags { "RenderType" = "Opaque" }
+
+		// visibility computation
+		Pass
+		{
+			CGPROGRAM
+			// to use the built-in helper functions
+			#include "UnityCG.cginc"
+			// use "vert" function as the vertex shader
+			#pragma vertex vert
+			// use "frag" function as the pixel (fragment) shader
+			#pragma fragment frag
+
+			#pragma target 4.5
+
+			// vertex shader inputs
+			struct vertIn
+			{
+				float4 vertex : POSITION; // vertex position
+			};
+
+			// vertex shader outputs
+			struct vertOut
+			{
+				float3 worldPos : TEXCOORD0; // world position
+				float4 projPos  : SV_POSITION; // clip space position
+			};
+
+			// fragment shader outputs
+			struct fragOut
+			{
+				float4 color : SV_Target;
+			};
+
+
+			// vertex shader
+			vertOut vert(vertIn v)
+			{
+				vertOut o;
+
+				o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
+
+				// calculates the clip space position
+				o.projPos = UnityObjectToClipPos(v.vertex.xyz);
+
+				return o;
+
+			}
+
+			sampler2D sceneDepthTexture;
+			RWStructuredBuffer<int> visiblePixelsBuffer : register(u1); // size = 2: (maxVisible, visible) pixels
+			float4x4 worldToViewMatrix;
+			float4x4 worldToScreenMatrix;
+			float visibilityBias;
+			float cameraZFar;
+
+			// fragment shader
+			fragOut frag(vertOut i)
+			{
+				fragOut o;
+
+				// add a visible pixel to the maxVisiblePixels counter
+				InterlockedAdd(visiblePixelsBuffer[0], 1);
+
+				//
+				// check if the pixel is occluded
+				//
+
+				// retrieve the pixel world coordinates
+				float4 worldPosition = float4(i.worldPos, 1.0f);
+
+				// calculates the input world position in the camera screen space
+				float4 screenPosition = mul(worldToScreenMatrix, worldPosition);
+				screenPosition /= screenPosition.w;
+
+				// retrieves the normalized linear eye depth information stored in the camera depth map
+				float4 cameraDepthwMapTextureCoords = float4((screenPosition.xy + 1.0) / 2.0, 0.0f, 0.0f);
+				float eyeCameraDepth = tex2D(sceneDepthTexture, cameraDepthwMapTextureCoords).x;
+				eyeCameraDepth *= cameraZFar;
+
+				// calculates the input world position in the camera eye space
+				float4 cameraEyePosition = mul(worldToViewMatrix, worldPosition);
+				cameraEyePosition.xyz /= cameraEyePosition.w;
+
+				// checks if the pixel world position is not occluded. The cameraEyePosition.z < 0
+				if (cameraEyePosition.z > (-eyeCameraDepth - visibilityBias))
+				{
+					// is visible
+					InterlockedAdd(visiblePixelsBuffer[1], 1);
+				}
+
+
+				// outputs a red color
+				o.color = float4(1.0, 0.0, 0.0, 1.0);
+
+				return o;
+
+			}
+			ENDCG
+		}
+
+	}
+	Fallback off
+}

Assets/Scripts/Runtime/MediaPlayer.cs

@@ -277,7 +277,7 @@ public static MediaPlayer Create(Media media, MediaPipelineConfig cfg, GameObjec
                 Debug.LogException(e);
                 return null;
             }
-            mp.autoPlay = media.autoPlay;
+            mp.autoPlay = media.autoplay;
             return mp;
         }
 
@@ -392,6 +392,8 @@ public void AddAudioSource(SpatialAudioSource aSrc)
 
         public void Play(TimeInfo t = null, ViewInfo v = null)
         {
+            autoPlay = false;
+
             if (timeInfo == null)
             {
                 timeInfo = new TimeInfo();

Assets/Scripts/Runtime/SceneViewer.cs

@@ -11,6 +11,7 @@
  */
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 
 using UnityEngine;
@@ -41,19 +42,27 @@ public class SceneViewer : MonoBehaviour
         int minFps = int.MaxValue;
         int maxFps = int.MinValue;
 
-        bool autoplay = true;
+        public bool autoplayAnimation = true;
+        bool showLog = false;
 
         int sceneIndex = 0;
         SceneImport? gltf;
         List<MediaPlayer>? mediaPlayers = null;
 
         Bounds bounds;
+        uint maxLogMessages = 15;
+        Queue logQueue = new Queue();
 
         public string GetSourceUriFromCommandLineArgs()
         {
             string[] args = Environment.GetCommandLineArgs();
             for (int i = 0; i < args.Length; i++)
             {
+                if (args[i] == "--log")
+                {
+                    showLog = true;
+                    continue;
+                }
                 int j = i + 1;
                 if (args[i] == "--gltf")
                 {
@@ -94,7 +103,7 @@ public void ConfigureInitialCamera()
             }
 
             bounds = Utils.ComputeSceneBounds();
-            Utils.LookAt(main, bounds, transform.forward);            
+            Utils.LookAt(main, bounds, transform.forward);
         }
 
         public Camera GetMainCamera()
@@ -187,9 +196,16 @@ async void Start()
                 }
 
                 var instantiator = new GameObjectInstantiator(gltf, transform);
+                await gltf.InstantiateSceneAsync(instantiator, sceneIndex);
+                if (autoplayAnimation)
+                {
+                    var legacyAnimation = instantiator.sceneInstance.legacyAnimation;
+                    if (legacyAnimation != null)
+                    {
+                        legacyAnimation.Play();
+                    }
+                }
 
-                await gltf.InstantiateSceneAsync(instantiator, sceneIndex); 
-
                 mediaPlayers = CreateMediaPlayers(gltf, baseUri);
                 CreateVideoTextures(gltf, mediaPlayers);
                 CreateAudioSources(gltf, instantiator, mediaPlayers);
@@ -230,8 +246,23 @@ private void disposeMemoryRecorder()
             memoryUsageRecording = false;
         }
 
+        void HandleLog(string logString, string stackTrace, LogType type)
+        {
+            logQueue.Enqueue("[" + type + "] : " + logString);
+            if (type == LogType.Exception)
+                logQueue.Enqueue(stackTrace);
+            while (logQueue.Count > maxLogMessages)
+                logQueue.Dequeue();
+        }
+
+        void OnEnable()
+        {
+            Application.logMessageReceived += HandleLog;
+        }
+
         private void OnDisable()
         {
+            Application.logMessageReceived -= HandleLog;
             disposeMemoryRecorder();
         }
 
@@ -266,20 +297,31 @@ void Update()
                     disposeMemoryRecorder();
             }
 
-            if (autoplay && (mediaPlayers != null))
+            if (mediaPlayers != null)
             {
                 foreach (var mp in mediaPlayers)
                 {
-                    mp.Play();
+                    if (mp.autoPlay)
+                    {
+                        mp.Play();
+                    }
                 }
-                autoplay = false;
             }
 
             if (Input.GetKeyDown(KeyCode.Tab))
             {
                 ConfigureInitialCamera();
             }
 
+            if (Input.GetKeyDown(KeyCode.L))
+            {
+                if(showLog){
+                    showLog = false;
+                } else {
+                    showLog = true;
+                }
+            }
+
         }
 
         private void OnDrawGizmos()
@@ -306,6 +348,13 @@ void OnGUI()
         {
             if (memoryUsageRecorder)
                 GUI.TextArea(new Rect(10, 30, 250, 50), statsText);
+
+            if (showLog)
+            {
+                GUILayout.BeginArea(new Rect(0, 0, Screen.width, Screen.height));
+                GUILayout.Label("\n" + string.Join("\n", logQueue.ToArray()));
+                GUILayout.EndArea();
+            }
         }
 
     }

Packages/manifest.json

@@ -1,19 +1,20 @@
 {
   "dependencies": {
-    "com.unity.collab-proxy": "1.17.2",
+    "com.unity.ai.navigation": "1.1.5",
+    "com.unity.collab-proxy": "2.2.0",
     "com.unity.feature.development": "1.0.1",
-    "com.unity.ide.rider": "3.0.15",
-    "com.unity.ide.visualstudio": "2.0.16",
+    "com.unity.ide.rider": "3.0.26",
+    "com.unity.ide.visualstudio": "2.0.22",
     "com.unity.ide.vscode": "1.2.5",
-    "com.unity.memoryprofiler": "0.7.1-preview.1",
-    "com.unity.test-framework": "1.1.31",
+    "com.unity.memoryprofiler": "1.1.0",
+    "com.unity.test-framework": "1.1.33",
     "com.unity.textmeshpro": "3.0.6",
-    "com.unity.timeline": "1.6.4",
+    "com.unity.timeline": "1.7.6",
     "com.unity.toolchain.win-x86_64-linux-x86_64": "2.0.5",
     "com.unity.ugui": "1.0.0",
-    "com.unity.visualscripting": "1.7.8",
+    "com.unity.visualscripting": "1.9.1",
     "com.unity.xr.management": "4.4.0",
-    "com.unity.xr.openxr": "1.4.2",
+    "com.unity.xr.openxr": "1.9.1",
     "com.unity.modules.ai": "1.0.0",
     "com.unity.modules.androidjni": "1.0.0",
     "com.unity.modules.animation": "1.0.0",