Soullies/ichni_Creator_Studio
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

一些特效

Browse Source
This commit is contained in:
SoulliesOfficial
2025-06-28 03:01:03 -04:00
parent 16418804e4
commit 1a3d37d9b5
216 changed files with 41141 additions and 2728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

483
Packages/NBPostProcessing/Runtime/NBPostProcess.cs Normal file
View File

@@ -0,0 +1,483 @@
// using ConfigSystem.MConfig;
// using Sirenix.OdinInspector;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using System.Collections.Generic;
namespace MhRender.RendererFeatures
{
public class NBPostProcess : ScriptableRendererFeature
{
private NBPostProcessRenderPass _renderPass;
private DisturbanceMaskRenderPass _disturbanceMaskRenderPass;
private ScreenColorRenderPass _screenColorRenderPass;
public static Material NBPostProcessMaterial;
//public MaskFormat maskFormat = MaskFormat.RG32;
public Downsampling downSampling = Downsampling.None;
public LayerMask disturbanceLayerMask=1 << 25;
private Material _disturbanceDownSampleMat;
private Material _screenColorDownSampleMat;
private float _screenHeight;
private ProfilingSampler _profilingSampler;
// private PostProcessingManager manager;-+
static Mesh s_FullscreenTriangle;
/// <summary>
/// A fullscreen triangle mesh.抄自Unity的后处理包,拿到一个全屏的Triangle。
/// </summary>
static Mesh fullscreenTriangle;
// {
// get
// {
// if (s_FullscreenTriangle != null)
// return s_FullscreenTriangle;
//
// s_FullscreenTriangle = new Mesh
// {
// name = "Fullscreen Triangle"
// };
//
// // Because we have to support older platforms (GLES2/3, DX9 etc) we can't do all of
// // this directly in the vertex shader using vertex ids :(
// s_FullscreenTriangle.SetVertices(new List<Vector3>
// {
// new Vector3 (-1f, -1f, 0f),
// new Vector3 (-1f, 3f, 0f),
// new Vector3 (3f, -1f, 0f)
// // new Vector3 (3f, -1f, 0f),
// // new Vector3 (-1f, 3f, 0f),
// // new Vector3 (-1f, -1f, 0f)
// });
// s_FullscreenTriangle.SetIndices(new[]
// {
// 0,
// 1,
// 2
// }, MeshTopology.Triangles, 0, false);
// s_FullscreenTriangle.UploadMeshData(false);
//
// meshTest = s_FullscreenTriangle;
// return s_FullscreenTriangle;
// }
// }
private bool canFind = false;
public override void Create()
{
if (Shader.Find("XuanXuan/ColorBlit") == null ||
Shader.Find("XuanXuan/Postprocess/NBPostProcessUber") == null)
{
canFind = false;
return;
}
else
{
canFind = true;
}
#if UNIVERSAL_RP_13_1_2_OR_NEWER
_screenColorDownSampleMat = CoreUtils.CreateEngineMaterial(Shader.Find("XuanXuan/ColorBlit"));
#else
_screenColorDownSampleMat = CoreUtils.CreateEngineMaterial(Shader.Find("XuanXuan/ColorBufferBlit"));
#endif
_screenColorRenderPass = new ScreenColorRenderPass(_screenColorDownSampleMat, downSampling);
_screenColorRenderPass.renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
_profilingSampler = new ProfilingSampler("DisturbanceRender");
_disturbanceDownSampleMat = CoreUtils.CreateEngineMaterial(Shader.Find("XuanXuan/ColorBlit"));
_disturbanceMaskRenderPass = new DisturbanceMaskRenderPass(_profilingSampler,_disturbanceDownSampleMat,downSampling,disturbanceLayerMask);
_disturbanceMaskRenderPass.renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
#if !UNIVERSAL_RP_13_1_2_OR_NEWER
_profilingSampler = new ProfilingSampler("DisturbanceDownRTBlit");
#endif
if (fullscreenTriangle == null)
{
/*UNITY_NEAR_CLIP_VALUE*/
float nearClipZ = -1;
if (SystemInfo.usesReversedZBuffer)
nearClipZ = 1;
fullscreenTriangle = new Mesh();
fullscreenTriangle.vertices = GetFullScreenTriangleVertexPosition(nearClipZ);
fullscreenTriangle.uv = GetFullScreenTriangleTexCoord();
fullscreenTriangle.triangles = new int[3] { 0, 1, 2 };
}
// Shader shader = Shader.Find("XuanXuan/Postprocess/NBPostProcessUber");
NBPostProcessMaterial = CoreUtils.CreateEngineMaterial(Shader.Find("XuanXuan/Postprocess/NBPostProcessUber"));
PostProcessingManager.InitMat();
// if (Application.isPlaying)
// {
// manager = PostProcessingManager.Instance;
// }
_renderPass = new NBPostProcessRenderPass(NBPostProcessMaterial,fullscreenTriangle);
_renderPass.renderPassEvent = RenderPassEvent.AfterRenderingTransparents;
}
#if UNIVERSAL_RP_13_1_2_OR_NEWER
public override void SetupRenderPasses(ScriptableRenderer renderer, in RenderingData renderingData)
{
if ((renderingData.cameraData.cameraType == CameraType.Game ||
renderingData.cameraData.cameraType == CameraType.SceneView) && canFind)
{
//_disturbanceMaskRenderPass.SetUp(renderer.cameraDepthTargetHandle);
//if (renderingData.cameraData.cameraType == CameraType.Game)
//{
// _screenHeight = renderer.cameraDepthTargetHandle.rt.descriptor.height;
//}
_disturbanceMaskRenderPass.ConfigureInput(ScriptableRenderPassInput.Color);
_disturbanceMaskRenderPass.SetUp(renderer.cameraColorTargetHandle);
_screenColorRenderPass.ConfigureInput(ScriptableRenderPassInput.Color);
_screenColorRenderPass.SetUp(renderer.cameraColorTargetHandle);
}
}
#endif
public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
if ((renderingData.cameraData.cameraType == CameraType.Game ||
renderingData.cameraData.cameraType == CameraType.SceneView) && canFind)
{
#if !UNIVERSAL_RP_13_1_2_OR_NEWER
// _disturbanceMaskRenderPass.ConfigureInput(ScriptableRenderPassInput.Color);
// _disturbanceMaskRenderPass.SetUp(renderer.cameraColorTargetHandle);
_screenColorRenderPass.ConfigureInput(ScriptableRenderPassInput.Color);
_screenColorRenderPass.SetUp(renderer);
#endif
renderer.EnqueuePass(_screenColorRenderPass);
renderer.EnqueuePass(_disturbanceMaskRenderPass);
renderer.EnqueuePass(_renderPass);
}
}
// Should match Common.hlsl
static Vector3[] GetFullScreenTriangleVertexPosition(float z /*= UNITY_NEAR_CLIP_VALUE*/)
{
var r = new Vector3[3];
for (int i = 0; i < 3; i++)
{
Vector2 uv = new Vector2((i << 1) & 2, i & 2);
r[i] = new Vector3(uv.x * 2.0f - 1.0f, uv.y * 2.0f - 1.0f, z);
}
return r;
}
// Should match Common.hlsl
static Vector2[] GetFullScreenTriangleTexCoord()
{
var r = new Vector2[3];
for (int i = 0; i < 3; i++)
{
if (SystemInfo.graphicsUVStartsAtTop)
r[i] = new Vector2((i << 1) & 2, 1.0f - (i & 2));
else
r[i] = new Vector2((i << 1) & 2, i & 2);
}
return r;
}
protected override void Dispose(bool disposing)
{
CoreUtils.Destroy(_disturbanceDownSampleMat);
//CoreUtils.Destroy(NBPostProcessMaterial);
_disturbanceMaskRenderPass?.Dispose();
CoreUtils.Destroy(_screenColorDownSampleMat);
_screenColorRenderPass?.Dispose();
}
}
public class DisturbanceMaskRenderPass : ScriptableRenderPass
{
private ProfilingSampler _profilingSampler;
#if UNIVERSAL_RP_13_1_2_OR_NEWER
private RTHandle _DisturbanceMaskRTHandle;
private RTHandle _cameraDepthRTHandle;
private RTHandle _DownRT;
#else
private static readonly int _DisturbanceMaskRTID = Shader.PropertyToID("_DisturbanceMaskRT");
private static readonly int _DownRTID = Shader.PropertyToID("_DisturbanceMaskTex");
private RenderTargetIdentifier _DisturbanceMaskRTHandle = new RenderTargetIdentifier (_DisturbanceMaskRTID);
private RenderTargetIdentifier _cameraDepthRTHandle;
private RenderTargetIdentifier _DownRT = new RenderTargetIdentifier (_DownRTID);
#endif
private Material tempMat;
private readonly Downsampling _downSampling;
//private readonly MaskFormat _maskFormat;
private Material _renderMaskMat ;
public LayerMask _DisturbanceMaskLayer = 1 << 25;
private FilteringSettings _Filtering;
private static readonly int CameraTexture = Shader.PropertyToID("_CameraTexture");
private static readonly int SampleOffset = Shader.PropertyToID("_SampleOffset");
private readonly List<ShaderTagId> _shaderTag = new List<ShaderTagId>()
{
new ShaderTagId("UniversalForward"),
new ShaderTagId("SRPDefaultUnlit"),
new ShaderTagId("UniversalForwardOnly")
};
public DisturbanceMaskRenderPass(ProfilingSampler profilingSampler,Material DisturbanceMaskMat, Downsampling downSampling,LayerMask disturbanceMaskLayer)
{
_profilingSampler = profilingSampler;
_renderMaskMat = DisturbanceMaskMat;
_downSampling = downSampling;
_DisturbanceMaskLayer = disturbanceMaskLayer;
}
#if UNIVERSAL_RP_13_1_2_OR_NEWER
public void SetUp ( RTHandle cameraRTHandle )
{
RenderTextureDescriptor descrip = cameraRTHandle.rt.descriptor;
descrip.colorFormat = RenderTextureFormat.RG32;
descrip.depthBufferBits = 0;
RenderingUtils.ReAllocateIfNeeded(ref _DisturbanceMaskRTHandle, descrip, name: "DisturbanceMaskRT");
switch (_downSampling)
{
case Downsampling._2xBilinear:
descrip.width /= 2;
descrip.height /= 2;
break;
case Downsampling._4xBilinear:
descrip.width /= 4;
descrip.height /= 4;
break;
case Downsampling._4xBox:
descrip.width /= 4;
descrip.height /= 4;
break;
}
RenderingUtils.ReAllocateIfNeeded(ref _DownRT, descrip, name:"MaskDownCopyRT");
}
#else
//在AddPass之前触发
public void SetUpDisturbanceMask(RenderTextureDescriptor descrip ,CommandBuffer cmd)
{
descrip.colorFormat = RenderTextureFormat.RG32;
descrip.depthBufferBits = 0;
cmd.GetTemporaryRT(_DisturbanceMaskRTID, descrip,FilterMode.Bilinear);
switch (_downSampling)
{
case Downsampling._2xBilinear:
descrip.width /= 2;
descrip.height /= 2;
break;
case Downsampling._4xBilinear:
descrip.width /= 4;
descrip.height /= 4;
break;
case Downsampling._4xBox:
descrip.width /= 4;
descrip.height /= 4;
break;
}
cmd.GetTemporaryRT(_DownRTID, descrip,FilterMode.Bilinear);
}
#endif
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{
_Filtering = new FilteringSettings(RenderQueueRange.all, _DisturbanceMaskLayer);
#if UNIVERSAL_RP_13_1_2_OR_NEWER
_cameraDepthRTHandle = renderingData.cameraData.renderer.cameraDepthTargetHandle;
#else
_cameraDepthRTHandle = renderingData.cameraData.renderer.cameraDepthTarget;
SetUpDisturbanceMask(renderingData.cameraData.cameraTargetDescriptor,cmd);
#endif
}
private readonly Color _clearDisturbanceMaskColor = new Color(0.5f, 0.5f, 0f, 1f);
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{
#if UNIVERSAL_RP_13_1_2_OR_NEWER
ConfigureTarget(_DisturbanceMaskRTHandle, _cameraDepthRTHandle);
#else
ConfigureTarget(_DisturbanceMaskRTID, _cameraDepthRTHandle);
#endif
//将RT清空
ConfigureClear(ClearFlag.Color, _clearDisturbanceMaskColor);
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (!(renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView))
return;
if (!_renderMaskMat)
{
return;
}
var DisturbanceDraw = CreateDrawingSettings(_shaderTag, ref renderingData, renderingData.cameraData.defaultOpaqueSortFlags);
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, _profilingSampler))
{
context.DrawRenderers(renderingData.cullResults, ref DisturbanceDraw, ref _Filtering);
#if UNIVERSAL_RP_13_1_2_OR_NEWER
_renderMaskMat.SetTexture(CameraTexture, _DisturbanceMaskRTHandle);
switch (_downSampling)
{
case Downsampling._2xBilinear:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
break;
case Downsampling._4xBilinear:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
break;
case Downsampling._4xBox:
_renderMaskMat.SetFloat(SampleOffset, 2);
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 1);
break;
default:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
break;
}
#else
// cmd.SetGlobalTexture(_DisturbanceMaskRTID, _DisturbanceMaskRTHandle);
//Bug:在非播放状态时，_DisturbanceMaskRTID在这里会经常丢失。造成画面闪烁。但是，只要有一个DistortObject在Scene中，并LockInspector，就不会闪烁，非常奇怪。
cmd.SetGlobalTexture(CameraTexture, _DisturbanceMaskRTHandle);
// _renderMaskMat.SetTexture(CameraTexture, Shader.GetGlobalTexture(_DisturbanceMaskRTID));
cmd.SetRenderTarget(_DownRT);
switch (_downSampling)
{
case Downsampling._2xBilinear:
// Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.Blit(_DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _renderMaskMat, 0, 2);
Blit(cmd, _DisturbanceMaskRTHandle,_DownRT,_renderMaskMat,0);
break;
case Downsampling._4xBilinear:
// Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.Blit(_DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _renderMaskMat, 0, 2);
Blit(cmd, _DisturbanceMaskRTHandle,_DownRT,_renderMaskMat,0);
break;
case Downsampling._4xBox:
_renderMaskMat.SetFloat(SampleOffset, 2);
// Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 1);
// cmd.Blit(_DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 1);
// cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _renderMaskMat, 0, 3);
Blit(cmd, _DisturbanceMaskRTHandle,_DownRT,_renderMaskMat,1);
break;
default:
// Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.Blit(_DisturbanceMaskRTHandle, _DownRT, _renderMaskMat, 0);
// cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _renderMaskMat, 0, 2);
Blit(cmd, _DisturbanceMaskRTHandle,_DownRT,_renderMaskMat,0);
break;
}
#endif
cmd.SetGlobalTexture("_DisturbanceMaskTex", _DownRT);
}
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
#if !UNIVERSAL_RP_13_1_2_OR_NEWER
// Cleanup any allocated resources that were created during the execution of this render pass.
public override void OnCameraCleanup(CommandBuffer cmd)
{
cmd.ReleaseTemporaryRT(_DisturbanceMaskRTID);
cmd.ReleaseTemporaryRT(_DownRTID);
}
//JustForSimple
public void Dispose()
{
}
#else
public void Dispose()
{
_DisturbanceMaskRTHandle?.Release();
_DownRT?.Release();
}
#endif
}
public class NBPostProcessRenderPass : ScriptableRenderPass
{
private ProfilingSampler _profilingSampler;
public static Material _material;
public Mesh _fullScreenMesh;
public NBPostProcessFlags _shaderFlag => PostProcessingManager.flags;
private Vector4 _lastOutlineProps;
public Vector4 outLinePorps = Vector4.one;
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (!(renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView))
return;
// if(!_shaderFlag.CheckFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON))return;//Disturbance需要执行
//ConfigureTarget()
CommandBuffer cmdBuffer = CommandBufferPool.Get();
cmdBuffer.Clear();
// cmdBuffer.name = "NBPostProcess";
using (new ProfilingScope(cmdBuffer,_profilingSampler))
{
Camera camera = renderingData.cameraData.camera;
cmdBuffer.SetViewProjectionMatrices(Matrix4x4.identity, Matrix4x4.identity);
if(_material == null) return;
cmdBuffer.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _material, 0, 0);
cmdBuffer.SetViewProjectionMatrices(camera.worldToCameraMatrix, camera.projectionMatrix);
}
context.ExecuteCommandBuffer(cmdBuffer);
CommandBufferPool.Release(cmdBuffer);
}
public NBPostProcessRenderPass(Material mat,Mesh mesh)
{
_material = mat;
_fullScreenMesh = mesh;
_profilingSampler ??= new ProfilingSampler("NBPostProcess");
}
}
}

11
Packages/NBPostProcessing/Runtime/NBPostProcess.cs.meta Normal file
View File

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

36
Packages/NBPostProcessing/Runtime/NBPostprocessFlags.cs Normal file
View File

@@ -0,0 +1,36 @@
using UnityEngine;
public class NBPostProcessFlags: ShaderFlagsBase
{
public const string FlagsName = "_NBPostProcessFlags";
public static int FlagsId = Shader.PropertyToID(FlagsName);
protected override int GetShaderFlagsId(int index = 0)
{
return FlagsId;
}
protected override string GetShaderFlagsName(int index = 0)
{
return FlagsName;
}
public NBPostProcessFlags(Material material = null): base(material)
{
}
public const int FLAG_BIT_NB_POSTPROCESS_ON = 1 << 0;
public const int FLAG_BIT_DISTORT_SPEED = 1 << 1;
public const int FLAG_BIT_OVERLAYTEXTURE = 1 << 2;
public const int FLAG_BIT_FLASH = 1 << 3;
public const int FLAG_BIT_CHORATICABERRAT = 1 << 4;
public const int FLAG_BIT_RADIALBLUR = 1 << 5;
public const int FLAG_BIT_VIGNETTE = 1 << 6;
public const int FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD = 1 << 7;
public const int FLAG_BIT_OVERLAYTEXTURE_MASKMAP = 1 << 8;
public const int FLAG_BIT_POST_DISTORT_SCREEN_UV = 1 << 9;//默认来自于PolarUV
public const int FLAG_BIT_RADIALBLUR_BY_DISTORT = 1 << 10;//默认来自于PolarUV
public const int FLAG_BIT_CHORATICABERRAT_BY_DISTORT = 1 << 11;//默认来自于PolarUV
}

11
Packages/NBPostProcessing/Runtime/NBPostprocessFlags.cs.meta Normal file
View File

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

602
Packages/NBPostProcessing/Runtime/PostProcessingController.cs Normal file
View File

@@ -0,0 +1,602 @@
using System;
using UnityEngine;
// using Sirenix.OdinInspector;
#if CINIMACHINE_3_0
using Unity.Cinemachine;
#endif
// using Unity.Cinemachine.Editor;
#if UNITY_EDITOR
using UnityEditor.AnimatedValues;
using UnityEditor;
#endif
[ExecuteInEditMode]
public class PostProcessingController : MonoBehaviour
{
#if UNITY_EDITOR
public AnimBool[] AnimBools = new AnimBool[10];
#endif
// [ShowInInspector][ReadOnly]
[SerializeField]
private PostProcessingManager _manager;
public int index
{
get
{
return _index;
}
}
// [ShowInInspector][ReadOnly]
private int _index;
public void SetIndex(int controllerIndex)
{
_index = controllerIndex;
}
// [OnValueChanged("SetScreenCenterPos")]
// [LabelText("自定义屏幕中心")]
public Vector2 customScreenCenterPos = new Vector2(0.5f, 0.5f);
private Vector2 _lastCustomScreenCenterPos = new Vector2(0.5f, 0.5f);
// [OnValueChanged("SetToggles")]
// [ToggleGroup("chromaticAberrationToggle", "色散")]
// [OnValueChanged("InitAllSettings")]
public bool chromaticAberrationToggle = false;
// [OnValueChanged("SetUVFromDistort")]
// [LabelText("色散UV跟随后处理扭曲")]
// [ToggleGroup("chromaticAberrationToggle")]
public bool caFromDistort = false;
// [LabelText("色散强度")]
// [ToggleGroup("chromaticAberrationToggle")]
public float chromaticAberrationIntensity = 0.2f;
// [HideIf("caFromDistort")]
// [LabelText("色散位置")]
// [ToggleGroup("chromaticAberrationToggle")]
public float chromaticAberrationPos = 0.5f;
// [HideIf("caFromDistort")]
// [LabelText("色散过渡范围")]
// [ToggleGroup("chromaticAberrationToggle")]
public float chromaticAberrationRange = 0.5f;
// [OnValueChanged("SetToggles")]
// [ToggleGroup("distortSpeedToggle", "扭曲")]
public bool distortSpeedToggle = false;
// [ToggleGroup("distortSpeedToggle")]
// [LabelText("后处理走常规屏幕坐标")]
// [OnValueChanged("SetUVFromDistort")]
public bool distortScreenUVMode = false;
// [LabelText("后处理扭曲")]
// [ToggleGroup("distortSpeedToggle")]
// [OnValueChanged("InitAllSettings")]
public Texture2D distortSpeedTexture;
// [LabelText("扭曲贴图中间值")]
// [ToggleGroup("distortSpeedToggle")]
// [OnValueChanged("SetTexture")]
public float distortTextureMidValue = 1;
// [LabelText("扭曲贴图ST")]
// [ToggleGroup("distortSpeedToggle")]
public Vector4 distortSpeedTexSt = new Vector4(30,1,0,0);
// [LabelText("扭曲强度")]
// [ToggleGroup("distortSpeedToggle")]
public float distortSpeedIntensity = 1f;
// [HideIf("distortScreenUVMode")]
// [LabelText("扭曲位置")]
// [ToggleGroup("distortSpeedToggle")]
public float distortSpeedPosition = 0.5f;
// [HideIf("distortScreenUVMode")]
// [LabelText("扭曲范围")]
// [ToggleGroup("distortSpeedToggle")]
public float distortSpeedRange = 1f;
// [LabelText("扭曲纹理流动X")]
// [ToggleGroup("distortSpeedToggle")]
public float distortSpeedMoveSpeedX = 0.1f;
// [LabelText("扭曲纹理流动Y")]
// [ToggleGroup("distortSpeedToggle")]
public float distortSpeedMoveSpeed = -0.5f;//因为老的做法是没有X偏移的，只有Y的偏移，不改变量兼容老做法。
private readonly int _distortSpeedTextureID = Shader.PropertyToID("_SpeedDistortMap");
private readonly int _distortSpeedTextureStID = Shader.PropertyToID("_SpeedDistortMap_ST");
// [ToggleGroup("radialBlurToggle", "径向模糊")]
// [OnValueChanged("InitAllSettings")]
public bool radialBlurToggle = false;
// [OnValueChanged("SetUVFromDistort")]
// [ToggleGroup("radialBlurToggle")] [LabelText("径向模糊跟随后处理扭曲")]
public bool radialBlurFromDistort = false;
// [ToggleGroup("radialBlurToggle")]
// [LabelText("采样次数")]
[Range(1,12)]
public int radialBlurSampleCount = 4;
// [ToggleGroup("radialBlurToggle")]
// [LabelText("强度")]
public float radialBlurIntensity = 1;
// [HideIf("radialBlurFromDistort")]
// [LabelText("位置")]
// [ToggleGroup("radialBlurToggle")]
public float radialBlurPos = 0.5f;
// [HideIf("radialBlurFromDistort")]
// [LabelText("过度范围")]
// [ToggleGroup("radialBlurToggle")]
public float radialBlurRange = 0.5f;
#if CINIMACHINE_3_0
// [OnValueChanged("SetToggles")]
// [ToggleGroup("cameraShakeToggle", "震屏")]
// [OnValueChanged("InitAllSettings")]
public bool cameraShakeToggle = false;
// [ToggleGroup("cameraShakeToggle")]
// [LabelText("绑定Cinemachine相机")]
// [OnValueChanged("InitCinemachineCamera")]
public CinemachineCamera cinemachineCamera;
// [ToggleGroup("cameraShakeToggle")]
// [LabelText("相机震动强度")]
public float cameraShakeIntensity;
#endif
// [ToggleGroup("overlayTextureToggle", "肌理叠加图")]
// [OnValueChanged("InitAllSettings")]
public bool overlayTextureToggle = false;
// [LabelText("肌理图极坐标模式")] [ToggleGroup("overlayTextureToggle")]
// [OnValueChanged("SetTexture")]
public bool overlayTexturePolarCoordMode = false;
// [ToggleGroup("overlayTextureToggle")]
// [LabelText("肌理图")]
// [OnValueChanged("SetTexture")]
public Texture2D overlayTexture;
private readonly int _overlayTextureID = Shader.PropertyToID("_TextureOverlay");
private readonly int _overlayTextureStID = Shader.PropertyToID("_TextureOverlay_ST");
private readonly int _textureOverlayAnimProperty = Shader.PropertyToID("_TextureOverlayAnim");
private readonly int _textureOverlayMaskProperty = Shader.PropertyToID("_TextureOverlayMask");
private readonly int _textureOverlayMaskStProperty = Shader.PropertyToID("_TextureOverlayMask_ST");
// [LabelText("肌理图缩放平移")] [ToggleGroup("overlayTextureToggle")]
public Vector4 overlayTextureSt = new Vector4(1, 1, 0, 0);
// [LabelText("肌理图偏移动画")] [ToggleGroup("overlayTextureToggle")]
public Vector2 overlayTextureAnim = new Vector2(0, 0);
// [LabelText("肌理图强度")] [ToggleGroup("overlayTextureToggle")]
public float overlayTextureIntensity = 1f;
// [LabelText("肌理图蒙板")] [ToggleGroup("overlayTextureToggle")]
// [OnValueChanged("SetTexture")]
public Texture2D overlayMaskTexture;
// [LabelText("肌理图蒙板缩放平移")] [ToggleGroup("overlayTextureToggle")]
public Vector4 overlayMaskTextureSt;
// [ToggleGroup("flashToggle", "反闪")]
// [OnValueChanged("InitAllSettings")]
public bool flashToggle = false;
// [LabelText("反转度")] [ToggleGroup("flashToggle")]
public float flashInvertIntensity = 1f;
// [LabelText("饱和度")] [ToggleGroup("flashToggle")]
public float flashDeSaturateIntensity = 1f;
// [LabelText("对比度")] [ToggleGroup("flashToggle")]
public float flashContrast = 1f;
public Color flashColor = new Color(1f,1f,1f,1f);
// [ToggleGroup("vignetteToggle", "暗角")]
// [OnValueChanged("InitAllSettings")]
public bool vignetteToggle = false;
// [ToggleGroup("vignetteToggle")]
// [LabelText("暗角颜色")]
public Color vignetteColor = Color.black;
private readonly int _vignetteColorID = Shader.PropertyToID("_VignetteColor");
// [ToggleGroup("vignetteToggle")]
// [LabelText("暗角强度")]
public float vignetteIntensity = 1;
// [ToggleGroup("vignetteToggle")]
// [LabelText("暗角圆度")]
public float vignetteRoundness = 1;
// [ToggleGroup("vignetteToggle")]
// [LabelText("暗角平滑度")]
public float vignetteSmothness = 10;
public void InitController()
{
if (this.isActiveAndEnabled == false)
{
return;
}
_manager = PostProcessingManager.Instance;
_manager.InitController(this);
InitAllSettings();
}
void InitAllSettings()
{
SetScreenCenterPos();
SetToggles();
SetUVFromDistort();
SetTexture();
#if CINIMACHINE_3_0
InitCinemachineCamera();
#endif
}
void SetScreenCenterPos()
{
PostProcessingManager.customScreenCenterPos = customScreenCenterPos;
_lastCustomScreenCenterPos = customScreenCenterPos;
}
void SetUVFromDistort()
{
PostProcessingManager.isDistortScreenUVMode = distortScreenUVMode;
PostProcessingManager.isCaByDistort = caFromDistort;
PostProcessingManager.isRadialBlurByDistort = radialBlurFromDistort;
}
private void SetTexture()
{
if(PostProcessingManager.material == null) return;
if (distortSpeedToggle)
{
if (distortSpeedTexture != null)
{
PostProcessingManager.material.SetTexture(_distortSpeedTextureID, distortSpeedTexture);
PostProcessingManager.distortTextureMidValue = distortTextureMidValue;
}
else
{
PostProcessingManager.material.SetTexture(_distortSpeedTextureID, null);
}
}
if (overlayTextureToggle)
{
if (overlayTexturePolarCoordMode)
{
PostProcessingManager.flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD);
}
else
{
PostProcessingManager.flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD);
}
if (overlayTexture)
{
Debug.Log("SetOverlayTexture");
PostProcessingManager.material.SetTexture(_overlayTextureID,overlayTexture);
}
else
{
Debug.Log("ClearOverlayTexture");
PostProcessingManager.material.SetTexture(_overlayTextureID,null);
}
if (overlayMaskTexture)
{
Debug.Log("SetOverlayMaskTexture");
PostProcessingManager.material.SetTexture(_textureOverlayMaskProperty,overlayMaskTexture);
PostProcessingManager.flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE_MASKMAP);
}
else
{
Debug.Log("ClearOverlayMaskTexture");
PostProcessingManager.flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE_MASKMAP);
}
}
}
private void SetToggles()
{
SetBit(ref PostProcessingManager.chromaticAberrationToggles,index,chromaticAberrationToggle);
SetBit(ref PostProcessingManager.distortSpeedToggles,index,distortSpeedToggle);
#if CINIMACHINE_3_0
SetBit(ref PostProcessingManager.cameraShakeToggles,index,cameraShakeToggle);
#endif
SetBit(ref PostProcessingManager.overlayTextureToggles,index,overlayTextureToggle);
SetBit(ref PostProcessingManager.flashToggles,index,flashToggle);
SetBit(ref PostProcessingManager.radialBlurToggles,index,radialBlurToggle);
SetBit(ref PostProcessingManager.vignetteToggles,index,vignetteToggle);
#if UNITY_EDITOR
SetTexture();
#endif
}
private void ClearToggles()
{
SetBit(ref PostProcessingManager.chromaticAberrationToggles,index,false);
SetBit(ref PostProcessingManager.distortSpeedToggles,index,false);
#if CINIMACHINE_3_0
SetBit(ref PostProcessingManager.cameraShakeToggles,index,false);
#endif
SetBit(ref PostProcessingManager.overlayTextureToggles,index,false);
SetBit(ref PostProcessingManager.flashToggles,index,false);
SetBit(ref PostProcessingManager.radialBlurToggles,index,false);
SetBit(ref PostProcessingManager.vignetteToggles,index,false);
}
private bool _lastChormaticAberrationToggle = false;
private bool _lastDistortSpeedToggle = false;
#if CINIMACHINE_3_0
private bool _lastCamerashakeToggle = false;
#endif
private bool _lastOverlayTextureToggle = false;
private bool _lastFlashToggle= false;
private bool _lastRadialBlurToggle= false;
private bool _lastVignetteToggle= false;
bool checkIfToggleChanged(ref bool lastTogggle, bool currentToggle)
{
if (lastTogggle != currentToggle)
{
lastTogggle = currentToggle;
return true;
}
else
{
return false;
}
}
private static void SetBit(ref int bit, int index,bool bitToggle)
{
if (bitToggle)
{
bit |= (1 << index);
}
else
{
bit &= ~(1 << index);
}
}
// [LabelText("跳过数值锁定")] public bool isSkipUpdate = false;
#if UNITY_EDITOR
// [Button("选择当前Manager")]
void FindManager()
{
UnityEditor.Selection.activeObject = _manager.gameObject;
}
#if CINIMACHINE_3_0
// [Button("选择当前VituralCamera")]
public void FindVirtualCamera()
{
UnityEditor.Selection.activeObject = _manager.currentVirtualCamera;
}
public void InitCinemachineCamera()
{
if (cinemachineCamera)
{
// _perlin = ;
if (!cinemachineCamera.gameObject.TryGetComponent<CinemachineBasicMultiChannelPerlin>(out var _perlin))
{
_perlin = cinemachineCamera.gameObject.AddComponent<CinemachineBasicMultiChannelPerlin>();
}
if (_perlin)
{
_perlin.NoiseProfile =
UnityEditor.AssetDatabase.LoadAssetAtPath<NoiseSettings>(
"Packages/com.xuanxuan.nb.postprocessing/3DPostionShake.asset");
_perlin.FrequencyGain = 5f; //做一个自定义
_perlin.AmplitudeGain = 0f; //一开始先不要震动
}
#if UNITY_EDITOR
if (_manager)
{
_manager.currentVirtualCamera = cinemachineCamera;
}
#endif
}
}
#endif
#endif
private void OnEnable()
{
// Debug.Log("InitController");
InitController();
#if UNITY_EDITOR
// 注册编辑器帧更新事件
EditorApplication.update += ControllerEditorUpdate;
_manager.ReRegistEditorUpdate();//保证Manager的注册在最后
#endif
}
private void OnDisable()
{
// Debug.Log("EndController");
EndController();
#if UNITY_EDITOR
// 注册编辑器帧更新事件
EditorApplication.update -= ControllerEditorUpdate;
#endif
}
bool isFirstUpdate = true;
// Update is called once per frame
void Update()
{
if (isFirstUpdate)
{
isFirstUpdate = false;
return;
}
if(!PostProcessingManager.material) return;
//#if UNITY_EDITOR
//Odin的ToggleGroup和OnValueChange功能冲突，导致不一定生效。不好调试。所以用手动的方式更新。
bool isToggleChanged = false;
isToggleChanged |= checkIfToggleChanged(ref _lastChormaticAberrationToggle, chromaticAberrationToggle);
isToggleChanged |= checkIfToggleChanged(ref _lastDistortSpeedToggle, distortSpeedToggle);
#if CINIMACHINE_3_0
isToggleChanged |= checkIfToggleChanged(ref _lastCamerashakeToggle, cameraShakeToggle);
#endif
isToggleChanged |= checkIfToggleChanged(ref _lastOverlayTextureToggle, overlayTextureToggle);
isToggleChanged |= checkIfToggleChanged(ref _lastFlashToggle, flashToggle);
isToggleChanged |= checkIfToggleChanged(ref _lastRadialBlurToggle, radialBlurToggle);
isToggleChanged |= checkIfToggleChanged(ref _lastVignetteToggle, vignetteToggle);
if (isToggleChanged)
{
SetToggles();
}
//#endif
if (customScreenCenterPos != _lastCustomScreenCenterPos)
{
SetScreenCenterPos();
}
if (chromaticAberrationToggle)
{
PostProcessingManager.chromaticAberrationIntensity =
Mathf.Max(PostProcessingManager.chromaticAberrationIntensity, chromaticAberrationIntensity);
PostProcessingManager.chromaticAberrationPos =
Mathf.Max(PostProcessingManager.chromaticAberrationPos, chromaticAberrationPos);
PostProcessingManager.chromaticAberrationRange =
Mathf.Max(PostProcessingManager.chromaticAberrationRange, chromaticAberrationRange);
}
if (distortSpeedToggle)
{
if (index == PostProcessingManager.laseUpdateControllerIndex)
{
//只有这里才会更新Scale
PostProcessingManager.material.SetVector(_distortSpeedTextureStID, distortSpeedTexSt);
}
PostProcessingManager.distortSpeedIntensity =
Mathf.Max(PostProcessingManager.distortSpeedIntensity, distortSpeedIntensity);
PostProcessingManager.distortSpeedPosition =
Mathf.Max(PostProcessingManager.distortSpeedPosition, distortSpeedPosition);
PostProcessingManager.distortSpeedRange =
Mathf.Max(PostProcessingManager.distortSpeedRange, distortSpeedRange);
PostProcessingManager.distortSpeedMoveSpeedX =
Mathf.Abs(PostProcessingManager.distortSpeedMoveSpeedX) > Mathf.Abs(distortSpeedMoveSpeedX)
? PostProcessingManager.distortSpeedMoveSpeedX
: distortSpeedMoveSpeedX;
PostProcessingManager.distortSpeedMoveSpeedY =
Mathf.Abs(PostProcessingManager.distortSpeedMoveSpeedY) > Mathf.Abs(distortSpeedMoveSpeed)
? PostProcessingManager.distortSpeedMoveSpeedY
: distortSpeedMoveSpeed;
}
#if CINIMACHINE_3_0
if (cameraShakeToggle)
{
PostProcessingManager.cameraShakeIntensity =
Mathf.Max(PostProcessingManager.cameraShakeIntensity, cameraShakeIntensity);
}
#endif
if (overlayTextureToggle)
{
if (index == PostProcessingManager.laseUpdateControllerIndex)
{
PostProcessingManager.material.SetVector(_overlayTextureStID, overlayTextureSt);
PostProcessingManager.material.SetVector(_textureOverlayMaskStProperty, overlayMaskTextureSt);
PostProcessingManager.material.SetVector(_textureOverlayAnimProperty,overlayTextureAnim);
}
PostProcessingManager.overlayTextureIntensity = Mathf.Max(PostProcessingManager.overlayTextureIntensity,
overlayTextureIntensity);
}
if (flashToggle)
{
PostProcessingManager.flashDesaturateIntensity =
Mathf.Max(PostProcessingManager.flashDesaturateIntensity, flashDeSaturateIntensity);
PostProcessingManager.flashInvertIntensity =
Mathf.Max(PostProcessingManager.flashInvertIntensity, flashInvertIntensity);
PostProcessingManager.flashContrast =
Mathf.Max(PostProcessingManager.flashContrast, flashContrast);
PostProcessingManager.flashColor = flashColor;
}
if (radialBlurToggle)
{
PostProcessingManager.radialBlurIntensity =
Mathf.Max(PostProcessingManager.radialBlurIntensity, radialBlurIntensity);
PostProcessingManager.radialBlurSampleCount = Mathf.Max(PostProcessingManager.radialBlurSampleCount,
radialBlurSampleCount);
PostProcessingManager.radialBlurPos = Mathf.Max(PostProcessingManager.radialBlurPos, radialBlurPos);
PostProcessingManager.radialBlurRange = Mathf.Max(PostProcessingManager.radialBlurRange, radialBlurRange);
}
if (vignetteToggle)
{
PostProcessingManager.vignetteIntensity =
Mathf.Max(PostProcessingManager.vignetteIntensity, vignetteIntensity);
PostProcessingManager.vignetteRoundness = Mathf.Max(PostProcessingManager.vignetteRoundness, vignetteRoundness);
PostProcessingManager.vignetteSmothness = Mathf.Max(PostProcessingManager.vignetteSmothness, vignetteSmothness);
if (index == PostProcessingManager.laseUpdateControllerIndex)
{
PostProcessingManager.material.SetColor(_vignetteColorID,vignetteColor);
}
}
}
void EndController()
{
ClearToggles();
_manager.EndController(this);
}
#if UNITY_EDITOR
[UnityEditor.MenuItem("GameObject/创建NB后处理特效")]
static void CreatMenu()
{
GameObject Effect = new GameObject();
Effect.name = "NBPostprocessController";
PostProcessingController controller = Effect.AddComponent<PostProcessingController>();
UnityEditor.Selection.activeObject = Effect;
}
void ControllerEditorUpdate()
{
if (!Application.isPlaying)
{
Update();
}
}
#endif
}

14
Packages/NBPostProcessing/Runtime/PostProcessingController.cs.meta Normal file
View File

@@ -0,0 +1,14 @@
fileFormatVersion: 2
guid: 909ea7d136ae0c349a24f02cac1f5f71
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences:
- manager: {instanceID: 0}
- distortSpeedTexture: {fileID: 2800000, guid: 7f808d0c8608b954d8f20cb4132c3049, type: 3}
- overlayTexture: {instanceID: 0}
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

720
Packages/NBPostProcessing/Runtime/PostProcessingManager.cs Normal file
View File

@@ -0,0 +1,720 @@
using System;
using UnityEngine;
// using Sirenix.OdinInspector;
// #if UNITY_EDITOR
// using Sirenix.OdinInspector.Editor;
// #endif
#if UNITY_EDITOR
using UnityEditor;
#endif
#if CINIMACHINE_3_0
using Unity.Cinemachine;
#endif
using MhRender.RendererFeatures;
[ExecuteAlways]
public class PostProcessingManager : MonoBehaviour
{
//单例实现
private static PostProcessingManager _instance = null;
public static PostProcessingManager Instance
{
get
{
if (_instance == null)
{
#if UNITY_2022_1_OR_NEWER
_instance = FindFirstObjectByType<PostProcessingManager>();
#else
_instance = FindObjectOfType<PostProcessingManager>();
#endif
if (_instance == null)
{
GameObject singletonObj = new GameObject();
_instance = singletonObj.AddComponent<PostProcessingManager>();
if (Application.isPlaying)
{
singletonObj.name = "NBPostProcessManager";
DontDestroyOnLoad(singletonObj);
}
else
{
singletonObj.name = "测试用NB后处理管理器，请美术删除此脚本再上传";
}
}
}
return _instance;
}
}
private void Awake()
{
if (_instance == null)
{
_instance = this;
}
else
{
DestroyImmediate(this);
}
}
// [ReadOnly] public Volume volume;
// private static VolumeProfile profile;
// [ReadOnly]
public static Material material
{
get
{
return NBPostProcess.NBPostProcessMaterial;
}
}
public static NBPostProcessFlags flags = new NBPostProcessFlags();
// public CinemachineBrain cameraBrain;
// public CinemachineVirtualCamera currentVirtualCamera;
#if CINIMACHINE_3_0
public CinemachineCamera currentVirtualCamera;
private CinemachineBasicMultiChannelPerlin _perlin;
#endif
public static void InitMat()
{
flags.SetMaterial(PostProcessingManager.material);
if (_instance)
{
_instance.ResetEffect();
}
}
private void OnEnable()
{
#if UNITY_EDITOR
if (_controllerIndexFlags > 0)
{
ReRegistEditorUpdate();
}
else
{
EditorApplication.update += EditorUpdate;
}
// 注册编辑器帧更新事件
#endif
// //TODO 后续版本要找比较准确快的找Volume的方式
// volume = GameObject.FindObjectOfType<Volume>();
// if (volume != null)
// {
// profile = volume.profile;
// }
// #if UNITY_EDITOR
// //仅仅用于测试。
// if (currentVirtualCamera == null)
// {
// currentVirtualCamera = FindFirstObjectByType<CinemachineCamera>();
//
// if (currentVirtualCamera)
// {
// if (!currentVirtualCamera.gameObject.TryGetComponent<CinemachineBasicMultiChannelPerlin>(out _perlin))
// {
// _perlin = currentVirtualCamera.gameObject.AddComponent<CinemachineBasicMultiChannelPerlin>();
// }
// }
//
// if (_perlin)
// {
// _perlin.NoiseProfile =
// // ResourceManager.LoadAssetAsync<NoiseSettings>("Assets/AddressableAssets/Shader/CustomPostprocess/3DPostionShake.asset");
// //在runtime下是找不到的。但设计是美术做好然后存引用在预制件里。
// UnityEditor.AssetDatabase.LoadAssetAtPath<NoiseSettings>(
// "Packages/com.r2.render.postprocessing/3DPostionShake.asset");
// _perlin.FrequencyGain = 5f; //做一个自定义
// _perlin.AmplitudeGain = 0f; //一开始先不要震动
// }
// }
//
// #endif
//重置Flag
flags = new NBPostProcessFlags(material);
flags.SetFlagBits(0);
}
private void OnDisable()
{
#if UNITY_EDITOR
// 注册编辑器帧更新事件
EditorApplication.update -= EditorUpdate;
#endif
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
}
// [ShowInInspector]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
private int _controllerIndexFlags = 0;
public static int laseUpdateControllerIndex;
private int GetControllerIndex()
{
for (int i = 0; i < 31; i++)
{
if (((~_controllerIndexFlags) & (1 << i)) != 0)
{
_controllerIndexFlags |= (1 << i);
laseUpdateControllerIndex = i;
return i;
}
}
return 32;
}
private void ReleaseControllerIndex(int index)
{
_controllerIndexFlags &= ~(1 << index);
}
private int CountBit(int bit)
{
int count = 0;
while (bit > 0)
{
bit = bit & (bit - 1);
count++;
}
return count;
}
//每次Controller触发Play都会触发Init
public void InitController(PostProcessingController controller)
{
#if CINIMACHINE_3_0
if (controller.cinemachineCamera != null)
{
currentVirtualCamera = controller.cinemachineCamera;
_perlin = currentVirtualCamera.gameObject.GetComponent<CinemachineBasicMultiChannelPerlin>();
}
#endif
controller.SetIndex(GetControllerIndex());
}
public void EndController(PostProcessingController controller)
{
#if CINIMACHINE_3_0
if (currentVirtualCamera == controller.cinemachineCamera)
{
currentVirtualCamera = null;
_perlin = null;
}
#endif
ReleaseControllerIndex(controller.index);
controller.SetIndex(32); //设置32为关闭index
}
private void EffectUpdater(Action initEffect,Action updateEffect,Action endEffect,ref bool lastIsEffect,int effectToggles)
{
if (effectToggles > 0)
{
if (!lastIsEffect)
{
initEffect();
}
updateEffect();
lastIsEffect = true;
}
else
{
if (lastIsEffect)
{
endEffect();
lastIsEffect = false;
}
}
}
private bool isFirstUpdate = true;
private void ResetEffect()
{
if (_lastIsChromaticAberration)
{
EndChromaticAberration();
_lastIsChromaticAberration = false;
}
if (_lastIsRadialBlur)
{
EndRadialBlur();
_lastIsRadialBlur = false;
}
if (_lastIsDistortSpeed)
{
EndDistortSpeed();
_lastIsDistortSpeed = false;
}
#if CINIMACHINE_3_0
if (_lastIsCameraShake)
{
EndCameraShake();
_lastIsCameraShake = false;
}
#endif
if (_lastIsOverlayTexture)
{
EndOverlayTexture();
_lastIsOverlayTexture = false;
}
if (_lastIsFlash)
{
EndFlash();
_lastIsFlash = false;
}
if (_lastIsVignette)
{
EndVignette();
_lastIsVignette = false;
}
}
private void LateUpdate()//晚于所有脚本触发。
{
if (isFirstUpdate)
{
isFirstUpdate = false;
return;
}
if(!material) return;
/*
#if UNITY_EDITOR
if (flags.GetMaterial() != PostProcessingManager.material)
{
flags.SetMaterial(PostProcessingManager.material);
}
#endif
*/
if (_controllerIndexFlags == 0)
{
ResetEffect();
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
return;
}
EffectUpdater(InitChromaticAberration,UpdateChromaticAberration,EndChromaticAberration,ref _lastIsChromaticAberration,chromaticAberrationToggles);
EffectUpdater(InitDistortSpeed,UpdateDistortSpeed,EndDistortSpeed,ref _lastIsDistortSpeed,distortSpeedToggles);
EffectUpdater(InitRadialBlur, UpdateRadialBlur, EndRadialBlur,ref _lastIsRadialBlur, radialBlurToggles);
bool isSetCustomScreenCenterPos = (chromaticAberrationToggles | distortSpeedToggles | radialBlurToggles) > 0;
if (isSetCustomScreenCenterPos)
{
material.SetVector(_customScreenCenterProperty,
new Vector4(customScreenCenterPos.x, customScreenCenterPos.y, 0, 0));
}
#if CINIMACHINE_3_0
EffectUpdater(() => { },UpdateCameraShake,EndCameraShake,ref _lastIsCameraShake,cameraShakeToggles);
#endif
EffectUpdater(InitOverlayTexture, UpdateOverlayTexture, EndOverlayTexture,ref _lastIsOverlayTexture, overlayTextureToggles);
EffectUpdater(InitFlash, UpdateFlash, EndFlash,ref _lastIsFlash, flashToggles);
EffectUpdater(InitVignette, UpdateVignette, EndVignette,ref _lastIsVignette, vignetteToggles);
bool hasEffect =
(
chromaticAberrationToggles|
distortSpeedToggles|
#if CINIMACHINE_3_0
cameraShakeToggles|
#endif
radialBlurToggles|
overlayTextureToggles|
flashToggles|
vignetteToggles
) >0;
if (hasEffect)
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
}
else
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_NB_POSTPROCESS_ON);
}
}
private readonly int _customScreenCenterProperty = Shader.PropertyToID("_CustomScreenCenter");
public static Vector2 customScreenCenterPos = new Vector2(0.5f, 0.5f);
#region 色散
//色散相关
// private ChromaticAberration chromaticAberrationComp;
// private bool preserveChromaticAberrationActive;
// private float preserveChromaticAberrationIntensity;
private bool _lastIsChromaticAberration = false;
private readonly int _chromaticAberrationVecProperty = Shader.PropertyToID("_ChromaticAberrationVec");
public static int chromaticAberrationToggles = 0;
public static bool isCaByDistort= false;
private bool _lastIsCaByDistort = false;
public static float chromaticAberrationIntensity = 0;
public static float chromaticAberrationPos = 0;
public static float chromaticAberrationRange = 0;
private void InitChromaticAberration()
{
// Debug.Log("InitCA");
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT);
}
private void UpdateChromaticAberration()
{
if (_lastIsCaByDistort != isCaByDistort)
{
if (isCaByDistort)
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT_BY_DISTORT);
}
else
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT_BY_DISTORT);
}
_lastIsCaByDistort = isCaByDistort;
}
material.SetVector(_chromaticAberrationVecProperty, new Vector4(chromaticAberrationIntensity,chromaticAberrationPos,chromaticAberrationRange));
chromaticAberrationIntensity = 0;//等待下一次update
chromaticAberrationPos = 0;//等待下一次update
chromaticAberrationRange = 0;//等待下一次update
}
private void EndChromaticAberration()
{
// Debug.Log("EndCA");
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_CHORATICABERRAT);
}
#endregion
#region 径向速度扭曲
//径向速度扭曲相关
private readonly int _distortVecProperty = Shader.PropertyToID("_SpeedDistortVec");
private readonly int _distortVec2Property = Shader.PropertyToID("_SpeedDistortVec2");
private bool _lastIsDistortSpeed = false;
public static bool isDistortScreenUVMode;
private bool _lastIsDistortScreenUVMode;
// [ShowInInspector]
// [LabelText("径向扭曲开关")]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
public static int distortSpeedToggles;
public static Texture2D distortTexture2D;
public static float distortSpeedIntensity = 0;
public static float distortSpeedPosition = 0;
public static float distortSpeedRange = 0;
public static float distortSpeedMoveSpeedX = 0;
public static float distortSpeedMoveSpeedY = 0;
public static float distortTextureMidValue = 0;
private void InitDistortSpeed()
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_DISTORT_SPEED);
}
private void UpdateDistortSpeed()
{
if (_lastIsDistortScreenUVMode!=isDistortScreenUVMode)
{
if (isDistortScreenUVMode)
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_POST_DISTORT_SCREEN_UV);
}
else
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_POST_DISTORT_SCREEN_UV);
}
_lastIsDistortScreenUVMode = isDistortScreenUVMode;
}
Vector4 distortVec = new Vector4(distortSpeedIntensity, distortSpeedPosition, distortSpeedRange,
distortTextureMidValue);
Vector4 distortVec2 = new Vector4(distortSpeedMoveSpeedX, distortSpeedMoveSpeedY, 0, 0);
material.SetVector(_distortVecProperty, distortVec);
material.SetVector(_distortVec2Property, distortVec2);
distortSpeedIntensity = 0;
distortSpeedPosition = 0;
distortSpeedRange = 0;
distortSpeedMoveSpeedX = 0;
distortSpeedMoveSpeedY = 0;
}
private void EndDistortSpeed()
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_DISTORT_SPEED);
}
#endregion
#region 径向模糊
// [ShowInInspector]
// [LabelText("径向模糊开关")]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
public static int radialBlurToggles = 0;
private readonly int _radialBlurVecProperty = Shader.PropertyToID("_RadialBlurVec");
public static float radialBlurIntensity = 0;
public static float radialBlurPos = 0;
public static float radialBlurRange = 0;
public static int radialBlurSampleCount = 4;
public static bool isRadialBlurByDistort = false;
private bool _lastIsRadialBlurByDistort = false;
private bool _lastIsRadialBlur = false;
private void InitRadialBlur()
{
// Debug.Log("InitRB");
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR);
}
private void UpdateRadialBlur()
{
if (_lastIsRadialBlurByDistort != isRadialBlurByDistort)
{
if (isRadialBlurByDistort)
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR_BY_DISTORT);
}
else
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR_BY_DISTORT);
}
_lastIsRadialBlurByDistort = isRadialBlurByDistort;
}
Vector4 radialBlurVec = new Vector4(radialBlurIntensity*0.1f/radialBlurSampleCount, radialBlurPos, radialBlurRange, radialBlurSampleCount);
material.SetVector(_radialBlurVecProperty,radialBlurVec);
radialBlurIntensity = 0;
radialBlurSampleCount = 0;
radialBlurPos = 0;
radialBlurRange = 0;
}
private void EndRadialBlur()
{
// Debug.Log("EndRB");
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_RADIALBLUR);
}
#endregion
#region 震屏
#if CINIMACHINE_3_0
public static int cameraShakeToggles = 0;
private bool _lastIsCameraShake = false;
public static float cameraShakeIntensity = 0;
private void UpdateCameraShake()
{
if (_perlin)
{
_perlin.AmplitudeGain = cameraShakeIntensity;
}
cameraShakeIntensity = 0;
// #if UNITY_EDITOR
if (currentVirtualCamera )
{
CinemachineCore.SoloCamera = currentVirtualCamera;
}
// #endif
// Debug.Log(_perlin.m_AmplitudeGain);
}
private void EndCameraShake()
{
if (_perlin)
{
_perlin.AmplitudeGain = 0;
}
CinemachineCore.SoloCamera = null;
}
#endif
#endregion
#region 肌理叠加
//肌理图
//注意，肌理图就是硬切，只有intensity可以做差值。
// [ShowInInspector]
// [LabelText("肌理开关")]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
public static int overlayTextureToggles = 0;
private bool _lastIsOverlayTexture = false;
public static float overlayTextureIntensity = 0;
private readonly int _overlayTextureProperty = Shader.PropertyToID("_TextureOverlay");
private readonly int _overlayTextureStProperty = Shader.PropertyToID("_TextureOverlay_ST");
private readonly int _overlayTextureIntensityProperty = Shader.PropertyToID("_TextureOverlayIntensity");
private void InitOverlayTexture()
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE);
}
private void UpdateOverlayTexture()
{
material.SetFloat(_overlayTextureIntensityProperty, overlayTextureIntensity);
overlayTextureIntensity = 0;
}
private void EndOverlayTexture()
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_OVERLAYTEXTURE);
}
#endregion
#region 黑白闪
// [ShowInInspector]
// [LabelText("黑白闪开关")]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
public static int flashToggles = 0;
private bool _lastIsFlash = false;
public static float flashDesaturateIntensity = 0;
public static float flashInvertIntensity = 0;
public static float flashContrast = 0;
public static Color flashColor = new Color(1, 1, 1, 1);
private readonly int _flashDesaturateProperty = Shader.PropertyToID("_DeSaturateIntensity");
private readonly int _flashInvertProperty = Shader.PropertyToID("_InvertIntensity");
private readonly int _flashContrastProperty = Shader.PropertyToID("_Contrast");
private readonly int _flashColorProperty = Shader.PropertyToID("_FlashColor");
private void InitFlash()
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_FLASH);
}
private void UpdateFlash()
{
material.SetFloat(_flashDesaturateProperty, flashDesaturateIntensity);
material.SetFloat(_flashInvertProperty, flashInvertIntensity);
material.SetFloat(_flashContrastProperty, flashContrast);
material.SetColor(_flashColorProperty,flashColor);
flashDesaturateIntensity = 0;
flashInvertIntensity = 0;
flashContrast = 0;
flashColor = Color.white;
}
private void EndFlash()
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_FLASH);
}
#endregion
#region 暗角
// [ShowInInspector]
// [LabelText("暗角开关")]
// #if UNITY_EDITOR
// [BinaryInt(8)]
// #endif
public static int vignetteToggles = 0;
private bool _lastIsVignette;
public static float vignetteIntensity = 0f;
public static float vignetteRoundness = 0f;
public static float vignetteSmothness = 0f;
private readonly int _vignetteVecProperty = Shader.PropertyToID("_VignetteVec");
private void InitVignette()
{
flags.SetFlagBits(NBPostProcessFlags.FLAG_BIT_VIGNETTE);
}
private void UpdateVignette()
{
Vector4 vignetteVec = new Vector4(vignetteIntensity, vignetteRoundness, vignetteSmothness, 0);
material.SetVector(_vignetteVecProperty,vignetteVec);
vignetteIntensity = 0;
vignetteRoundness = 0;
vignetteSmothness = 0;
}
private void EndVignette()
{
flags.ClearFlagBits(NBPostProcessFlags.FLAG_BIT_VIGNETTE);
}
#endregion
#if UNITY_EDITOR
void EditorUpdate()
{
if (!Application.isPlaying)
{
LateUpdate();//每帧Update会导致SceneView闪
}
}
public void ReRegistEditorUpdate()
{
EditorApplication.update -= EditorUpdate;
EditorApplication.update += EditorUpdate;
}
#endif
}

11
Packages/NBPostProcessing/Runtime/PostProcessingManager.cs.meta Normal file
View File

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

189
Packages/NBPostProcessing/Runtime/ScreenColorRenderPass.cs Normal file
View File

@@ -0,0 +1,189 @@
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using System.Reflection;
namespace MhRender.RendererFeatures
{
public class ScreenColorRenderPass : ScriptableRenderPass
{
#if UNIVERSAL_RP_13_1_2_OR_NEWER
private RTHandle _screenColorHandle;
private RTHandle _tempRTHandle;
#else
private RenderTargetIdentifier _screenColorHandle;
private static readonly int _screenColorRTID = Shader.PropertyToID("_screenColorRT");
private RenderTargetIdentifier _tempRTHandle = new RenderTargetIdentifier(_tempRTID);
private static readonly int _tempRTID = Shader.PropertyToID("CopyColorRT");
#endif
private ProfilingSampler _profilingSampler;
private readonly Downsampling _downSampling;
readonly Material _material;
private static readonly int CameraTexture = Shader.PropertyToID("_CameraTexture");
private static readonly int SampleOffset = Shader.PropertyToID("_SampleOffset");
public ScreenColorRenderPass(Material material, Downsampling downSampling)
{
_material = material;
_downSampling = downSampling;
}
#if UNIVERSAL_RP_13_1_2_OR_NEWER
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{
ConfigureTarget(_screenColorHandle);
}
public void SetUp(RTHandle colorHandle)
{
_profilingSampler ??= new ProfilingSampler("ScreenColorRender");
_screenColorHandle = colorHandle;
RenderTextureDescriptor descriptor = _screenColorHandle.rt.descriptor;
descriptor.autoGenerateMips = true;
descriptor.useMipMap = true;
switch (_downSampling)
{
case Downsampling._2xBilinear:
descriptor.width /= 2;
descriptor.height /= 2;
break;
case Downsampling._4xBilinear:
descriptor.width /= 4;
descriptor.height /= 4;
break;
case Downsampling._4xBox:
descriptor.width /= 4;
descriptor.height /= 4;
break;
}
RenderingUtils.ReAllocateIfNeeded(ref _tempRTHandle, descriptor,name:"CopyColorRT");
}
#else
FieldInfo cameraColorAttachment = typeof(UniversalRenderer).GetField("m_ActiveCameraColorAttachment", BindingFlags.NonPublic|BindingFlags.Instance);
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
{
var renderer = (UniversalRenderer)renderingData.cameraData.renderer;
// cmd.SetGlobalTexture(_screenColorRTID,_screenColorHandle);
SetUpCopyColorRT(renderer,renderingData.cameraData.cameraTargetDescriptor,cmd);
ConfigureTarget(_tempRTHandle);
ConfigureClear(ClearFlag.Color, Color.clear);
}
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
{
}
public void SetUp(ScriptableRenderer renderer)
{
RenderTargetHandle value = (RenderTargetHandle)cameraColorAttachment.GetValue(renderer);
_screenColorHandle = value.Identifier();
// _screenColorHandle = colorTarget;
}
public void SetUpCopyColorRT(ScriptableRenderer renderer,RenderTextureDescriptor descriptor ,CommandBuffer cmd)
{
descriptor.autoGenerateMips = true;
descriptor.useMipMap = true;
switch (_downSampling)
{
case Downsampling._2xBilinear:
descriptor.width /= 2;
descriptor.height /= 2;
break;
case Downsampling._4xBilinear:
descriptor.width /= 4;
descriptor.height /= 4;
break;
case Downsampling._4xBox:
descriptor.width /= 4;
descriptor.height /= 4;
break;
}
cmd.GetTemporaryRT( _tempRTID, descriptor,FilterMode.Bilinear);
}
public override void OnCameraCleanup(CommandBuffer cmd)
{
cmd.ReleaseTemporaryRT(_tempRTID);
}
#endif
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (!(renderingData.cameraData.cameraType == CameraType.Game || renderingData.cameraData.cameraType == CameraType.SceneView))
return;
if (_material == null)
return;
CommandBuffer cmd = CommandBufferPool.Get();
using (new ProfilingScope(cmd, _profilingSampler))
{
#if UNIVERSAL_RP_13_1_2_OR_NEWER
_material.SetTexture(CameraTexture, _screenColorHandle);
switch (_downSampling)
{
case Downsampling._2xBilinear:
Blitter.BlitTexture(cmd, _screenColorHandle, _tempRTHandle, _material, 0);
break;
case Downsampling._4xBilinear:
Blitter.BlitTexture(cmd, _screenColorHandle, _tempRTHandle, _material, 0);
break;
case Downsampling._4xBox:
_material.SetFloat(SampleOffset,2);
Blitter.BlitTexture(cmd, _screenColorHandle, _tempRTHandle, _material, 1);
break;
default:
Blitter.BlitTexture(cmd, _screenColorHandle, _tempRTHandle, _material, 0);
break;
}
#else
cmd.SetGlobalTexture(_screenColorRTID,_screenColorHandle);
_material.SetTexture(CameraTexture,Shader.GetGlobalTexture(_screenColorRTID));
cmd.SetRenderTarget(_tempRTHandle);
switch (_downSampling)
{
case Downsampling._2xBilinear:
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _material, 0,0);
break;
case Downsampling._4xBilinear:
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _material, 0,0);
break;
case Downsampling._4xBox:
_material.SetFloat(SampleOffset,2);
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _material, 0,1);
break;
default:
cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, _material, 0,0);
break;
}
#endif
cmd.SetGlobalTexture("_ScreenColorCopy1", _tempRTHandle);
}
context.ExecuteCommandBuffer(cmd);
cmd.Clear();
CommandBufferPool.Release(cmd);
}
public void Dispose()
{
#if UNIVERSAL_RP_13_1_2_OR_NEWER
_tempRTHandle?.Release();
#endif
}
}
}

11
Packages/NBPostProcessing/Runtime/ScreenColorRenderPass.cs.meta Normal file
View File

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

30
Packages/NBPostProcessing/Runtime/com.xuanxuan.nb.postprocessing.asmdef Normal file
View File

@@ -0,0 +1,30 @@
{
"name": "com.xuanxuan.nb.postprocessing",
"rootNamespace": "",
"references": [
"GUID:df380645f10b7bc4b97d4f5eb6303d95",
"GUID:15fc0a57446b3144c949da3e2b9737a9",
"GUID:4307f53044263cf4b835bd812fc161a4",
"GUID:8f9e4d586616f13449cfeb86c5f704c2"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [
{
"name": "com.unity.cinemachine",
"expression": "3.0",
"define": "CINIMACHINE_3_0"
},
{
"name": "com.unity.render-pipelines.universal",
"expression": "13.1.2",
"define": "UNIVERSAL_RP_13_1_2_OR_NEWER"
}
],
"noEngineReferences": false
}

7
Packages/NBPostProcessing/Runtime/com.xuanxuan.nb.postprocessing.asmdef.meta Normal file
View File

@@ -0,0 +1,7 @@
fileFormatVersion: 2
guid: a1f23b61b189bd949adfd0f7a353734f
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant: