CnMGaming/GameDevTVObstacleDodge
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial project commit

Browse Source
This commit is contained in:
Caleb Sandford deQuincey
2026-01-08 16:50:20 +00:00
commit f0c5a8b267
29596 changed files with 4861782 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/PostProcessData.asset Normal file
View File

@@ -0,0 +1,78 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 572910c10080c0945a0ef731ccedc739, type: 3}
m_Name: PostProcessData
m_EditorClassIdentifier:
shaders:
stopNanPS: {fileID: 4800000, guid: 1121bb4e615ca3c48b214e79e841e823, type: 3}
subpixelMorphologicalAntialiasingPS: {fileID: 4800000, guid: 63eaba0ebfb82cc43bde059b4a8c65f6, type: 3}
gaussianDepthOfFieldPS: {fileID: 4800000, guid: 5e7134d6e63e0bc47a1dd2669cedb379, type: 3}
bokehDepthOfFieldPS: {fileID: 4800000, guid: 2aed67ad60045d54ba3a00c91e2d2631, type: 3}
cameraMotionBlurPS: {fileID: 4800000, guid: 1edcd131364091c46a17cbff0b1de97a, type: 3}
paniniProjectionPS: {fileID: 4800000, guid: a15b78cf8ca26ca4fb2090293153c62c, type: 3}
lutBuilderLdrPS: {fileID: 4800000, guid: 65df88701913c224d95fc554db28381a, type: 3}
lutBuilderHdrPS: {fileID: 4800000, guid: ec9fec698a3456d4fb18cf8bacb7a2bc, type: 3}
bloomPS: {fileID: 4800000, guid: 5f1864addb451f54bae8c86d230f736e, type: 3}
temporalAntialiasingPS: {fileID: 4800000, guid: 9c70c1a35ff15f340b38ea84842358bf, type: 3}
LensFlareDataDrivenPS: {fileID: 4800000, guid: 6cda457ac28612740adb23da5d39ea92, type: 3}
LensFlareScreenSpacePS: {fileID: 4800000, guid: 701880fecb344ea4c9cd0db3407ab287, type: 3}
scalingSetupPS: {fileID: 4800000, guid: e8ee25143a34b8c4388709ea947055d1, type: 3}
easuPS: {fileID: 4800000, guid: 562b7ae4f629f144aa97780546fce7c6, type: 3}
uberPostPS: {fileID: 4800000, guid: e7857e9d0c934dc4f83f270f8447b006, type: 3}
finalPostPassPS: {fileID: 4800000, guid: c49e63ed1bbcb334780a3bd19dfed403, type: 3}
textures:
blueNoise16LTex:
- {fileID: 2800000, guid: 81200413a40918d4d8702e94db29911c, type: 3}
- {fileID: 2800000, guid: d50c5e07c9911a74982bddf7f3075e7b, type: 3}
- {fileID: 2800000, guid: 1134690bf9216164dbc75050e35b7900, type: 3}
- {fileID: 2800000, guid: 7ce2118f74614a94aa8a0cdf2e6062c3, type: 3}
- {fileID: 2800000, guid: 2ca97df9d1801e84a8a8f2c53cb744f0, type: 3}
- {fileID: 2800000, guid: e63eef8f54aa9dc4da9a5ac094b503b5, type: 3}
- {fileID: 2800000, guid: 39451254daebd6d40b52899c1f1c0c1b, type: 3}
- {fileID: 2800000, guid: c94ad916058dff743b0f1c969ddbe660, type: 3}
- {fileID: 2800000, guid: ed5ea7ce59ca8ec4f9f14bf470a30f35, type: 3}
- {fileID: 2800000, guid: 071e954febf155243a6c81e48f452644, type: 3}
- {fileID: 2800000, guid: 96aaab9cc247d0b4c98132159688c1af, type: 3}
- {fileID: 2800000, guid: fc3fa8f108657e14486697c9a84ccfc5, type: 3}
- {fileID: 2800000, guid: bfed3e498947fcb4890b7f40f54d85b9, type: 3}
- {fileID: 2800000, guid: d512512f4af60a442ab3458489412954, type: 3}
- {fileID: 2800000, guid: 47a45908f6db0cb44a0d5e961143afec, type: 3}
- {fileID: 2800000, guid: 4dcc0502f8586f941b5c4a66717205e8, type: 3}
- {fileID: 2800000, guid: 9d92991794bb5864c8085468b97aa067, type: 3}
- {fileID: 2800000, guid: 14381521ff11cb74abe3fe65401c23be, type: 3}
- {fileID: 2800000, guid: d36f0fe53425e08499a2333cf423634c, type: 3}
- {fileID: 2800000, guid: d4044ea2490d63b43aa1765f8efbf8a9, type: 3}
- {fileID: 2800000, guid: c9bd74624d8070f429e3f46d161f9204, type: 3}
- {fileID: 2800000, guid: d5c9b274310e5524ebe32a4e4da3df1f, type: 3}
- {fileID: 2800000, guid: f69770e54f2823f43badf77916acad83, type: 3}
- {fileID: 2800000, guid: 10b6c6d22e73dea46a8ab36b6eebd629, type: 3}
- {fileID: 2800000, guid: a2ec5cbf5a9b64345ad3fab0912ddf7b, type: 3}
- {fileID: 2800000, guid: 1c3c6d69a645b804fa232004b96b7ad3, type: 3}
- {fileID: 2800000, guid: d18a24d7b4ed50f4387993566d9d3ae2, type: 3}
- {fileID: 2800000, guid: c989e1ed85cf7154caa922fec53e6af6, type: 3}
- {fileID: 2800000, guid: ff47e5a0f105eb34883b973e51f4db62, type: 3}
- {fileID: 2800000, guid: fa042edbfc40fbd4bad0ab9d505b1223, type: 3}
- {fileID: 2800000, guid: 896d9004736809c4fb5973b7c12eb8b9, type: 3}
- {fileID: 2800000, guid: 179f794063d2a66478e6e726f84a65bc, type: 3}
filmGrainTex:
- {fileID: 2800000, guid: 654c582f7f8a5a14dbd7d119cbde215d, type: 3}
- {fileID: 2800000, guid: dd77ffd079630404e879388999033049, type: 3}
- {fileID: 2800000, guid: 1097e90e1306e26439701489f391a6c0, type: 3}
- {fileID: 2800000, guid: f0b67500f7fad3b4c9f2b13e8f41ba6e, type: 3}
- {fileID: 2800000, guid: 9930fb4528622b34687b00bbe6883de7, type: 3}
- {fileID: 2800000, guid: bd9e8c758250ef449a4b4bfaad7a2133, type: 3}
- {fileID: 2800000, guid: 510a2f57334933e4a8dbabe4c30204e4, type: 3}
- {fileID: 2800000, guid: b4db8180660810945bf8d55ab44352ad, type: 3}
- {fileID: 2800000, guid: fd2fd78b392986e42a12df2177d3b89c, type: 3}
- {fileID: 2800000, guid: 5cdee82a77d13994f83b8fdabed7c301, type: 3}
smaaAreaTex: {fileID: 2800000, guid: d1f1048909d55cd4fa1126ab998f617e, type: 3}
smaaSearchTex: {fileID: 2800000, guid: 51eee22c2a633ef4aada830eed57c3fd, type: 3}

8
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/PostProcessData.asset.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 41439944d30ece34e96484bdb6645b55
NativeFormatImporter:
externalObjects: {}
mainObjectFileID: 11400000
userData:
assetBundleName:
assetBundleVariant:

319
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/PostProcessData.cs Normal file
View File

@@ -0,0 +1,319 @@
using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.ProjectWindowCallback;
using System.Reflection;
#endif
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Class containing shader and texture resources needed for Post Processing in URP.
/// </summary>
/// <seealso cref="Shader"/>
/// <seealso cref="Texture"/>
[Serializable]
public class PostProcessData : ScriptableObject
{
#if UNITY_EDITOR
[SuppressMessage("Microsoft.Performance", "CA1812")]
internal class CreatePostProcessDataAsset : EndNameEditAction
{
public override void Action(int instanceId, string pathName, string resourceFile)
{
var instance = CreateInstance<PostProcessData>();
AssetDatabase.CreateAsset(instance, pathName);
Selection.activeObject = instance;
}
}
[MenuItem("Assets/Create/Rendering/URP Post-process Data", priority = CoreUtils.Sections.section5 + CoreUtils.Priorities.assetsCreateRenderingMenuPriority)]
static void CreatePostProcessData()
{
ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, CreateInstance<CreatePostProcessDataAsset>(), "CustomPostProcessData.asset", null, null);
}
internal static PostProcessData GetDefaultPostProcessData()
{
var path = Path.Combine(UniversalRenderPipelineAsset.packagePath, "Runtime/Data/PostProcessData.asset");
return AssetDatabase.LoadAssetAtPath<PostProcessData>(path);
}
internal void Reset()
{
LoadResources(true);
}
internal void Populate()
{
LoadResources(false);
}
void LoadResources(bool reset)
{
if (GraphicsSettings.TryGetRenderPipelineSettings<ShaderResources>(out var defaultShaderResources))
{
if (shaders == null || reset)
shaders = new ShaderResources();
shaders.Populate(defaultShaderResources);
}
if (GraphicsSettings.TryGetRenderPipelineSettings<TextureResources>(out var defaultTextureResources))
{
if (textures == null || reset)
textures = new TextureResources();
textures.Populate(defaultTextureResources);
}
}
#endif
/// <summary>
/// Class containing shader resources used for Post Processing in URP.
/// </summary>
[Serializable]
[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))]
[Categorization.CategoryInfo(Name = "R: Default PostProcess Shaders", Order = 1000)]
[Categorization.ElementInfo(Order = 0), HideInInspector]
public sealed class ShaderResources : IRenderPipelineResources
{
/// <summary>
/// The StopNan Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/StopNaN.shader")]
public Shader stopNanPS;
/// <summary>
/// The <c>SubpixelMorphologicalAntiAliasing</c> SMAA Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/SubpixelMorphologicalAntialiasing.shader")]
public Shader subpixelMorphologicalAntialiasingPS;
/// <summary>
/// The Gaussian Depth Of Field Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/GaussianDepthOfField.shader")]
public Shader gaussianDepthOfFieldPS;
/// <summary>
/// The Bokeh Depth Of Field Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/BokehDepthOfField.shader")]
public Shader bokehDepthOfFieldPS;
/// <summary>
/// The Motion Blur Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/CameraMotionBlur.shader")]
public Shader cameraMotionBlurPS;
/// <summary>
/// The Panini Projection Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/PaniniProjection.shader")]
public Shader paniniProjectionPS;
/// <summary>
/// The LUT Builder LDR Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/LutBuilderLdr.shader")]
public Shader lutBuilderLdrPS;
/// <summary>
/// The LUT Builder HDR Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/LutBuilderHdr.shader")]
public Shader lutBuilderHdrPS;
/// <summary>
/// The Bloom Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/Bloom.shader")]
public Shader bloomPS;
/// <summary>
/// The Temporal-antialiasing Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/TemporalAA.shader")]
public Shader temporalAntialiasingPS;
/// <summary>
/// The Lens Flare Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/LensFlareDataDriven.shader")]
public Shader LensFlareDataDrivenPS;
/// <summary>
/// The Lens Flare Screen Space shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/LensFlareScreenSpace.shader")]
public Shader LensFlareScreenSpacePS;
/// <summary>
/// The Scaling Setup Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/ScalingSetup.shader")]
public Shader scalingSetupPS;
/// <summary>
/// The Edge Adaptive Spatial Upsampling shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/EdgeAdaptiveSpatialUpsampling.shader")]
public Shader easuPS;
/// <summary>
/// The Uber Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/UberPost.shader")]
public Shader uberPostPS;
/// <summary>
/// The Final Post Processing shader.
/// </summary>
[ResourcePath("Shaders/PostProcessing/FinalPost.shader")]
public Shader finalPostPassPS;
#if UNITY_EDITOR
/// <summary>
/// Copies all fields and resources from a source <see cref="ShaderResources"/> object into this object.
/// </summary>
/// <remarks>
/// This method is available only in the Unity Editor. It uses the <see cref="CoreUtils.Populate"/> method to copy non-null field values. Use this to synchronize resource objects during runtime in the Editor.
/// </remarks>
/// <param name="source">
/// The source <see cref="ShaderResources"/> object to copy data from. This object must not be null.
/// </param>
internal void Populate(ShaderResources source)
{
CoreUtils.PopulateNullFieldsFrom(source, this);
}
#endif
// This name must be unique within the entire PostProcessData set, as PostProcessDataAnalytics retrieves it.
[SerializeField][HideInInspector] int m_ShaderResourcesVersion = 0;
/// <summary>
/// Gets the current version of the resource container.
/// </summary>
/// <remarks>
/// This version is used exclusively for upgrading a project to ensure compatibility with resources configured in earlier Unity versions. Updating this version is an internal process during asset upgrades.
/// </remarks>
/// <value>
/// The version number of the resource container. This value is incremented when the resource container changes.
/// </value>
public int version => m_ShaderResourcesVersion;
/// <summary>
/// Indicates whether the resource is available in a player build.
/// </summary>
/// <remarks>
/// Always returns `false` because this resource is not designed to be included in player builds.
/// </remarks>
/// <value>
/// `false`, indicating that the resource is editor-only and unavailable in a player build.
/// </value>
public bool isAvailableInPlayerBuild => false;
}
/// <summary>
/// Class containing texture resources used for Post Processing in URP.
/// </summary>
[Serializable]
[SupportedOnRenderPipeline(typeof(UniversalRenderPipelineAsset))]
[Categorization.CategoryInfo(Name = "R: Default PostProcess Textures", Order = 1000)]
[Categorization.ElementInfo(Order = 0), HideInInspector]
public sealed class TextureResources : IRenderPipelineResources
{
/// <summary>
/// Pre-baked Blue noise textures.
/// </summary>
[ResourceFormattedPaths("Textures/BlueNoise16/L/LDR_LLL1_{0}.png", 0, 32)]
public Texture2D[] blueNoise16LTex;
/// <summary>
/// Film Grain textures.
/// </summary>
[ResourcePaths(new[]
{
"Textures/FilmGrain/Thin01.png",
"Textures/FilmGrain/Thin02.png",
"Textures/FilmGrain/Medium01.png",
"Textures/FilmGrain/Medium02.png",
"Textures/FilmGrain/Medium03.png",
"Textures/FilmGrain/Medium04.png",
"Textures/FilmGrain/Medium05.png",
"Textures/FilmGrain/Medium06.png",
"Textures/FilmGrain/Large01.png",
"Textures/FilmGrain/Large02.png"
})]
public Texture2D[] filmGrainTex;
/// <summary>
/// <c>SubpixelMorphologicalAntiAliasing</c> SMAA area texture.
/// </summary>
[ResourcePath("Textures/SMAA/AreaTex.tga")] public Texture2D smaaAreaTex;
/// <summary>
/// <c>SubpixelMorphologicalAntiAliasing</c> SMAA search texture.
/// </summary>
[ResourcePath("Textures/SMAA/SearchTex.tga")]
public Texture2D smaaSearchTex;
#if UNITY_EDITOR
/// <summary>
/// Copies all fields and resources from a source <see cref="TextureResources"/> object into this object.
/// </summary>
/// <remarks>
/// This method is available only in the Unity Editor. It uses the <see cref="CoreUtils.Populate"/> method to copy non-null field values. Use this to synchronize resource objects during runtime in the Editor.
/// </remarks>
/// <param name="source">
/// The source <see cref="TextureResources"/> object to copy data from. This object must not be null.
/// </param>
internal void Populate(TextureResources source)
{
CoreUtils.PopulateNullFieldsFrom(source, this);
}
#endif
// This name must be unique within the entire PostProcessData set, as PostProcessDataAnalytics retrieves it.
[SerializeField][HideInInspector] int m_TexturesResourcesVersion = 0;
/// <summary>
/// Gets the current version of the resource container.
/// </summary>
/// <remarks>
/// This version is used exclusively for upgrading a project to ensure compatibility with resources configured in earlier Unity versions. Updating this version is an internal process during asset upgrades.
/// </remarks>
/// <value>
/// The version number of the resource container. This value is incremented when the resource container changes.
/// </value>
public int version => m_TexturesResourcesVersion;
/// <summary>
/// Indicates whether the resource is available in a player build.
/// </summary>
/// <remarks>
/// Always returns `false` because this resource is not designed to be included in player builds.
/// </remarks>
/// <value>
/// `false`, indicating that the resource is editor-only and unavailable in a player build.
/// </value>
public bool isAvailableInPlayerBuild => false;
}
/// <summary>
/// Shader resources used for Post Processing in URP.
/// </summary>
public ShaderResources shaders;
/// <summary>
/// Texture resources used for Post Processing in URP.
/// </summary>
public TextureResources textures;
}
}

11
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/PostProcessData.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 572910c10080c0945a0ef731ccedc739
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

39
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/RenderStateData.cs Normal file
View File

@@ -0,0 +1,39 @@
namespace UnityEngine.Rendering.Universal
{
/// <summary>
/// Container class for stencil rendering settings.
/// </summary>
[System.Serializable]
public class StencilStateData
{
/// <summary>
/// Used to mark whether the stencil values should be overridden or not.
/// </summary>
public bool overrideStencilState = false;
/// <summary>
/// The stencil reference value.
/// </summary>
public int stencilReference = 0;
/// <summary>
/// The comparison function to use.
/// </summary>
public CompareFunction stencilCompareFunction = CompareFunction.Always;
/// <summary>
/// The stencil operation to use when the stencil test passes.
/// </summary>
public StencilOp passOperation = StencilOp.Keep;
/// <summary>
/// The stencil operation to use when the stencil test fails.
/// </summary>
public StencilOp failOperation = StencilOp.Keep;
/// <summary>
/// The stencil operation to use when the stencil test fails because of depth.
/// </summary>
public StencilOp zFailOperation = StencilOp.Keep;
}
}

11
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/RenderStateData.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 682abd313990845aabd60612b4828970
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

243
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAsset.DefaultResources.cs Normal file
View File

@@ -0,0 +1,243 @@
using System;
using UnityEditor;
namespace UnityEngine.Rendering.Universal
{
internal enum DefaultMaterialType
{
Default,
Particle,
Terrain,
Sprite,
SpriteMask,
Decal
}
public partial class UniversalRenderPipelineAsset
{
#region Materials
Material GetMaterial(DefaultMaterialType materialType)
{
#if UNITY_EDITOR
Material material = null;
if (scriptableRendererData != null)
material = scriptableRendererData.GetDefaultMaterial(materialType);
if (material == null)
{
if (GraphicsSettings.TryGetRenderPipelineSettings<UniversalRenderPipelineEditorMaterials>(out var defaultMaterials))
{
return materialType switch
{
DefaultMaterialType.Default => defaultMaterials.defaultMaterial,
DefaultMaterialType.Particle => defaultMaterials.defaultParticleUnlitMaterial,
DefaultMaterialType.Terrain => defaultMaterials.defaultTerrainLitMaterial,
DefaultMaterialType.Decal => defaultMaterials.defaultDecalMaterial,
DefaultMaterialType.Sprite => defaultMaterials.defaultSpriteMaterial,
_ => null
};
}
}
return material;
#else
return null;
#endif
}
/// <summary>
/// Returns the default Material.
/// </summary>
/// <returns>Returns the default Material.</returns>
public override Material defaultMaterial => GetMaterial(DefaultMaterialType.Default);
/// <summary>
/// Returns the default particle Material.
/// </summary>
/// <returns>Returns the default particle Material.</returns>
public override Material defaultParticleMaterial => GetMaterial(DefaultMaterialType.Particle);
/// <summary>
/// Returns the default line Material.
/// </summary>
/// <returns>Returns the default line Material.</returns>
public override Material defaultLineMaterial => GetMaterial(DefaultMaterialType.Particle);
/// <summary>
/// Returns the default terrain Material.
/// </summary>
/// <returns>Returns the default terrain Material.</returns>
public override Material defaultTerrainMaterial => GetMaterial(DefaultMaterialType.Terrain);
/// <summary>
/// Returns the default material for the 2D renderer.
/// </summary>
/// <returns>Returns the material containing the default lit and unlit shader passes for sprites in the 2D renderer.</returns>
public override Material default2DMaterial => GetMaterial(DefaultMaterialType.Sprite);
/// <summary>
/// Returns the default sprite mask material for the 2D renderer.
/// </summary>
/// <returns>Returns the material containing the default shader pass for sprite mask in the 2D renderer.</returns>
public override Material default2DMaskMaterial => GetMaterial(DefaultMaterialType.SpriteMask);
/// <summary>
/// Returns the Material that Unity uses to render decals.
/// </summary>
/// <returns>Returns the Material containing the Unity decal shader.</returns>
public Material decalMaterial => GetMaterial(DefaultMaterialType.Decal);
#endregion
#region Shaders
#if UNITY_EDITOR
private UniversalRenderPipelineEditorShaders defaultShaders =>
GraphicsSettings.GetRenderPipelineSettings<UniversalRenderPipelineEditorShaders>();
#endif
Shader m_DefaultShader;
/// <summary>
/// Returns the default shader for the specified renderer. When creating new objects in the editor, the materials of those objects will use the selected default shader.
/// </summary>
/// <returns>Returns the default shader for the specified renderer.</returns>
public override Shader defaultShader
{
get
{
#if UNITY_EDITOR
// TODO: When importing project, AssetPreviewUpdater:CreatePreviewForAsset will be called multiple time
// which in turns calls this property to get the default shader.
// The property should never return null as, when null, it loads the data using AssetDatabase.LoadAssetAtPath.
// However it seems there's an issue that LoadAssetAtPath will not load the asset in some cases. so adding the null check
// here to fix template tests.
if (scriptableRendererData != null)
{
Shader defaultShader = scriptableRendererData.GetDefaultShader();
if (defaultShader != null)
return defaultShader;
}
if (m_DefaultShader == null)
{
string path = AssetDatabase.GUIDToAssetPath(ShaderUtils.GetShaderGUID(ShaderPathID.Lit));
m_DefaultShader = AssetDatabase.LoadAssetAtPath<Shader>(path);
}
#endif
if (m_DefaultShader == null)
m_DefaultShader = Shader.Find(ShaderUtils.GetShaderPath(ShaderPathID.Lit));
return m_DefaultShader;
}
}
#region Terrain
/// <summary>
/// Returns the terrain detail lit shader that this asset uses.
/// </summary>
public override Shader terrainDetailLitShader
{
get
{
if (GraphicsSettings.TryGetRenderPipelineSettings<UniversalRenderPipelineRuntimeShaders>(
out var shadersResources))
{
return shadersResources.terrainDetailLitShader;
}
return null;
}
}
/// <summary>
/// Returns the terrain detail grass shader that this asset uses.
/// </summary>
public override Shader terrainDetailGrassShader
{
get
{
if (GraphicsSettings.TryGetRenderPipelineSettings<UniversalRenderPipelineRuntimeShaders>(
out var shadersResources))
{
return shadersResources.terrainDetailGrassShader;
}
return null;
}
}
/// <summary>
/// Returns the terrain detail grass billboard shader that this asset uses.
/// </summary>
public override Shader terrainDetailGrassBillboardShader
{
get
{
if (GraphicsSettings.TryGetRenderPipelineSettings<UniversalRenderPipelineRuntimeShaders>(
out var shadersResources))
{
return shadersResources.terrainDetailGrassBillboardShader;
}
return null;
}
}
#endregion
#if UNITY_EDITOR
#region Autodesk
/// <summary>
/// Returns the Autodesk Interactive shader that this asset uses.
/// </summary>
/// <returns>Returns the Autodesk Interactive shader that this asset uses.</returns>
public override Shader autodeskInteractiveShader => defaultShaders?.autodeskInteractiveShader;
/// <summary>
/// Returns the Autodesk Interactive transparent shader that this asset uses.
/// </summary>
/// <returns>Returns the Autodesk Interactive transparent shader that this asset uses.</returns>
public override Shader autodeskInteractiveTransparentShader => defaultShaders?.autodeskInteractiveTransparentShader;
/// <summary>
/// Returns the Autodesk Interactive mask shader that this asset uses.
/// </summary>
/// <returns>Returns the Autodesk Interactive mask shader that this asset uses</returns>
public override Shader autodeskInteractiveMaskedShader => defaultShaders?.autodeskInteractiveMaskedShader;
#endregion
#region SpeedTree
/// <summary>
/// Returns the default SpeedTree7 shader that this asset uses.
/// </summary>
/// <returns>Returns the default SpeedTree7 shader that this asset uses.</returns>
public override Shader defaultSpeedTree7Shader => defaultShaders?.defaultSpeedTree7Shader;
/// <summary>
/// Returns the default SpeedTree8 shader that this asset uses.
/// </summary>
/// <returns>Returns the default SpeedTree8 shader that this asset uses.</returns>
public override Shader defaultSpeedTree8Shader => defaultShaders?.defaultSpeedTree8Shader;
/// <summary>
/// Returns the default SpeedTree9 shader that this asset uses.
/// </summary>
/// <returns>Returns the default SpeedTree9 shader that this asset uses.</returns>
public override Shader defaultSpeedTree9Shader => defaultShaders?.defaultSpeedTree9Shader;
#endregion
#endif
#endregion
}
}

2
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAsset.DefaultResources.cs.meta Normal file
View File

@@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: 3ee3e329a28361841bde3586c2b45586

2003
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAsset.cs Normal file
View File

File diff suppressed because it is too large Load Diff

12
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAsset.cs.meta Normal file
View File

@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: bf2edee5c58d82540a51f03df9d42094
timeCreated: 1488808083
licenseType: Pro
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

307
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAssetPrefiltering.cs Normal file
View File

@@ -0,0 +1,307 @@
#if UNITY_EDITOR
using ShaderKeywordFilter = UnityEditor.ShaderKeywordFilter;
using HDRKeywords = UnityEngine.Rendering.HDROutputUtils.ShaderKeywords;
namespace UnityEngine.Rendering.Universal
{
// This partial class is used for Shader Keyword Prefiltering
// It's an editor only file and used when making builds to determine what keywords can
// be removed early in the Shader Processing stage based on the settings in each URP Asset
public partial class UniversalRenderPipelineAsset
{
internal enum PrefilteringMode
{
Remove, // Removes the keyword
Select, // Keeps the keyword
SelectOnly // Selects the keyword and removes others
}
internal enum PrefilteringModeMainLightShadows
{
Remove, // Removes the keyword
SelectMainLight, // Selects MainLightShadows variant & Removes OFF variant
SelectMainLightAndOff, // Selects MainLightShadows & OFF variants
SelectMainLightAndCascades, // Selects MainLightShadows, MainLightShadowCascades & Removes OFF variant
SelectAll, // Selects MainLightShadows, MainLightShadowCascades & OFF variant
}
internal enum PrefilteringModeAdditionalLights
{
Remove, // Removes the keyword
SelectVertex, // Selects Vertex & Removes OFF variant
SelectVertexAndOff, // Selects Vertex & OFF variant
SelectPixel, // Selects Pixel & Removes OFF variant
SelectPixelAndOff, // Selects Pixel & OFF variant
SelectAll // Selects Vertex, Pixel & OFF variant
}
// Platform specific filtering overrides
[ShaderKeywordFilter.ApplyRulesIfGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.WriteRenderingLayers)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT1)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT2)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT3)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.USE_LEGACY_LIGHTMAPS)]
private const bool k_CommonGLDefaults = true;
// Foveated Rendering
#if ENABLE_VR && ENABLE_XR_MODULE
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.PlayStation5NGGC, GraphicsDeviceType.Metal)]
#endif
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.FoveatedRenderingNonUniformRaster)]
private const bool k_PrefilterFoveatedRenderingNonUniformRaster = true;
// User can change cascade count at runtime so we have to include both MainLightShadows and MainLightShadowCascades.
// ScreenSpaceShadows renderer feature has separate filter attribute for keeping MainLightShadowScreen.
// NOTE: off variants are atm always removed when shadows are supported
[ShaderKeywordFilter.RemoveIf(PrefilteringModeMainLightShadows.Remove, keywordNames: new [] {ShaderKeywordStrings.MainLightShadows, ShaderKeywordStrings.MainLightShadowCascades})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeMainLightShadows.SelectMainLight, keywordNames: ShaderKeywordStrings.MainLightShadows)]
[ShaderKeywordFilter.SelectIf(PrefilteringModeMainLightShadows.SelectMainLightAndOff, keywordNames: new [] {"", ShaderKeywordStrings.MainLightShadows})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeMainLightShadows.SelectMainLightAndCascades, keywordNames: new [] {ShaderKeywordStrings.MainLightShadows, ShaderKeywordStrings.MainLightShadowCascades})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeMainLightShadows.SelectAll, keywordNames: new [] {"", ShaderKeywordStrings.MainLightShadows, ShaderKeywordStrings.MainLightShadowCascades})]
[SerializeField] private PrefilteringModeMainLightShadows m_PrefilteringModeMainLightShadows = PrefilteringModeMainLightShadows.SelectMainLight;
// Additional Lights
// clustered renderer can override PerVertex/PerPixel to be disabled
// NOTE: off variants are atm always kept when additional lights are enabled due to XR perf reasons
// multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
[ShaderKeywordFilter.RemoveIf(PrefilteringModeAdditionalLights.Remove, keywordNames: new string[] {ShaderKeywordStrings.AdditionalLightsVertex, ShaderKeywordStrings.AdditionalLightsPixel})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeAdditionalLights.SelectVertex, keywordNames: ShaderKeywordStrings.AdditionalLightsVertex)]
[ShaderKeywordFilter.SelectIf(PrefilteringModeAdditionalLights.SelectVertexAndOff,keywordNames: new string[] {"", ShaderKeywordStrings.AdditionalLightsVertex})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeAdditionalLights.SelectPixel, keywordNames: ShaderKeywordStrings.AdditionalLightsPixel)]
[ShaderKeywordFilter.SelectIf(PrefilteringModeAdditionalLights.SelectPixelAndOff, keywordNames: new string[] {"", ShaderKeywordStrings.AdditionalLightsPixel})]
[ShaderKeywordFilter.SelectIf(PrefilteringModeAdditionalLights.SelectAll, keywordNames: new string[] {"", ShaderKeywordStrings.AdditionalLightsVertex, ShaderKeywordStrings.AdditionalLightsPixel})]
[SerializeField] private PrefilteringModeAdditionalLights m_PrefilteringModeAdditionalLight = PrefilteringModeAdditionalLights.SelectPixelAndOff;
// Additional Lights Shadows
[ShaderKeywordFilter.RemoveIf(PrefilteringMode.Remove, keywordNames: ShaderKeywordStrings.AdditionalLightShadows)]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.Select, keywordNames: new string[] {"", ShaderKeywordStrings.AdditionalLightShadows})]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.SelectOnly, keywordNames: ShaderKeywordStrings.AdditionalLightShadows)]
[SerializeField] private PrefilteringMode m_PrefilteringModeAdditionalLightShadows = PrefilteringMode.Select;
// XR Specific keywords
[ShaderKeywordFilter.RemoveIf(true, keywordNames: new [] {
ShaderKeywordStrings.BlitSingleSlice, ShaderKeywordStrings.XROcclusionMeshCombined
})]
[SerializeField] private bool m_PrefilterXRKeywords = false;
// Forward+ / Deferred+
[ShaderKeywordFilter.RemoveIf(PrefilteringMode.Remove, keywordNames: ShaderKeywordStrings.ClusterLightLoop)]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.Select, keywordNames: new [] { "", ShaderKeywordStrings.ClusterLightLoop })]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.SelectOnly, keywordNames: ShaderKeywordStrings.ClusterLightLoop)]
[SerializeField] private PrefilteringMode m_PrefilteringModeForwardPlus = PrefilteringMode.Select;
// Deferred Rendering / Deferred+
[ShaderKeywordFilter.RemoveIf(PrefilteringMode.Remove, keywordNames: new [] {
ShaderKeywordStrings._DEFERRED_FIRST_LIGHT, ShaderKeywordStrings._DEFERRED_MAIN_LIGHT,
ShaderKeywordStrings._DEFERRED_MIXED_LIGHTING, ShaderKeywordStrings._GBUFFER_NORMALS_OCT
})]
[SerializeField] private PrefilteringMode m_PrefilteringModeDeferredRendering = PrefilteringMode.Select;
// Screen Space Occlusion
[ShaderKeywordFilter.RemoveIf(PrefilteringMode.Remove, keywordNames: ShaderKeywordStrings.ScreenSpaceOcclusion)]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.Select, keywordNames: new [] {"", ShaderKeywordStrings.ScreenSpaceOcclusion})]
[ShaderKeywordFilter.SelectIf(PrefilteringMode.SelectOnly, keywordNames: ShaderKeywordStrings.ScreenSpaceOcclusion)]
[SerializeField] private PrefilteringMode m_PrefilteringModeScreenSpaceOcclusion = PrefilteringMode.Select;
// Rendering Debugger
[ShaderKeywordFilter.RemoveIf(true, keywordNames:ShaderKeywordStrings.DEBUG_DISPLAY)]
[SerializeField] private bool m_PrefilterDebugKeywords = false;
// Filters out WriteRenderingLayers if nothing requires the feature
// TODO: Implement a different filter triggers for different passes (i.e. per-pass filter attributes)
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.WriteRenderingLayers)]
[SerializeField] private bool m_PrefilterWriteRenderingLayers = false;
// HDR Output
[ShaderKeywordFilter.RemoveIf(true, keywordNames: new [] {
HDRKeywords.HDR_INPUT, HDRKeywords.HDR_COLORSPACE_CONVERSION, HDRKeywords.HDR_ENCODING, HDRKeywords.HDR_COLORSPACE_CONVERSION_AND_ENCODING
})]
[SerializeField] private bool m_PrefilterHDROutput = false;
// Alpha Output
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT)]
[SerializeField] private bool m_PrefilterAlphaOutput = false;
// Screen Space Ambient Occlusion (SSAO) specific keywords
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SourceDepthNormalsKeyword)]
[SerializeField] private bool m_PrefilterSSAODepthNormals = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SourceDepthLowKeyword)]
[SerializeField] private bool m_PrefilterSSAOSourceDepthLow = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SourceDepthMediumKeyword)]
[SerializeField] private bool m_PrefilterSSAOSourceDepthMedium = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SourceDepthHighKeyword)]
[SerializeField] private bool m_PrefilterSSAOSourceDepthHigh = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_AOInterleavedGradientKeyword)]
[SerializeField] private bool m_PrefilterSSAOInterleaved = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_AOBlueNoiseKeyword)]
[SerializeField] private bool m_PrefilterSSAOBlueNoise = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SampleCountLowKeyword)]
[SerializeField] private bool m_PrefilterSSAOSampleCountLow = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SampleCountMediumKeyword)]
[SerializeField] private bool m_PrefilterSSAOSampleCountMedium = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ScreenSpaceAmbientOcclusion.k_SampleCountHighKeyword)]
[SerializeField] private bool m_PrefilterSSAOSampleCountHigh = false;
// Decals
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT1)]
[SerializeField] private bool m_PrefilterDBufferMRT1 = false;
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT2)]
[SerializeField] private bool m_PrefilterDBufferMRT2 = false;
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DBufferMRT3)]
[SerializeField] private bool m_PrefilterDBufferMRT3 = false;
// Decal Layers - Gets overridden in Decal renderer feature if enabled.
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.DecalLayers)]
private const bool k_DecalLayersDefault = true;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.SoftShadowsLow)]
[SerializeField] private bool m_PrefilterSoftShadowsQualityLow = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.SoftShadowsMedium)]
[SerializeField] private bool m_PrefilterSoftShadowsQualityMedium = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.SoftShadowsHigh)]
[SerializeField] private bool m_PrefilterSoftShadowsQualityHigh = false;
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.SoftShadows)]
[SerializeField] private bool m_PrefilterSoftShadows = false;
// Screen Coord Override - Controlled by the Global Settings
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.SCREEN_COORD_OVERRIDE)]
[SerializeField] private bool m_PrefilterScreenCoord = false;
// Native Render Pass
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.RenderPassEnabled)]
[SerializeField] private bool m_PrefilterNativeRenderPass = false;
// Use legacy lightmaps (GPU resident drawer)
[ShaderKeywordFilter.ApplyRulesIfNotGraphicsAPI(GraphicsDeviceType.OpenGLES3, GraphicsDeviceType.OpenGLCore)]
[ShaderKeywordFilter.SelectOrRemove(true, keywordNames: ShaderKeywordStrings.USE_LEGACY_LIGHTMAPS)]
[SerializeField] private bool m_PrefilterUseLegacyLightmaps = false;
// Bicubic lightmap sampling
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.LIGHTMAP_BICUBIC_SAMPLING)]
[ShaderKeywordFilter.SelectIf(false, keywordNames: ShaderKeywordStrings.LIGHTMAP_BICUBIC_SAMPLING)]
[SerializeField] private bool m_PrefilterBicubicLightmapSampling = false;
// Reflection probe blending (_REFLECTION_PROBE_BLENDING)
[ShaderKeywordFilter.SelectOrRemove(false, keywordNames: ShaderKeywordStrings.ReflectionProbeBlending)]
[SerializeField] private bool m_PrefilterReflectionProbeBlending = false;
// Reflection probe box projection (_REFLECTION_PROBE_BOX_PROJECTION)
[ShaderKeywordFilter.SelectOrRemove(false, keywordNames: ShaderKeywordStrings.ReflectionProbeBoxProjection)]
[SerializeField] private bool m_PrefilterReflectionProbeBoxProjection = false;
// Reflection probe atlas (_REFLECTION_PROBE_ATLAS)
[ShaderKeywordFilter.RemoveIf(true, keywordNames: ShaderKeywordStrings.ReflectionProbeAtlas)]
[SerializeField] private bool m_PrefilterReflectionProbeAtlas = false;
/// <summary>
/// Data used for Shader Prefiltering. Gathered after going through the URP Assets,
/// Renderers and Renderer Features in OnPreprocessBuild() inside ShaderPreprocessor.cs.
/// </summary>
internal struct ShaderPrefilteringData
{
public PrefilteringMode forwardPlusPrefilteringMode;
public PrefilteringMode deferredPrefilteringMode;
public PrefilteringModeMainLightShadows mainLightShadowsPrefilteringMode;
public PrefilteringModeAdditionalLights additionalLightsPrefilteringMode;
public PrefilteringMode additionalLightsShadowsPrefilteringMode;
public PrefilteringMode screenSpaceOcclusionPrefilteringMode;
public bool useLegacyLightmaps;
public bool stripXRKeywords;
public bool stripHDRKeywords;
public bool stripAlphaOutputKeywords;
public bool stripDebugDisplay;
public bool stripScreenCoordOverride;
public bool stripWriteRenderingLayers;
public bool stripDBufferMRT1;
public bool stripDBufferMRT2;
public bool stripDBufferMRT3;
public bool stripNativeRenderPass;
public bool stripSoftShadowsQualityLow;
public bool stripSoftShadowsQualityMedium;
public bool stripSoftShadowsQualityHigh;
public bool stripSSAOBlueNoise;
public bool stripSSAOInterleaved;
public bool stripSSAODepthNormals;
public bool stripSSAOSourceDepthLow;
public bool stripSSAOSourceDepthMedium;
public bool stripSSAOSourceDepthHigh;
public bool stripSSAOSampleCountLow;
public bool stripSSAOSampleCountMedium;
public bool stripSSAOSampleCountHigh;
public bool stripBicubicLightmapSampling;
public bool stripReflectionProbeBlending;
public bool stripReflectionProbeBoxProjection;
public bool stripReflectionProbeAtlas;
public static ShaderPrefilteringData GetDefault()
{
return new ShaderPrefilteringData()
{
forwardPlusPrefilteringMode = PrefilteringMode.Select,
deferredPrefilteringMode = PrefilteringMode.Select,
mainLightShadowsPrefilteringMode = PrefilteringModeMainLightShadows.SelectAll,
additionalLightsPrefilteringMode = PrefilteringModeAdditionalLights.SelectAll,
additionalLightsShadowsPrefilteringMode = PrefilteringMode.Select,
screenSpaceOcclusionPrefilteringMode = PrefilteringMode.Select,
};
}
}
/// <summary>
/// Uses the data collected in the OnPreprocessBuild() to set the Shader Prefiltering variables.
/// </summary>
/// <param name="prefilteringData"></param>
internal void UpdateShaderKeywordPrefiltering(ref ShaderPrefilteringData prefilteringData)
{
m_PrefilteringModeForwardPlus = prefilteringData.forwardPlusPrefilteringMode;
m_PrefilteringModeDeferredRendering = prefilteringData.deferredPrefilteringMode;
m_PrefilteringModeMainLightShadows = prefilteringData.mainLightShadowsPrefilteringMode;
m_PrefilteringModeAdditionalLight = prefilteringData.additionalLightsPrefilteringMode;
m_PrefilteringModeAdditionalLightShadows = prefilteringData.additionalLightsShadowsPrefilteringMode;
m_PrefilteringModeScreenSpaceOcclusion = prefilteringData.screenSpaceOcclusionPrefilteringMode;
m_PrefilterUseLegacyLightmaps = prefilteringData.useLegacyLightmaps;
m_PrefilterXRKeywords = prefilteringData.stripXRKeywords;
m_PrefilterHDROutput = prefilteringData.stripHDRKeywords;
m_PrefilterAlphaOutput = prefilteringData.stripAlphaOutputKeywords;
m_PrefilterDebugKeywords = prefilteringData.stripDebugDisplay;
m_PrefilterWriteRenderingLayers = prefilteringData.stripWriteRenderingLayers;
m_PrefilterScreenCoord = prefilteringData.stripScreenCoordOverride;
m_PrefilterDBufferMRT1 = prefilteringData.stripDBufferMRT1;
m_PrefilterDBufferMRT2 = prefilteringData.stripDBufferMRT2;
m_PrefilterDBufferMRT3 = prefilteringData.stripDBufferMRT3;
m_PrefilterNativeRenderPass = prefilteringData.stripNativeRenderPass;
m_PrefilterSoftShadowsQualityLow = prefilteringData.stripSoftShadowsQualityLow;
m_PrefilterSoftShadowsQualityMedium = prefilteringData.stripSoftShadowsQualityMedium;
m_PrefilterSoftShadowsQualityHigh = prefilteringData.stripSoftShadowsQualityHigh;
m_PrefilterSoftShadows = !m_PrefilterSoftShadowsQualityLow || !m_PrefilterSoftShadowsQualityMedium || !m_PrefilterSoftShadowsQualityHigh;
m_PrefilterSSAOBlueNoise = prefilteringData.stripSSAOBlueNoise;
m_PrefilterSSAOInterleaved = prefilteringData.stripSSAOInterleaved;
m_PrefilterSSAODepthNormals = prefilteringData.stripSSAODepthNormals;
m_PrefilterSSAOSourceDepthLow = prefilteringData.stripSSAOSourceDepthLow;
m_PrefilterSSAOSourceDepthMedium = prefilteringData.stripSSAOSourceDepthMedium;
m_PrefilterSSAOSourceDepthHigh = prefilteringData.stripSSAOSourceDepthHigh;
m_PrefilterSSAOSampleCountLow = prefilteringData.stripSSAOSampleCountLow;
m_PrefilterSSAOSampleCountMedium = prefilteringData.stripSSAOSampleCountMedium;
m_PrefilterSSAOSampleCountHigh = prefilteringData.stripSSAOSampleCountHigh;
m_PrefilterBicubicLightmapSampling = prefilteringData.stripBicubicLightmapSampling;
m_PrefilterReflectionProbeBlending = prefilteringData.stripReflectionProbeBlending;
m_PrefilterReflectionProbeBoxProjection = prefilteringData.stripReflectionProbeBoxProjection;
m_PrefilterReflectionProbeAtlas = prefilteringData.stripReflectionProbeAtlas;
}
}
}
#endif

3
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRenderPipelineAssetPrefiltering.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 55dca53d5ab64402b85ef43b2af4e33e
timeCreated: 1667940906

52
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRendererData.asset Normal file
View File

@@ -0,0 +1,52 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!114 &11400000
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 0}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: de640fe3d0db1804a85f9fc8f5cadab6, type: 3}
m_Name: UniversalRendererData
m_EditorClassIdentifier:
debugShaders:
debugReplacementPS: {fileID: 4800000, guid: cf852408f2e174538bcd9b7fda1c5ae7, type: 3}
m_RendererFeatures: []
m_RendererFeatureMap:
m_UseNativeRenderPass: 0
postProcessData: {fileID: 11400000, guid: 41439944d30ece34e96484bdb6645b55, type: 2}
xrSystemData: {fileID: 11400000, guid: 60e1133243b97e347b653163a8c01b64, type: 2}
shaders:
blitPS: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
copyDepthPS: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}
screenSpaceShadowPS: {fileID: 0}
samplingPS: {fileID: 4800000, guid: 04c410c9937594faa893a11dceb85f7e, type: 3}
stencilDeferredPS: {fileID: 4800000, guid: e9155b26e1bc55942a41e518703fe304, type: 3}
fallbackErrorPS: {fileID: 4800000, guid: e6e9a19c3678ded42a3bc431ebef7dbd, type: 3}
materialErrorPS: {fileID: 4800000, guid: 5fd9a8feb75a4b5894c241777f519d4e, type: 3}
coreBlitPS: {fileID: 4800000, guid: 93446b5c5339d4f00b85c159e1159b7c, type: 3}
coreBlitColorAndDepthPS: {fileID: 4800000, guid: d104b2fc1ca6445babb8e90b0758136b, type: 3}
cameraMotionVector: {fileID: 4800000, guid: c56b7e0d4c7cb484e959caeeedae9bbf, type: 3}
objectMotionVector: {fileID: 4800000, guid: 7b3ede40266cd49a395def176e1bc486, type: 3}
m_OpaqueLayerMask:
serializedVersion: 2
m_Bits: 4294967295
m_TransparentLayerMask:
serializedVersion: 2
m_Bits: 4294967295
m_DefaultStencilState:
overrideStencilState: 0
stencilReference: 0
stencilCompareFunction: 8
passOperation: 2
failOperation: 0
zFailOperation: 0
m_ShadowTransparentReceive: 1
m_RenderingMode: 0
m_DepthPrimingMode: 0
m_AccurateGbufferNormals: 0
m_ClusteredRendering: 0
m_TileSize: 32

8
Library/PackageCache/com.unity.render-pipelines.universal@ba467ec059b9/Runtime/Data/UniversalRendererData.asset.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: ba6e69114eba6af4585b7b850051b2d9
NativeFormatImporter:
externalObjects: {}
mainObjectFileID: 11400000
userData:
assetBundleName:
assetBundleVariant: