public override void Action(int instanceId, string pathName, string resourceFile)
{
var instance = CreateInstance <GraphicProfile>();
ResourceReloader.TryReloadAllNullIn(instance, packagePath);
AssetDatabase.CreateAsset(instance, pathName);
}
//[MenuItem("Assets/Create/Rendering/Universal Pipeline Editor Resources", priority = CoreUtils.assetCreateMenuPriority1)]
static void CreateUniversalPipelineEditorResources()
{
var instance = CreateInstance <UniversalRenderPipelineEditorResources>();
ResourceReloader.ReloadAllNullIn(instance, packagePath);
AssetDatabase.CreateAsset(instance, string.Format("Assets/{0}.asset", typeof(UniversalRenderPipelineEditorResources).Name));
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var instance = UniversalRenderPipelineAsset.CreateRendererAsset(pathName, RendererType.UniversalRenderer, false) as UniversalRendererData;
ResourceReloader.ReloadAllNullIn(instance, UniversalRenderPipelineAsset.packagePath);
Selection.activeObject = instance;
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var instance = CreateInstance<ForwardRendererData>();
AssetDatabase.CreateAsset(instance, pathName);
ResourceReloader.ReloadAllNullIn(instance, UniversalRenderPipelineAsset.packagePath);
Selection.activeObject = instance;
}
protected override void OnEnable()
{
base.OnEnable();
// Provide a list of suggested texture property names to Sprite Editor via EditorPrefs.
const string suggestedNamesKey = "SecondarySpriteTexturePropertyNames";
const string maskTex = "_MaskTex";
const string normalMap = "_NormalMap";
string suggestedNamesPrefs = EditorPrefs.GetString(suggestedNamesKey);
if (string.IsNullOrEmpty(suggestedNamesPrefs))
{
EditorPrefs.SetString(suggestedNamesKey, maskTex + "," + normalMap);
}
else
{
if (!suggestedNamesPrefs.Contains(maskTex))
{
suggestedNamesPrefs += ("," + maskTex);
}
if (!suggestedNamesPrefs.Contains(normalMap))
{
suggestedNamesPrefs += ("," + normalMap);
}
EditorPrefs.SetString(suggestedNamesKey, suggestedNamesPrefs);
}
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.TryReloadAllNullIn(m_PostProcessData, UniversalRenderPipelineAsset.packagePath);
}
void FixHdrpAssetRuntimeResources(bool fromAsyncUnused)
{
if (!IsHdrpAssetUsedCorrect())
{
FixHdrpAssetUsed(fromAsync: false);
}
var hdrpAsset = HDRenderPipeline.defaultAsset;
if (hdrpAsset == null)
{
return;
}
var editorResourcesPath = HDUtils.GetHDRenderPipelinePath() + "Editor/RenderPipelineResources/HDRenderPipelineEditorResources.asset";
var objs = InternalEditorUtility.LoadSerializedFileAndForget(editorResourcesPath);
hdrpAsset.renderPipelineEditorResources = objs != null && objs.Length > 0 ? objs.First() as HDRenderPipelineEditorResources : null;
if (ResourceReloader.ReloadAllNullIn(HDRenderPipeline.defaultAsset.renderPipelineEditorResources,
HDUtils.GetHDRenderPipelinePath()))
{
InternalEditorUtility.SaveToSerializedFileAndForget(
new UnityEngine.Object[] { HDRenderPipeline.defaultAsset.renderPipelineEditorResources },
editorResourcesPath,
true);
}
}
static T LoadResourceFile <T>() where T : ScriptableObject
{
T resourceAsset = null;
var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", new[] { "Assets" });
foreach (string guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
resourceAsset = AssetDatabase.LoadAssetAtPath <T>(path);
if (resourceAsset != null)
{
break;
}
}
// There's currently an issue that prevents FindAssets from find resources withing the package folder.
if (resourceAsset == null)
{
string path = packagePath + "/Runtime/Data/" + typeof(T).Name + ".asset";
resourceAsset = AssetDatabase.LoadAssetAtPath <T>(path);
}
// Validate the resource file
ResourceReloader.TryReloadAllNullIn(resourceAsset, packagePath);
return(resourceAsset);
}
static void CreatePSXRenderPipelineAsset()
{
var newAsset = ScriptableObject.CreateInstance <PSXRenderPipelineResources>();
ResourceReloader.ReloadAllNullIn(newAsset, PSXStringConstants.s_PackagePath);
UnityEditor.AssetDatabase.CreateAsset(newAsset, s_DefaultPath);
}
protected override ScriptableRenderer Create()
{
#if UNITY_EDITOR
ResourceReloader.ReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.ReloadAllNullIn(postProcessData, UniversalRenderPipelineAsset.packagePath);
#endif
return(new ForwardRenderer(this));
}
public override void Create()
{
#if UNITY_EDITOR
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
#endif
m_DecalPreviewPass = new DecalPreviewPass();
m_RecreateSystems = true;
}
private void ReloadAllNullProperties()
{
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
// As now post process data is stored in Universal Render Pipeline, we can dereference non custom data.
if (m_PostProcessData == PostProcessData.GetDefaultPostProcessData())
{
m_PostProcessData = null;
}
}
protected override ScriptableRenderer Create()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
ResourceReloader.ReloadAllNullIn(this, LightweightRenderPipelineAsset.packagePath);
}
#endif
return(new ForwardRenderer(this));
}
void FixHdrpAssetEditorResources()
{
if (!IsHdrpAssetUsedCorrect())
{
FixHdrpAssetUsed(fromAsync: false);
}
HDRenderPipeline.defaultAsset.renderPipelineEditorResources
= AssetDatabase.LoadAssetAtPath <HDRenderPipelineEditorResources>(HDUtils.GetHDRenderPipelinePath() + "Editor/RenderPipelineResources/HDRenderPipelineEditorResources.asset");
ResourceReloader.ReloadAllNullIn(HDRenderPipeline.defaultAsset.renderPipelineEditorResources, HDUtils.GetHDRenderPipelinePath());
}
void FixDXRAsset(bool fromAsyncUnused)
{
if (!IsHdrpAssetUsedCorrect())
{
FixHdrpAssetUsed(fromAsync: false);
}
HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources
= AssetDatabase.LoadAssetAtPath <HDRenderPipelineRayTracingResources>(HDUtils.GetHDRenderPipelinePath() + "Runtime/RenderPipelineResources/HDRenderPipelineRayTracingResources.asset");
ResourceReloader.ReloadAllNullIn(HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources, HDUtils.GetHDRenderPipelinePath());
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var newAsset = CreateInstance <HDRenderPipelineEditorResources>();
newAsset.name = Path.GetFileName(pathName);
ResourceReloader.ReloadAllNullIn(newAsset);
AssetDatabase.CreateAsset(newAsset, pathName);
ProjectWindowUtil.ShowCreatedAsset(newAsset);
}
public void Setup(RenderTargetIdentifier source)
{
#if UNITY_EDITOR
if (Application.isPlaying)
{
ResourceReloader.TryReloadAllNullIn(this, "Packages/com.sbstn_hn.rendererfeatures.urp-ssao");
}
#endif
this.source = source;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.Space();
EditorGUILayout.LabelField(Styles.RendererTitle, EditorStyles.boldLabel); // Title
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_PostProcessData);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField(Styles.FilteringLabel, EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_OpaqueLayerMask, Styles.OpaqueMask);
EditorGUILayout.PropertyField(m_TransparentLayerMask, Styles.TransparentMask);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Shadows", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_ShadowTransparentReceiveProp, Styles.shadowTransparentReceiveLabel);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Overrides", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_DefaultStencilState, Styles.defaultStencilStateLabel, true);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
EditorGUILayout.LabelField("Portals", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(m_MaxPortalDepth, Styles.maxPortalDepthLabel, true);
EditorGUI.indentLevel--;
EditorGUILayout.Space();
serializedObject.ApplyModifiedProperties();
base.OnInspectorGUI(); // Draw the base UI, contains ScriptableRenderFeatures list
// Add a "Reload All" button in inspector when we are in developer's mode
if (EditorPrefs.GetBool("DeveloperMode"))
{
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_Shaders, true);
if (GUILayout.Button("Reload All"))
{
var resources = target as ForwardRendererData;
resources.shaders = null;
ResourceReloader.ReloadAllNullIn(target, UniversalRenderPipelineAsset.packagePath);
}
}
}
public override void Create()
{
#if UNITY_EDITOR
ResourceReloader.TryReloadAllNullIn(settings, "Assets/");
#endif
m_ScriptablePassOpaque = new OnlyDepthShadowmapRenderPass("Render Custom Shadowmap", true, RenderPassEvent.BeforeRendering - 10, RenderQueueRange.opaque, settings.OpaqueLayerMask);
m_ScriptablePassOpaque._ShadowParams = settings.ShadowColor;
m_ScriptablePassOpaque._ShadowParams.w = settings.ShadowBias;
//m_ScriptablePassTransparent = new LayerRenderPass("Render Player Transparent", false, RenderPassEvent.AfterRenderingTransparents + 11, RenderQueueRange.transparent, settings.TransparentLayerMask);
}
protected override ScriptableRenderer Create()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.TryReloadAllNullIn(postProcessData, UniversalRenderPipelineAsset.packagePath);
}
#endif
return(new CustomForwardRenderer(this));
}
public override void Action(int instanceId, string pathName, string resourceFile)
{
var newAsset = CreateInstance <HDRenderPipelineRuntimeResources>();
newAsset.name = Path.GetFileName(pathName);
// to prevent cases when the asset existed prior but then when upgrading the package, there is null field inside the resource asset
ResourceReloader.ReloadAllNullIn(newAsset, HDUtils.GetHDRenderPipelinePath());
AssetDatabase.CreateAsset(newAsset, pathName);
ProjectWindowUtil.ShowCreatedAsset(newAsset);
}
protected override ScriptableRenderer Create()
{
m_DefaultStencilState = new StencilStateData();
#if UNITY_EDITOR
if (!Application.isPlaying)
{
ResourceReloader.ReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.ReloadAllNullIn(postProcessData, UniversalRenderPipelineAsset.packagePath);
}
#endif
return(new ForwardRenderer(this));
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
// Add a "Reload All" button in inspector when we are in developer's mode
if (UnityEditor.EditorPrefs.GetBool("DeveloperMode") && GUILayout.Button("Reload All"))
{
var resources = target as UniversalRenderPipelineEditorResources;
resources.materials = null;
resources.shaders = null;
ResourceReloader.ReloadAllNullIn(target, UniversalRenderPipelineAsset.packagePath);
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
// Add a "Reload All" button in inspector when we are in developer's mode
if (UnityEditor.EditorPrefs.GetBool("DeveloperMode") &&
GUILayout.Button("Reload All"))
{
var resources = target as HDRenderPipelineRayTracingResources;
resources = null;
ResourceReloader.ReloadAllNullIn(target, HDUtils.GetHDRenderPipelinePath());
}
}
protected override ScriptableRenderer Create()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
ResourceReloader.ReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
}
#endif
shaders.colorToMrtPS = Shader.Find("Test/OutputColorsToMRTs");
shaders.copyToViewportPS = Shader.Find("Test/CopyToViewport");
return(new Test106Renderer(this));
}
void FixDXRAsset(bool fromAsyncUnused)
{
if (!IsHdrpAssetUsedCorrect())
{
FixHdrpAssetUsed(fromAsync: false);
}
HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources
= AssetDatabase.LoadAssetAtPath <HDRenderPipelineRayTracingResources>(HDUtils.GetHDRenderPipelinePath() + "Runtime/RenderPipelineResources/HDRenderPipelineRayTracingResources.asset");
ResourceReloader.ReloadAllNullIn(HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources, HDUtils.GetHDRenderPipelinePath());
if (!SystemInfo.supportsRayTracing)
{
Debug.LogError("Your hardware and/or OS don't support DXR!");
}
}
//[SerializeField] bool m_TiledDeferredShading = false;
protected override ScriptableRenderer Create()
{
#if UNITY_EDITOR
if (!Application.isPlaying)
{
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.TryReloadAllNullIn(postProcessData, UniversalRenderPipelineAsset.packagePath);
#if ENABLE_VR && ENABLE_XR_MODULE
ResourceReloader.TryReloadAllNullIn(xrSystemData, UniversalRenderPipelineAsset.packagePath);
#endif
}
#endif
return(new ToonForwardRenderer(this));
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
// Add a "Reload All" button in inspector when we are in developer's mode
if (UnityEditor.EditorPrefs.GetBool("DeveloperMode")
&& GUILayout.Button("Reload All"))
{
foreach (var field in typeof(HDRenderPipelineEditorResources).GetFields())
field.SetValue(target, null);
ResourceReloader.ReloadAllNullIn(target, HDUtils.GetHDRenderPipelinePath());
}
}
public override void Create()
{
#if UNITY_EDITOR
ResourceReloader.TryReloadAllNullIn(settings, "Assets/");
#endif
m_StencilPass = new StencilRenderPass(settings);
m_ReflectionsPass = new ReflectionsRenderPass(settings);
m_DrawReflectivePass = new DrawReflectiveLayerRenderPass(settings);
// Configures where the render pass should be injected.
m_StencilPass.renderPassEvent = RenderPassEvent.BeforeRenderingOpaques;
m_ReflectionsPass.renderPassEvent = RenderPassEvent.AfterRenderingSkybox;
m_DrawReflectivePass.renderPassEvent = RenderPassEvent.AfterRenderingSkybox;
}
internal static ScriptableRendererData CreateRendererAsset(string path, RendererType type, bool relativePath = true, string suffix = "Renderer")
{
ScriptableRendererData data = CreateRendererData(type);
string dataPath;
if (relativePath)
{
dataPath =
$"{Path.Combine(Path.GetDirectoryName(path), Path.GetFileNameWithoutExtension(path))}_{suffix}{Path.GetExtension(path)}";
}
else
{
dataPath = path;
}
AssetDatabase.CreateAsset(data, dataPath);
ResourceReloader.ReloadAllNullIn(data, packagePath);
return(data);
}
protected override void OnEnable()
{
base.OnEnable();
// Upon asset creation, OnEnable is called and `shaders` reference is not yet initialized
// We need to call the OnEnable for data migration when updating from old versions of UniversalRP that
// serialized resources in a different format. Early returning here when OnEnable is called
// upon asset creation is fine because we guarantee new assets get created with all resources initialized.
if (shaders == null)
{
return;
}
#if UNITY_EDITOR
ResourceReloader.TryReloadAllNullIn(this, UniversalRenderPipelineAsset.packagePath);
ResourceReloader.TryReloadAllNullIn(postProcessData, UniversalRenderPipelineAsset.packagePath);
#endif
}
