External mainloop stride

build/compile-windows-runtime.bat

@@ -0,0 +1 @@
+msbuild Stride.build /t:Package /m /v:m /restore /nr:false /p:StridePlatforms="Windows" /p:StrideGraphicsApiDependentBuildAll=false /p:StrideBuildPrerequisitesInstaller=false /p:StrideSign=false /p:StrideOfficialBuild=false

sources/assets/Stride.Core.Assets/Compiler/AssetCompilerRegistry.cs

@@ -181,27 +181,34 @@ private void RegisterAssembly(Assembly assembly)
         private void RegisterCompilersFromAssembly(Assembly assembly)
         {
             // Process Asset types.
-            foreach (var type in assembly.GetTypes())
+            try
             {
-                // Only process Asset types
-                if (!typeof(IAssetCompiler).IsAssignableFrom(type) || !type.IsClass)
-                    continue;
+                foreach (var type in assembly.GetTypes())
+                {
+                    // Only process Asset types
+                    if (!typeof(IAssetCompiler).IsAssignableFrom(type) || !type.IsClass)
+                        continue;
 
-                // Asset compiler
-                var compilerAttribute = type.GetCustomAttribute<AssetCompilerAttribute>();
+                    // Asset compiler
+                    var compilerAttribute = type.GetCustomAttribute<AssetCompilerAttribute>();
 
-                if (compilerAttribute == null) // no compiler attribute in this asset
-                    continue;
+                    if (compilerAttribute == null) // no compiler attribute in this asset
+                        continue;
 
-                try
-                {
-                    ProcessAttribute(compilerAttribute, type);
-                }
-                catch (Exception ex)
-                {
-                    log.Error($"Unable to instantiate compiler [{compilerAttribute.TypeName}]", ex);
+                    try
+                    {
+                        ProcessAttribute(compilerAttribute, type);
+                    }
+                    catch (Exception ex)
+                    {
+                        log.Error($"Unable to instantiate compiler [{compilerAttribute.TypeName}]", ex);
+                    }
                 }
             }
+            catch (Exception e)
+            {
+                log.Warning($"Unable to register asset compilers from assembly [{assembly}]", e);
+            }
         }
 
         private void UnregisterAssembly(Assembly assembly)

sources/core/Stride.Core.Mathematics/RectangleF.cs

@@ -269,7 +269,7 @@ public void Inflate(float horizontalAmount, float verticalAmount)
         /// <param name="result">[OutAttribute] true if the specified Point is contained within this rectangle; false otherwise.</param>
         public void Contains(ref Vector2 value, out bool result)
         {
-            result = (X <= value.X) && (value.X < Right) && (Y <= value.Y) && (value.Y < Bottom);
+            result = value.X >= this.X && value.X <= Right && value.Y >= this.Y && value.Y <= Bottom;
         }
 
         /// <summary>Determines whether this rectangle entirely contains a specified rectangle.</summary>
@@ -295,7 +295,7 @@ public void Contains(ref RectangleF value, out bool result)
         /// <returns><c>true</c> if point is inside <see cref="RectangleF"/>, otherwise <c>false</c>.</returns>
         public bool Contains(float x, float y)
         {
-            return (x >= this.X && x <= Right && y >= this.Y && y <= Bottom);
+            return x >= this.X && x <= Right && y >= this.Y && y <= Bottom;
         }
 
         /// <summary>

sources/core/Stride.Core.Serialization/Serialization/Contents/ContentManager.cs

@@ -324,6 +324,25 @@ public ContentManagerStats GetStats()
             return new ContentManagerStats(LoadedAssetUrls.Values);
         }
 
+        /// <summary>
+        /// Request the ref counts for a specific asset url.
+        /// </summary>
+        public void GetReferenceCounts(string url, out bool exists, out int publicRefCount, out int privateRefCount)
+        {
+            if (LoadedAssetUrls.TryGetValue(url, out var reference))
+            {
+                exists = true;
+                publicRefCount = reference.PublicReferenceCount;
+                privateRefCount = reference.PrivateReferenceCount;
+            }
+            else
+            {
+                exists = false;
+                publicRefCount = 0;
+                privateRefCount = 0;
+            }
+        }
+
         private void PrepareSerializerContext(ContentSerializerContext contentSerializerContext, SerializerContext context)
         {
             context.Set(ContentSerializerContext.ContentSerializerContextProperty, contentSerializerContext);

sources/engine/Stride.Assets.Models/Stride.Assets.Models.csproj

@@ -14,6 +14,8 @@
     </Compile>
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\tools\Stride.Assimp\Stride.Assimp.csproj" PrivateAssets="All" />
+    <ProjectReference Include="..\..\tools\Stride.Assimp.Translation\Stride.Assimp.Translation.vcxproj" PrivateAssets="All" />
     <ProjectReference Include="..\..\tools\Stride.Importer.Assimp\Stride.Importer.Assimp.vcxproj" PrivateAssets="All" />
     <ProjectReference Include="..\..\tools\Stride.Importer.Common\Stride.Importer.Common.vcxproj" PrivateAssets="All" />
     <ProjectReference Include="..\..\tools\Stride.Importer.FBX\Stride.Importer.FBX.vcxproj" PrivateAssets="All" />

sources/engine/Stride.Engine.NoAssets.Tests/GameWindowTest.cs

@@ -21,11 +21,12 @@ public void RenderToWindow(AppContextType contextType)
             PerformTest(game =>
             {
                 var context = GameContextFactory.NewGameContext(contextType, isUserManagingRun: true);
-                var windowRenderer = new GameWindowRenderer(game.Services, context)
-                {
-                    PreferredBackBufferWidth = 640,
-                    PreferredBackBufferHeight = 480,
-                };
+
+                var windowRenderer = new GameWindowRenderer(game.Services, context);
+
+                windowRenderer.WindowManager.PreferredBackBufferWidth = 640;
+                windowRenderer.WindowManager.PreferredBackBufferHeight = 640;
+
                 windowRenderer.Initialize();
                 ((IContentable)windowRenderer).LoadContent();
 

sources/engine/Stride.Engine/Engine/ModelComponent.cs

@@ -294,7 +294,19 @@ internal void Update(TransformComponent transformComponent)
                 else
                 {
                     // If there is a skeleton, use the corresponding node's transform. Otherwise, fall back to the model transform.
-                    var transform = skeleton != null ? skeleton.NodeTransformations[mesh.NodeIndex].WorldMatrix : worldMatrix;
+                    var transform = worldMatrix;
+                    if (skeleton != null && skeleton.NodeTransformations != null)
+                    {
+                        var nodeTransformationsCount = skeleton.NodeTransformations.Length;
+
+                        if (nodeTransformationsCount > 0)
+                        {
+                            var nodeIndex = mesh.NodeIndex;
+                            if (nodeIndex >= 0 && nodeIndex < nodeTransformationsCount)
+                                transform = skeleton.NodeTransformations[nodeIndex].WorldMatrix; 
+                        }
+                    }
+
                     BoundingBox.Transform(ref mesh.BoundingBox, ref transform, out meshInfo.BoundingBox);
                     BoundingSphere.Transform(ref mesh.BoundingSphere, ref transform, out meshInfo.BoundingSphere);
                 }

sources/engine/Stride.Engine/Profiling/GameProfilingSystem.cs

@@ -49,7 +49,7 @@ public class GameProfilingSystem : GameSystemBase
 
         private Color4 textColor = Color.LightGreen;
 
-        private PresentInterval userPresentInterval = PresentInterval.Default;
+        private Dictionary<GraphicsPresenter, PresentInterval> userPresentInterval = new Dictionary<GraphicsPresenter, PresentInterval>();
         private bool userMinimizedState = true;
 
         private int lastFrame = -1;
@@ -61,7 +61,15 @@ public class GameProfilingSystem : GameSystemBase
         private uint trianglesCount;
         private uint drawCallsCount;
 
-        private struct ProfilingResult : IComparer<ProfilingResult>
+        /// <summary>
+        /// Gets or sets the current render target. If null, the <see cref="Game.GraphicsDevice.Presenter.BackBuffer"/> is used.
+        /// </summary>
+        /// <value>
+        /// The render target.
+        /// </value>
+        public Texture RenderTarget { get; set; }
+
+        public struct ProfilingResult : IComparer<ProfilingResult>
         {
             public long AccumulatedTime;
             public long MinTime;
@@ -84,6 +92,8 @@ public int Compare(ProfilingResult x, ProfilingResult y)
         private readonly List<ProfilingResult> profilingResults = new List<ProfilingResult>();
         private readonly Dictionary<ProfilingKey, ProfilingResult> profilingResultsDictionary = new Dictionary<ProfilingKey, ProfilingResult>();
 
+        public IReadOnlyList<ProfilingResult> ProfilingResults { get => profilingResults; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GameProfilingSystem"/> class.
         /// </summary>
@@ -243,7 +253,6 @@ private void UpdateProfilingStrings()
                 {
                     AppendEvent(profilingResults[((int)CurrentResultPage - 1) * elementsPerPage + i], elapsedFrames, tickFrequency, containsMarks);
                 }
-                profilingResults.Clear();
 
                 if (numberOfPages > 1)
                     profilersStringBuilder.AppendFormat("PAGE {0} OF {1}", CurrentResultPage, numberOfPages);
@@ -343,6 +352,9 @@ protected override void Destroy()
         /// <inheritdoc/>
         public override void Draw(GameTime gameTime)
         {
+            // Where to render the result?
+            var renderTarget = RenderTarget ?? Game.GraphicsDevice.Presenter.BackBuffer;
+
             // copy those values before fast text render not to influence the game stats
             drawCallsCount = GraphicsDevice.FrameDrawCalls;
             trianglesCount = GraphicsDevice.FrameTriangleCount;
@@ -351,7 +363,7 @@ public override void Draw(GameTime gameTime)
             {
                 dumpTiming.Restart();
 
-                renderTargetSize = new Size2(Game.GraphicsContext.CommandList.RenderTarget.Width, Game.GraphicsContext.CommandList.RenderTarget.Height);
+                renderTargetSize = new Size2(renderTarget.Width, renderTarget.Height);
 
                 if (stringBuilderTask == null || stringBuilderTask.IsCompleted)
                 {
@@ -360,7 +372,6 @@ public override void Draw(GameTime gameTime)
                 }
             }
 
-            viewportHeight = Game.GraphicsContext.CommandList.Viewport.Height;
 
             if (fastTextRenderer == null)
             {
@@ -372,7 +383,9 @@ public override void Draw(GameTime gameTime)
             }
 
             // TODO GRAPHICS REFACTOR where to get command list from?
-            Game.GraphicsContext.CommandList.SetRenderTargetAndViewport(null, Game.GraphicsDevice.Presenter.BackBuffer);
+            var commandList = Game.GraphicsContext.CommandList;
+            commandList.SetRenderTargetAndViewport(null, renderTarget);
+            viewportHeight = commandList.Viewport.Height;
             fastTextRenderer.Begin(Game.GraphicsContext);
             lock (stringLock)
             {
@@ -419,11 +432,18 @@ public void EnableProfiling(bool excludeKeys = false, params ProfilingKey[] keys
             }
 
             // Backup current PresentInterval state
-            userPresentInterval = GraphicsDevice.Presenter.PresentInterval;
+            userPresentInterval[GraphicsDevice.Presenter] = GraphicsDevice.Presenter.PresentInterval;
 
             // Disable VSync (otherwise GPU results might be incorrect)
             GraphicsDevice.Presenter.PresentInterval = PresentInterval.Immediate;
 
+            foreach (var wp in GraphicsDevice.WindowPresenters)
+            {
+                userPresentInterval[wp] = wp.PresentInterval;
+                wp.PresentInterval = PresentInterval.Immediate;
+            }
+
+
             if (keys.Length == 0)
             {
                 Profiler.EnableAll();
@@ -458,9 +478,21 @@ public void DisableProfiling()
             Enabled = false;
             Visible = false;
 
-            // Restore previous PresentInterval state
-            GraphicsDevice.Presenter.PresentInterval = userPresentInterval;
-            userPresentInterval = PresentInterval.Default;
+            if (userPresentInterval.TryGetValue(GraphicsDevice.Presenter, out var presentInterval))
+            {
+                GraphicsDevice.Presenter.PresentInterval = presentInterval;
+            }
+
+            foreach (var wp in GraphicsDevice.WindowPresenters)
+            {
+                if (userPresentInterval.TryGetValue(wp, out presentInterval))
+                {
+                    wp.PresentInterval = presentInterval;
+                }
+            }
+
+            userPresentInterval.Clear();
+
             if (Game != null)
                 Game.TreatNotFocusedLikeMinimized = userMinimizedState;
 

sources/engine/Stride.Engine/Rendering/Compositing/ForwardRenderer.cs

@@ -797,7 +797,13 @@ private Texture ResolveDepthAsSRV(RenderDrawContext context)
 
             context.CommandList.SetRenderTargets(null, context.CommandList.RenderTargetCount, context.CommandList.RenderTargets);
 
-            depthStencilROCached = context.Resolver.GetDepthStencilAsRenderTarget(depthStencil, depthStencilROCached);
+            var depthStencilROCached = context.Resolver.GetDepthStencilAsRenderTarget(depthStencil, this.depthStencilROCached);
+            if (depthStencilROCached != this.depthStencilROCached)
+            {
+                // Dispose cached view
+                this.depthStencilROCached?.Dispose();
+                this.depthStencilROCached = depthStencilROCached;
+            }
             context.CommandList.SetRenderTargets(depthStencilROCached, context.CommandList.RenderTargetCount, context.CommandList.RenderTargets);
 
             return depthStencilSRV;
@@ -876,6 +882,7 @@ protected virtual void PrepareRenderTargets(RenderDrawContext drawContext, Size2
         protected override void Destroy()
         {
             PostEffects?.Dispose();
+            depthStencilROCached?.Dispose();
         }
 
         [StructLayout(LayoutKind.Sequential)]

sources/engine/Stride.Engine/Rendering/ModelRenderProcessor.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Stride contributors (https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using Stride.Core;
 using Stride.Core.Extensions;
@@ -108,7 +109,7 @@ private void UpdateRenderModel(ModelComponent modelComponent, RenderModel render
                         // Copy world matrix
                         var mesh = renderModel.Model.Meshes[sourceMeshIndex];
                         var meshInfo = modelComponent.MeshInfos[sourceMeshIndex];
-                        var nodeIndex = mesh.NodeIndex;
+                        var nodeIndex = Math.Min(mesh.NodeIndex, nodeTransformations.Length - 1);
                         renderMesh.World = nodeTransformations[nodeIndex].WorldMatrix;
                         renderMesh.IsScalingNegative = nodeTransformations[nodeIndex].IsScalingNegative;
                         renderMesh.BoundingBox = new BoundingBoxExt(meshInfo.BoundingBox);

sources/engine/Stride.Games/GameBase.cs

@@ -75,9 +75,10 @@ protected GameBase()
             DrawTime = new GameTime();
             autoTickTimer = new TimerTick();
             IsFixedTimeStep = false;
-            maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
+            maximumElapsedTime = TimeSpan.FromMilliseconds(2000.0);
             TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz
-
+            TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz
+
             TreatNotFocusedLikeMinimized = true;
             WindowMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromSeconds(0d));
             MinimizedMinimumUpdateRate = new ThreadThrottler(15); // by default 15 updates per second while minimized
@@ -269,6 +270,17 @@ public bool IsMouseVisible
         /// <value>The target elapsed time.</value>
         public TimeSpan TargetElapsedTime { get; set; }
 
+        /// <summary>
+        /// Gets or sets the value indicating whether the user provides the elapsed time increment for the time calculation.
+        /// </summary>
+        public bool IsUserManagingTime { get; set; }
+
+        /// <summary>
+        /// Gets or sets the elapsed time, for the next tick/update if called from external code. Should be set just before calling the RunCallback.
+        /// Default is 1/60s, i.e. 60fps
+        /// </summary>
+        public TimeSpan ElapsedUserTime { get; set; }
+
         /// <summary>
         /// Access to the throttler used to set the minimum time allowed between each updates.
         /// </summary>
@@ -504,10 +516,19 @@ protected virtual void RawTickProducer()
         {
             try
             {
-                // Update the timer
-                autoTickTimer.Tick();
+                TimeSpan elapsedAdjustedTime;
 
-                var elapsedAdjustedTime = autoTickTimer.ElapsedTimeWithPause;
+                if (IsUserManagingTime)
+                {
+                    // Use user provided time
+                    elapsedAdjustedTime = ElapsedUserTime;
+                }
+                else
+                {
+                    // Update the timer
+                    autoTickTimer.Tick();
+                    elapsedAdjustedTime = autoTickTimer.ElapsedTimeWithPause;
+                }
 
                 if (forceElapsedTimeToZero)
                 {