Upgrade to Unity 2019

Author: Looooong

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.0]
+
+### Breaking changes
+
+- Upgraded to Unity 2019. Dropped support for Unity 2018.
+- Removed `dynamicBatching` from Render Pipeline Asset. Configure dynamic batching in `Project Settings/Player/Others Settings` instead.
+
 ## [0.0.1]
 
 ### Added

Runtime/SRP/VXGIRenderPipeline.cs

@@ -1,19 +1,11 @@
 using System.Collections.ObjectModel;
 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 
 public class VXGIRenderPipeline : RenderPipeline {
-  public static bool isD3D11Supported {
-    get { return _D3D11DeviceType.Contains(SystemInfo.graphicsDeviceType); }
-  }
+  public static bool isD3D11Supported => _D3D11DeviceType.Contains(SystemInfo.graphicsDeviceType);
 
-  public DrawRendererFlags drawRendererFlags {
-    get { return _drawRendererFlags; }
-  }
-  public RendererConfiguration rendererConfiguration {
-    get { return _rendererConfiguration; }
-  }
+  public PerObjectData PerObjectData { get; }
 
   static readonly ReadOnlyCollection<GraphicsDeviceType> _D3D11DeviceType = new ReadOnlyCollection<GraphicsDeviceType>(new[] {
     GraphicsDeviceType.Direct3D11,
@@ -23,10 +15,8 @@ public RendererConfiguration rendererConfiguration {
   });
 
   CommandBuffer _command;
-  CullResults _cullResults;
-  DrawRendererFlags _drawRendererFlags;
-  FilterRenderersSettings _filterSettings;
-  RendererConfiguration _rendererConfiguration;
+  FilteringSettings _filteringSettings;
+  ScriptableCullingParameters _cullingParameters;
   VXGIRenderer _renderer;
 
   public static void TriggerCameraCallback(Camera camera, string message, Camera.CameraCallback callback) {
@@ -37,63 +27,53 @@ public static void TriggerCameraCallback(Camera camera, string message, Camera.C
   public VXGIRenderPipeline(VXGIRenderPipelineAsset asset) {
     _renderer = new VXGIRenderer(this);
     _command = new CommandBuffer() { name = "VXGI.RenderPipeline" };
-    _filterSettings = new FilterRenderersSettings(true) { renderQueueRange = RenderQueueRange.opaque };
-
-    _drawRendererFlags = DrawRendererFlags.None;
-    if (asset.dynamicBatching) _drawRendererFlags |= DrawRendererFlags.EnableDynamicBatching;
-
-    _rendererConfiguration = RendererConfiguration.None;
-
-    if (asset.environmentLighting) _rendererConfiguration |= RendererConfiguration.PerObjectLightProbe;
-    if (asset.environmentReflections) _rendererConfiguration |= RendererConfiguration.PerObjectReflectionProbes;
+    _filteringSettings = FilteringSettings.defaultValue;
 
+    PerObjectData = asset.perObjectData;
     Shader.globalRenderPipeline = "VXGI";
-
     GraphicsSettings.lightsUseLinearIntensity = true;
     GraphicsSettings.useScriptableRenderPipelineBatching = asset.SRPBatching;
   }
 
-  public override void Dispose() {
-    base.Dispose();
+  protected override void Dispose(bool disposing) {
+    base.Dispose(disposing);
 
     _command.Dispose();
 
     Shader.globalRenderPipeline = string.Empty;
   }
 
-  public override void Render(ScriptableRenderContext renderContext, Camera[] cameras) {
-    base.Render(renderContext, cameras);
-    BeginFrameRendering(cameras);
+  protected override void Render(ScriptableRenderContext renderContext, Camera[] cameras) {
+    var mainCamera = Camera.main;
 
-    foreach (var camera in cameras) {
-      BeginCameraRendering(camera);
+    BeginFrameRendering(renderContext, cameras);
 
-      var vxgi = camera.GetComponent<VXGI>();
+    foreach (var camera in cameras) {
+      BeginCameraRendering(renderContext, camera);
 
-      if (vxgi != null && vxgi.isActiveAndEnabled) {
+      if (camera.TryGetComponent<VXGI>(out var vxgi) && vxgi.isActiveAndEnabled) {
         vxgi.Render(renderContext, _renderer);
       } else {
-        bool rendered = false;
-
 #if UNITY_EDITOR
         if (camera.cameraType == CameraType.SceneView) {
           ScriptableRenderContext.EmitWorldGeometryForSceneView(camera);
         }
 
-        if (Camera.main != null) {
-          vxgi = Camera.main.GetComponent<VXGI>();
-
-          if (vxgi != null && vxgi.isActiveAndEnabled) {
-            vxgi.Render(renderContext, camera, _renderer);
-            rendered = true;
-          }
+        if (mainCamera != null && mainCamera.TryGetComponent<VXGI>(out vxgi) && vxgi.isActiveAndEnabled) {
+          vxgi.Render(renderContext, camera, _renderer);
+        } else {
+          RenderFallback(renderContext, camera);
         }
+#else
+        RenderFallback(renderContext, camera);
 #endif
-
-        if (!rendered) RenderFallback(renderContext, camera);
       }
+
+      EndCameraRendering(renderContext, camera);
     }
 
+    EndFrameRendering(renderContext, cameras);
+
     renderContext.Submit();
   }
 
@@ -106,20 +86,19 @@ void RenderFallback(ScriptableRenderContext renderContext, Camera camera) {
 
     TriggerCameraCallback(camera, "OnPreCull", Camera.onPreCull);
 
-    ScriptableCullingParameters cullingParams;
-    if (!CullResults.GetCullingParameters(camera, out cullingParams)) return;
-    CullResults.Cull(ref cullingParams, renderContext, ref _cullResults);
+    if (!camera.TryGetCullingParameters(out _cullingParameters)) return;
 
-    var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("ForwardBase"));
-    drawSettings.SetShaderPassName(1, new ShaderPassName("PrepassBase"));
-    drawSettings.SetShaderPassName(2, new ShaderPassName("Always"));
-    drawSettings.SetShaderPassName(3, new ShaderPassName("Vertex"));
-    drawSettings.SetShaderPassName(4, new ShaderPassName("VertexLMRGBM"));
-    drawSettings.SetShaderPassName(5, new ShaderPassName("VertexLM"));
-    drawSettings.flags = _drawRendererFlags;
+    var cullingResults = renderContext.Cull(ref _cullingParameters);
+    var drawingSettings = new DrawingSettings { perObjectData = PerObjectData };
+    drawingSettings.SetShaderPassName(0, ShaderTagIDs.Deferred);
+    drawingSettings.SetShaderPassName(1, ShaderTagIDs.PrepassBase);
+    drawingSettings.SetShaderPassName(2, ShaderTagIDs.Always);
+    drawingSettings.SetShaderPassName(3, ShaderTagIDs.Vertex);
+    drawingSettings.SetShaderPassName(4, ShaderTagIDs.VertexLMRGBM);
+    drawingSettings.SetShaderPassName(5, ShaderTagIDs.VertexLM);
 
     renderContext.SetupCameraProperties(camera);
-    renderContext.DrawRenderers(_cullResults.visibleRenderers, ref drawSettings, _filterSettings);
+    renderContext.DrawRenderers(cullingResults, ref drawingSettings, ref _filteringSettings);
     renderContext.DrawSkybox(camera);
 
     TriggerCameraCallback(camera, "OnPostRender", Camera.onPostRender);

Runtime/SRP/VXGIRenderPipelineAsset.cs

@@ -1,28 +1,14 @@
 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering;
 
 [CreateAssetMenu(fileName = "VXGIRenderPipeline.asset", menuName = "Rendering/VXGI Render Pipeline Asset", order = 320)]
 public class VXGIRenderPipelineAsset : RenderPipelineAsset {
-  public bool dynamicBatching;
   public bool SRPBatching;
+  public PerObjectData perObjectData;
 
-  [Header("Lighting Settings")]
-  public bool environmentLighting = true;
-  public bool environmentReflections = true;
+  public override Material defaultMaterial => (Material)Resources.Load("VXGI/Material/Default");
+  public override Material defaultParticleMaterial => (Material)Resources.Load("VXGI/Material/Default-Particle");
+  public override Shader defaultShader => Shader.Find("VXGI/Standard");
 
-  public override Material GetDefaultMaterial() {
-    return (Material)Resources.Load("VXGI/Material/Default");
-  }
-
-  public override Material GetDefaultParticleMaterial() {
-    return (Material)Resources.Load("VXGI/Material/Default-Particle");
-  }
-
-  public override Shader GetDefaultShader() {
-    return Shader.Find("VXGI/Standard");
-  }
-
-  protected override IRenderPipeline InternalCreatePipeline() {
-    return new VXGIRenderPipeline(this);
-  }
+  protected override RenderPipeline CreatePipeline() => new VXGIRenderPipeline(this);
 }

Runtime/SRP/VXGIRenderer.cs

@@ -1,36 +1,31 @@
 using UnityEngine;
-using UnityEngine.Experimental.Rendering;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
 
 public class VXGIRenderer : System.IDisposable {
-  public DrawRendererFlags drawRendererFlags {
-    get { return _renderPipeline.drawRendererFlags; }
-  }
-  public RendererConfiguration rendererConfiguration {
-    get { return _renderPipeline.rendererConfiguration; }
-  }
-
   const string _sampleCameraEvent = "CameraEvent.";
   const string _samplePostProcessRender = "PostProcess.Render";
   const string _samplePostProcessRenderOpaqueOnly = "PostProcess.Render.OpaqueOnly";
   const string _sampleRenderLighting = "Render.Lighting";
 
+  public VXGIRenderPipeline RenderPipeline { get; }
+
   float[] _renderScale;
   CommandBuffer _command;
   CommandBuffer _eventCommand;
-  CullResults _cullResults;
-  FilterRenderersSettings _filterSettings;
+  CullingResults _cullingResults;
+  FilteringSettings _filteringSettings;
   LightingShader[] _lightingPasses;
   PostProcessRenderContext _postProcessRenderContext;
   RenderTargetBinding _gBufferBinding;
-  VXGIRenderPipeline _renderPipeline;
+  ScriptableCullingParameters _cullingParameters;
 
   public VXGIRenderer(VXGIRenderPipeline renderPipeline) {
+    RenderPipeline = renderPipeline;
+
     _command = new CommandBuffer { name = "VXGI.Renderer" };
     _eventCommand = new CommandBuffer();
-    _filterSettings = new FilterRenderersSettings(true);
-    _renderPipeline = renderPipeline;
+    _filteringSettings = FilteringSettings.defaultValue;
 
     _gBufferBinding = new RenderTargetBinding(
       new RenderTargetIdentifier[] { ShaderIDs._CameraGBufferTexture0, ShaderIDs._CameraGBufferTexture1, ShaderIDs._CameraGBufferTexture2, ShaderIDs._CameraGBufferTexture3 },
@@ -57,9 +52,9 @@ public void Dispose() {
   }
 
   public void RenderDeferred(ScriptableRenderContext renderContext, Camera camera, VXGI vxgi) {
-    ScriptableCullingParameters cullingParams;
-    if (!CullResults.GetCullingParameters(camera, out cullingParams)) return;
-    CullResults.Cull(ref cullingParams, renderContext, ref _cullResults);
+    if (!camera.TryGetCullingParameters(out _cullingParameters)) return;
+
+    _cullingResults = renderContext.Cull(ref _cullingParameters);
 
     renderContext.SetupCameraProperties(camera);
 
@@ -161,14 +156,11 @@ void RenderCameraDepthNormalsTexture(ScriptableRenderContext renderContext, Came
   }
 
   void RenderGBuffers(ScriptableRenderContext renderContext, Camera camera) {
-    var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("Deferred"));
-    drawSettings.flags = _renderPipeline.drawRendererFlags;
-    drawSettings.rendererConfiguration = _renderPipeline.rendererConfiguration;
-    drawSettings.sorting.flags = SortFlags.CommonOpaque;
-
-    _filterSettings.renderQueueRange = RenderQueueRange.opaque;
+    var sortingSettings = new SortingSettings(camera) { criteria = SortingCriteria.CommonOpaque };
+    var drawingSettings = new DrawingSettings(ShaderTagIDs.Deferred, sortingSettings) { perObjectData = RenderPipeline.PerObjectData };
 
-    renderContext.DrawRenderers(_cullResults.visibleRenderers, ref drawSettings, _filterSettings);
+    _filteringSettings.renderQueueRange = RenderQueueRange.opaque;
+    renderContext.DrawRenderers(_cullingResults, ref drawingSettings, ref _filteringSettings);
   }
 
   void RenderLighting(ScriptableRenderContext renderContext, Camera camera, VXGI vxgi) {
@@ -245,18 +237,15 @@ void RenderSkyBox(ScriptableRenderContext renderContext, Camera camera) {
   }
 
   void RenderTransparent(ScriptableRenderContext renderContext, Camera camera) {
-    var drawSettings = new DrawRendererSettings(camera, new ShaderPassName("ForwardBase"));
-    drawSettings.flags = _renderPipeline.drawRendererFlags;
-    drawSettings.rendererConfiguration = _renderPipeline.rendererConfiguration;
-    drawSettings.sorting.flags = SortFlags.CommonTransparent;
-
-    _filterSettings.renderQueueRange = RenderQueueRange.transparent;
-
     _command.SetRenderTarget(ShaderIDs.FrameBuffer, (RenderTargetIdentifier)ShaderIDs._CameraDepthTexture);
     renderContext.ExecuteCommandBuffer(_command);
     _command.Clear();
 
-    renderContext.DrawRenderers(_cullResults.visibleRenderers, ref drawSettings, _filterSettings);
+    var sortingSettings = new SortingSettings(camera) { criteria = SortingCriteria.CommonTransparent };
+    var drawingSettings = new DrawingSettings(ShaderTagIDs.ForwardBase, sortingSettings) { perObjectData = RenderPipeline.PerObjectData };
+
+    _filteringSettings.renderQueueRange = RenderQueueRange.transparent;
+    renderContext.DrawRenderers(_cullingResults, ref drawingSettings, ref _filteringSettings);
   }
 
   void TriggerCameraEvent(ScriptableRenderContext renderContext, Camera camera, CameraEvent cameraEvent, VXGI vxgi) {

Runtime/ShaderStructs/LightSource.cs

@@ -1,4 +1,5 @@
 using UnityEngine;
+using UnityEngine.Rendering;
 
 public struct LightSource {
   public const int size = (3 + 3 + 3 + 3 + 1 + 1 + 1 + 1) * 4;
@@ -12,10 +13,10 @@ public struct LightSource {
   public float spotFactor; // 1 * 4 bytes
   public uint type; // 1 * 4 bytes
 
-  public LightSource(UnityEngine.Experimental.Rendering.VisibleLight light, Matrix4x4 worldToVoxel) {
+  public LightSource(VisibleLight light, Matrix4x4 worldToVoxel) {
     color = (Vector4)light.finalColor;
-    direction = light.localToWorld.GetColumn(2);
-    worldPosition = light.localToWorld.GetColumn(3);
+    direction = light.localToWorldMatrix.GetColumn(2);
+    worldPosition = light.localToWorldMatrix.GetColumn(3);
     voxelPosition = worldToVoxel * new Vector4(worldPosition.x, worldPosition.y, worldPosition.z, 1f);
     range = light.range;
     spotCos = 0f;

Runtime/Stages/Mipmapper.cs

@@ -1,7 +1,5 @@
-using System.Collections.ObjectModel;
 using UnityEngine;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
 
 public class Mipmapper {
   public enum Mode { Box = 0, Gaussian3x3x3 = 1, Gaussian4x4x4 = 2 }

Runtime/Stages/VoxelShader.cs

@@ -1,6 +1,5 @@
 using UnityEngine;
 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering;
 
 public class VoxelShader : System.IDisposable {
   public ComputeShader compute {