Soullies/ichni_Official
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新了NB Shader，少量优化GPU

Browse Source
This commit is contained in:
SoulliesOfficial
2026-07-17 17:34:36 -04:00
parent 02efc1b95b
commit b00ac27e3a
194 changed files with 7870 additions and 17669 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Packages/NBPostProcessing/.gitignore vendored
View File

@@ -1 +0,0 @@
Runtime/.idea

BIN
Packages/NBPostProcessing/3DPostionShake.asset LFS
View File

Binary file not shown.

8
Packages/NBPostProcessing/3DPostionShake.asset.meta
View File

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

8
Packages/NBPostProcessing/Editor.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 0b3052f0c1288a045a0be3d63f109623
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

358
Packages/NBPostProcessing/Editor/PostProcessingControllerGUI.cs
View File

@@ -1,358 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.AnimatedValues;
using System.Reflection;
#if CINIMACHINE_3_0
using Unity.Cinemachine;
#endif
using System;
// using Unity.Properties;
[CustomEditor(typeof(PostProcessingController))]
public class PostProcessingControllerGUI : Editor
{
private SerializedProperty _managerProperty;
private SerializedProperty _indexProperty;
private Action delayExcuteReflect = () => { };
public override void OnInspectorGUI()
{
PostProcessingController ppController = (PostProcessingController)target;
serializedObject.Update();
_managerProperty = serializedObject.FindProperty("_manager");
_indexProperty = serializedObject.FindProperty("_index");
EditorGUI.BeginDisabledGroup(true);
EditorGUILayout.PropertyField(_managerProperty);
EditorGUI.EndDisabledGroup();
EditorGUI.BeginChangeCheck();
// ppController.customScreenCenterPos = EditorGUILayout.Vector2Field("自定义屏幕中心", ppController.customScreenCenterPos);
SerializedProperty customScreenCenterPosProp = serializedObject.FindProperty("customScreenCenterPos");
EditorGUILayout.PropertyField(customScreenCenterPosProp,new GUIContent("自定义屏幕中心"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetScreenCenterPos", ppController);
}
SerializedProperty caToggleProp = serializedObject.FindProperty("chromaticAberrationToggle");
DrawToggleFoldOut(ppController.AnimBools[0], "色散", caToggleProp,
drawEndChangeCheck: isChangeToggle => { ReflectMethod("InitAllSettings", ppController); }
, drawBlock: isToggle =>
{
EditorGUI.BeginChangeCheck();
// ppController.caFromDistort = EditorGUILayout.Toggle("色散UV跟随后处理扭曲", ppController.caFromDistort);
SerializedProperty caFromDistortProp = serializedObject.FindProperty("caFromDistort");
EditorGUILayout.PropertyField(caFromDistortProp, new GUIContent("色散UV跟随后处理扭曲"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetUVFromDistort", ppController);
}
// ppController.chromaticAberrationIntensity = EditorGUILayout.FloatField("色散强度", ppController.chromaticAberrationIntensity);
SerializedProperty caIntensityProps = serializedObject.FindProperty("chromaticAberrationIntensity");
EditorGUILayout.PropertyField(caIntensityProps, new GUIContent("色散强度"));
if (!ppController.caFromDistort)
{
// ppController.chromaticAberrationPos = EditorGUILayout.FloatField("色散位置", ppController.chromaticAberrationPos);
SerializedProperty caPosProp = serializedObject.FindProperty("chromaticAberrationPos");
EditorGUILayout.PropertyField(caPosProp, new GUIContent("色散位置"));
// ppController.chromaticAberrationRange = EditorGUILayout.FloatField("色散过渡范围", ppController.chromaticAberrationRange);
SerializedProperty caRangeProp = serializedObject.FindProperty("chromaticAberrationRange");
EditorGUILayout.PropertyField(caRangeProp, new GUIContent("色散过渡范围"));
}
});
SerializedProperty distortSpeedToggleProp = serializedObject.FindProperty("distortSpeedToggle");
DrawToggleFoldOut(ppController.AnimBools[1], "扭曲", distortSpeedToggleProp, drawEndChangeCheck:
isChangeToggle => { ReflectMethod("InitAllSettings", ppController); },
drawBlock: isToggle =>
{
EditorGUI.BeginChangeCheck();
// ppController.distortScreenUVMode = EditorGUILayout.Toggle("后处理走常规屏幕坐标", ppController.distortScreenUVMode);
SerializedProperty distortScreenUVModeProp = serializedObject.FindProperty("distortScreenUVMode");
EditorGUILayout.PropertyField(distortScreenUVModeProp,new GUIContent("后处理走常规屏幕坐标"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetUVFromDistort", ppController);
}
EditorGUI.BeginChangeCheck();
// ppController.distortSpeedTexture = (Texture2D)EditorGUILayout.ObjectField("后处理扭曲贴图", ppController.distortSpeedTexture, typeof(Texture2D));
SerializedProperty distortSpeedTextureProp = serializedObject.FindProperty("distortSpeedTexture");
EditorGUILayout.PropertyField(distortSpeedTextureProp, new GUIContent("后处理扭曲贴图"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("InitAllSettings", ppController);
}
if (ppController.distortScreenUVMode)
{
EditorGUI.BeginChangeCheck();
// ppController.distortTextureMidValue = EditorGUILayout.FloatField("扭曲贴图中间值", ppController.distortTextureMidValue);
SerializedProperty distortTextureMidValueProp = serializedObject.FindProperty("distortTextureMidValue");
EditorGUILayout.PropertyField(distortTextureMidValueProp, new GUIContent("扭曲贴图中间值"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetTexture", ppController);
}
}
// ppController.distortSpeedTexSt = EditorGUILayout.Vector4Field("扭曲贴图ST", ppController.distortSpeedTexSt);
SerializedProperty distortSpeedTexStProp = serializedObject.FindProperty("distortSpeedTexSt");
EditorGUILayout.PropertyField(distortSpeedTexStProp, new GUIContent("扭曲贴图缩放平移"));
// ppController.distortSpeedIntensity = EditorGUILayout.FloatField("扭曲强度", ppController.distortSpeedIntensity);
SerializedProperty distortSpeedIntensityProp = serializedObject.FindProperty("distortSpeedIntensity");
EditorGUILayout.PropertyField(distortSpeedIntensityProp, new GUIContent("扭曲强度"));
if (!ppController.distortScreenUVMode)
{
// ppController.distortSpeedPosition = EditorGUILayout.FloatField("扭曲位置", ppController.distortSpeedPosition);
SerializedProperty distortSpeedPositionProp = serializedObject.FindProperty("distortSpeedPosition");
EditorGUILayout.PropertyField(distortSpeedPositionProp, new GUIContent("扭曲位置"));
// ppController.distortSpeedRange = EditorGUILayout.FloatField("扭曲过渡范围", ppController.distortSpeedRange);
SerializedProperty distortSpeedRangeProp = serializedObject.FindProperty("distortSpeedRange");
EditorGUILayout.PropertyField(distortSpeedRangeProp, new GUIContent("扭曲过渡范围"));
}
// ppController.distortSpeedMoveSpeedX = EditorGUILayout.FloatField("扭曲纹理流动X", ppController.distortSpeedMoveSpeedX);
SerializedProperty distortSpeedMoveSpeedXProp = serializedObject.FindProperty("distortSpeedMoveSpeedX");
EditorGUILayout.PropertyField(distortSpeedMoveSpeedXProp, new GUIContent("扭曲纹理流动X"));
// ppController.distortSpeedMoveSpeed = EditorGUILayout.FloatField("扭曲纹理流动Y", ppController.distortSpeedMoveSpeed);
SerializedProperty distortSpeedMoveSpeed = serializedObject.FindProperty("distortSpeedMoveSpeed");
EditorGUILayout.PropertyField(distortSpeedMoveSpeed , new GUIContent("扭曲纹理流动Y"));
});
SerializedProperty radialBlurToggleProp = serializedObject.FindProperty("radialBlurToggle");
DrawToggleFoldOut(ppController.AnimBools[2], "径向模糊", radialBlurToggleProp, drawEndChangeCheck:
isChangeToggle => { ReflectMethod("InitAllSettings", ppController); },
drawBlock: isToggle =>
{
EditorGUI.BeginChangeCheck();
// ppController.radialBlurFromDistort = EditorGUILayout.Toggle("径向模糊跟随后处理扭曲", ppController.radialBlurFromDistort);
SerializedProperty radialBlurFromDistortProp = serializedObject.FindProperty("radialBlurFromDistort");
EditorGUILayout.PropertyField(radialBlurFromDistortProp, new GUIContent("径向模糊跟随后处理扭曲"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetUVFromDistort", ppController);
}
// ppController.radialBlurSampleCount = EditorGUILayout.IntSlider("采样次数", ppController.radialBlurSampleCount, 1, 12);
SerializedProperty radialBlurSampleCountProp = serializedObject.FindProperty("radialBlurSampleCount");
EditorGUILayout.PropertyField(radialBlurSampleCountProp, new GUIContent("采样次数"));
// ppController.radialBlurIntensity = EditorGUILayout.FloatField("强度", ppController.radialBlurIntensity);
SerializedProperty radialBlurIntensityProp = serializedObject.FindProperty("radialBlurIntensity");
EditorGUILayout.PropertyField(radialBlurIntensityProp, new GUIContent("强度"));
if (!ppController.radialBlurFromDistort)
{
// ppController.radialBlurPos = EditorGUILayout.FloatField("位置", ppController.radialBlurPos);\
SerializedProperty radialBlurPosProp = serializedObject.FindProperty("radialBlurPos");
EditorGUILayout.PropertyField(radialBlurPosProp, new GUIContent("位置"));
// ppController.radialBlurRange = EditorGUILayout.FloatField("过渡范围", ppController.radialBlurRange);
SerializedProperty radialBlurRangeProp = serializedObject.FindProperty("radialBlurRange");
EditorGUILayout.PropertyField(radialBlurRangeProp, new GUIContent("过渡范围"));
}
});
#if CINIMACHINE_3_0
SerializedProperty cameraShakeToggleProp = serializedObject.FindProperty("cameraShakeToggle");
DrawToggleFoldOut(ppController.AnimBools[3], "震屏", cameraShakeToggleProp, drawEndChangeCheck:
isChangeToggle =>
{
ReflectMethod("InitAllSettings",ppController);
},
drawBlock: isToggle =>
{
EditorGUI.BeginChangeCheck();
// ppController.cinemachineCamera = (CinemachineCamera)EditorGUILayout.ObjectField("绑定Cinemachine相机", ppController.cinemachineCamera, typeof(CinemachineCamera));
SerializedProperty cinemachineCameraProp = serializedObject.FindProperty("cinemachineCamera");
EditorGUILayout.PropertyField(cinemachineCameraProp, new GUIContent("绑定Cinemachine相机"));
if (EditorGUI.EndChangeCheck())
{
// ReflectMethod("InitCinemachineCamera",ppController);
ppController.InitCinemachineCamera();
}
// ppController.cameraShakeIntensity = EditorGUILayout.FloatField("相机震动强度", ppController.cameraShakeIntensity);
SerializedProperty cameraShakeIntensityProp = serializedObject.FindProperty("cameraShakeIntensity");
EditorGUILayout.PropertyField(cameraShakeIntensityProp, new GUIContent("相机震动强度"));
});
#endif
SerializedProperty overlayTextureToggleProp = serializedObject.FindProperty("overlayTextureToggle");
DrawToggleFoldOut(ppController.AnimBools[4], "肌理叠加图", overlayTextureToggleProp, drawEndChangeCheck:isChangeToggle =>
{
ReflectMethod("InitAllSettings", ppController);
},
drawBlock: isToggle =>
{
EditorGUI.BeginChangeCheck();
// ppController.overlayTexturePolarCoordMode = EditorGUILayout.Toggle("肌理图极坐标模式", ppController.overlayTexturePolarCoordMode);
SerializedProperty overlayTexturePolarCoordModeProp = serializedObject.FindProperty("overlayTexturePolarCoordMode");
EditorGUILayout.PropertyField(overlayTexturePolarCoordModeProp, new GUIContent("肌理图极坐标模式"));
// ppController.overlayTexture = (Texture2D)EditorGUILayout.ObjectField("肌理图", ppController.overlayTexture, typeof(Texture2D));
SerializedProperty overlayTextureProp = serializedObject.FindProperty("overlayTexture");
EditorGUILayout.PropertyField(overlayTextureProp, new GUIContent("肌理图"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetTexture",ppController);
}
// ppController.overlayTextureSt = EditorGUILayout.Vector4Field("肌理图缩放平移", ppController.overlayTextureSt);
SerializedProperty overlayTextureStProp = serializedObject.FindProperty("overlayTextureSt");
EditorGUILayout.PropertyField(overlayTextureStProp, new GUIContent("肌理图缩放平移"));
// ppController.overlayTextureAnim = EditorGUILayout.Vector2Field("肌理图偏移动画", ppController.overlayTextureAnim);
SerializedProperty overlayTextureAnimProp = serializedObject.FindProperty("overlayTextureAnim");
EditorGUILayout.PropertyField(overlayTextureAnimProp, new GUIContent("肌理图偏移动画"));
// ppController.overlayTextureIntensity = EditorGUILayout.FloatField("肌理图强度", ppController.overlayTextureIntensity);
SerializedProperty overlayTextureIntensityProp = serializedObject.FindProperty("overlayTextureIntensity");
EditorGUILayout.PropertyField(overlayTextureIntensityProp, new GUIContent("肌理图强度"));
EditorGUI.BeginChangeCheck();
// ppController.overlayMaskTexture = (Texture2D)EditorGUILayout.ObjectField("肌理蒙版图", ppController.overlayMaskTexture, typeof(Texture2D));
SerializedProperty overlayMaskTextureProp = serializedObject.FindProperty("overlayMaskTexture");
EditorGUILayout.PropertyField(overlayMaskTextureProp, new GUIContent("肌理蒙版图"));
if (EditorGUI.EndChangeCheck())
{
ReflectMethod("SetTexture",ppController);
}
// ppController.overlayMaskTextureSt = EditorGUILayout.Vector4Field("肌理图蒙版缩放平移", ppController.overlayMaskTextureSt);
SerializedProperty overlayMaskTextureStProp = serializedObject.FindProperty("overlayMaskTextureSt");
EditorGUILayout.PropertyField(overlayMaskTextureStProp, new GUIContent("肌理图蒙版缩放平移"));
});
SerializedProperty flashToggleProp = serializedObject.FindProperty("flashToggle");
DrawToggleFoldOut(ppController.AnimBools[5], "反闪", flashToggleProp, drawEndChangeCheck:
isChangeToggle =>
{
ReflectMethod("InitAllSettings",ppController);
},
drawBlock: isToggle =>
{
// ppController.flashInvertIntensity = EditorGUILayout.FloatField("反转度", ppController.flashInvertIntensity);
SerializedProperty flashInvertIntensityProp = serializedObject.FindProperty("flashInvertIntensity");
EditorGUILayout.PropertyField(flashInvertIntensityProp, new GUIContent("反转度"));
// ppController.flashDeSaturateIntensity = EditorGUILayout.FloatField("饱和度", ppController.flashDeSaturateIntensity);
SerializedProperty flashDeSaturateIntensityProp = serializedObject.FindProperty("flashDeSaturateIntensity");
EditorGUILayout.PropertyField(flashDeSaturateIntensityProp, new GUIContent("饱和度"));
// ppController.flashContrast = EditorGUILayout.FloatField("对比度", ppController.flashContrast);
SerializedProperty flashContrastProp = serializedObject.FindProperty("flashContrast");
EditorGUILayout.PropertyField(flashContrastProp, new GUIContent("对比度"));
// ppController.flashColor = EditorGUILayout.ColorField("闪颜色", ppController.flashColor);
SerializedProperty flashColorProp = serializedObject.FindProperty("flashColor");
EditorGUILayout.PropertyField(flashColorProp, new GUIContent("亮部闪颜色"));
SerializedProperty blackFlashColorProp = serializedObject.FindProperty("blackFlashColor");
EditorGUILayout.PropertyField(blackFlashColorProp, new GUIContent("暗部闪颜色"));
});
SerializedProperty vignetteToggleProp = serializedObject.FindProperty("vignetteToggle");
DrawToggleFoldOut(ppController.AnimBools[6], "暗角", vignetteToggleProp, drawEndChangeCheck:
isChangeToggle =>
{
ReflectMethod("InitAllSettings", ppController);
},
drawBlock: isToggle =>
{
// ppController.vignetteColor = EditorGUILayout.ColorField("暗角颜色", ppController.vignetteColor);
SerializedProperty vignetteColorProp = serializedObject.FindProperty("vignetteColor");
EditorGUILayout.PropertyField(vignetteColorProp, new GUIContent("暗角颜色"));
// ppController.vignetteIntensity = EditorGUILayout.FloatField("暗角强度", ppController.vignetteIntensity);
SerializedProperty vignetteIntensityProp = serializedObject.FindProperty("vignetteIntensity");
EditorGUILayout.PropertyField(vignetteIntensityProp, new GUIContent("暗角强度"));
// ppController.vignetteRoundness = EditorGUILayout.FloatField("暗角圆度", ppController.vignetteRoundness);
SerializedProperty vignetteRoundnessProp = serializedObject.FindProperty("vignetteRoundness");
EditorGUILayout.PropertyField(vignetteRoundnessProp, new GUIContent("暗角圆度"));
// ppController.vignetteSmothness = EditorGUILayout.FloatField("暗角平滑度", ppController.vignetteSmothness);
SerializedProperty vignetteSmothnessProp = serializedObject.FindProperty("vignetteSmothness");
EditorGUILayout.PropertyField(vignetteSmothnessProp, new GUIContent("暗角平滑度"));
});
if (GUILayout.Button("选择当前Manager"))
{
ReflectMethod("FindManager",ppController);
}
#if CINIMACHINE_3_0
if (GUILayout.Button("选择当前CinemachineCamera"))
{
ppController.FindVirtualCamera();
}
#endif
serializedObject.ApplyModifiedProperties();
}
public void DrawToggleFoldOut(AnimBool foldOutAnimBool,string label, SerializedProperty boolProperty,
bool isIndentBlock = true,
FontStyle fontStyle = FontStyle.Bold,
Action<bool> drawBlock = null, Action<bool> drawEndChangeCheck = null)
{
if (fontStyle == FontStyle.Bold)
{
EditorGUILayout.Space();
}
EditorGUILayout.BeginHorizontal();
var rect = EditorGUILayout.GetControlRect();
var foldoutRect = new Rect(rect.x, rect.y, rect.width, rect.height);
// foldoutRect.width = toggleRect.x - foldoutRect.x;
var labelRect = new Rect(rect.x + 18f, rect.y, rect.width - 18f, rect.height);
// bool isToggle = false;
// 必须先画Toggle，不然按钮会被FoldOut和Label覆盖。
EditorGUI.BeginChangeCheck();
EditorGUI.PropertyField(rect,boolProperty,new GUIContent(""));
// isToggle = EditorGUI.Toggle(rect, isToggle, EditorStyles.toggle);
if (EditorGUI.EndChangeCheck())
{
drawEndChangeCheck?.Invoke(boolProperty.boolValue);
}
// EditorGUI.DrawRect(foldoutRect,Color.red);
foldOutAnimBool.target = EditorGUI.Foldout(foldoutRect, foldOutAnimBool.target, string.Empty, true);
var origFontStyle = EditorStyles.label.fontStyle;
EditorStyles.label.fontStyle = fontStyle;
// EditorGUI.DrawRect(labelRect,Color.blue);
EditorGUI.LabelField(labelRect, label);
EditorStyles.label.fontStyle = origFontStyle;
EditorGUILayout.EndHorizontal();
if (isIndentBlock) EditorGUI.indentLevel++;
float faded = foldOutAnimBool.faded;
if (faded == 0) faded = 0.00001f; //用于欺骗FadeGroup，不要让他真的关闭了。这样会藏不住相关的GUI。我们的目的是，GUI藏住，但是逻辑还是在跑。drawBlock要执行。
EditorGUILayout.BeginFadeGroup(faded);
{
EditorGUI.BeginDisabledGroup(!boolProperty.boolValue);
drawBlock?.Invoke(boolProperty.boolValue);
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndFadeGroup();
if (isIndentBlock) EditorGUI.indentLevel--;
}
void ReflectMethod(string methodName,PostProcessingController controller)
{
serializedObject.ApplyModifiedProperties();
MethodInfo privateMethod = typeof(PostProcessingController).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
if (privateMethod != null)
{
privateMethod.Invoke(controller, null);
}
else
{
Debug.LogError("Private method " + methodName + " not found!");
}
}
}

11
Packages/NBPostProcessing/Editor/PostProcessingControllerGUI.cs.meta
View File

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

70
Packages/NBPostProcessing/Editor/PostProcessingManagerGUI.cs
View File

@@ -1,70 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.Reflection;
[CustomEditor(typeof(PostProcessingManager))]
public class PostProcessingManagerGUI : Editor
{
private PostProcessingManager _ppManager;
public override void OnInspectorGUI()
{
_ppManager = (PostProcessingManager)target;
serializedObject.Update();
DrawToggle("controllerIndexFlags","_controllerIndexFlags");
DrawToggle("色散开关",PostProcessingManager.chromaticAberrationToggles);
DrawToggle("径向扭曲开关",PostProcessingManager.distortSpeedToggles);
DrawToggle("径向模糊开关",PostProcessingManager.radialBlurToggles);
#if CINIMACHINE_3_0
DrawToggle("震屏开关",PostProcessingManager.cameraShakeToggles);
#endif
DrawToggle("肌理开关",PostProcessingManager.overlayTextureToggles);
DrawToggle("黑白闪开关",PostProcessingManager.flashToggles);
DrawToggle("暗角开关",PostProcessingManager.vignetteToggles);
DrawToggle32("ShaderFlags", PostProcessingManager.material.GetInteger(NBPostProcessFlags.FlagsId));
}
void DrawToggle(string label, string propertyName)
{
int intValue = ReflectIntValue(propertyName);
DrawToggle(label,intValue);
}
void DrawToggle(string label, int intValue)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(label);
EditorGUILayout.LabelField(BinaryIntDrawer.DrawBinaryInt(intValue,8));
EditorGUILayout.EndHorizontal();
}
void DrawToggle32(string label, int intValue)
{
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField(label);
EditorGUILayout.LabelField(BinaryIntDrawer.DrawBinaryInt(intValue,32));
EditorGUILayout.EndHorizontal();
}
int ReflectIntValue(string propertyName)
{
FieldInfo privateField = typeof(PostProcessingManager).GetField(propertyName, BindingFlags.NonPublic | BindingFlags.Instance);
if (privateField != null)
{
// 获取私有字段的值
int value = (int)privateField.GetValue(_ppManager);
return value;
}
else
{
Debug.LogError("PostProcessingManagerGUI获取变量错误");
return -1;
}
}
}

11
Packages/NBPostProcessing/Editor/PostProcessingManagerGUI.cs.meta
View File

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

27
Packages/NBPostProcessing/Editor/com.xuanxuan.nb.postprocessing.Editor.asmdef
View File

@@ -1,27 +0,0 @@
{
"name": "com.xuanxuan.nb.postprocessing.Editor",
"rootNamespace": "",
"references": [
"GUID:a1f23b61b189bd949adfd0f7a353734f",
"GUID:8495541fcd41b0c40b5b6e6e7a7639d1",
"GUID:8f9e4d586616f13449cfeb86c5f704c2",
"GUID:4307f53044263cf4b835bd812fc161a4"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [
{
"name": "com.unity.cinemachine",
"expression": "3.0",
"define": "CINIMACHINE_3_0"
}
],
"noEngineReferences": false
}

7
Packages/NBPostProcessing/Editor/com.xuanxuan.nb.postprocessing.Editor.asmdef.meta
View File

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

2
Packages/NBPostProcessing/README.md
View File

@@ -1,2 +0,0 @@
# NBPostProcessing
NBPostProcessing

7
Packages/NBPostProcessing/README.md.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 11345d4fc578e4c15a13b9e5a61107df
TextScriptImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Packages/NBPostProcessing/Runtime.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 4f0e3118134388949838b53cc48e9c89
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

485
Packages/NBPostProcessing/Runtime/NBPostProcess.cs
View File

@@ -1,485 +0,0 @@
// 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);
cmd.SetRenderTarget((RenderTargetIdentifier)_DownRT);
switch (_downSampling)
{
case Downsampling._2xBilinear:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, Vector2.one, _renderMaskMat, 0);
break;
case Downsampling._4xBilinear:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, Vector2.one, _renderMaskMat, 0);
break;
case Downsampling._4xBox:
_renderMaskMat.SetFloat(SampleOffset, 2);
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, Vector2.one, _renderMaskMat, 1);
break;
default:
Blitter.BlitTexture(cmd, _DisturbanceMaskRTHandle, Vector2.one, _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
View File

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

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

@@ -1,36 +0,0 @@
using UnityEngine;
public class NBPostProcessFlags: ShaderFlagsBase
{
public const string FlagsName = "_NBPostProcessFlags";
public static int FlagsId = Shader.PropertyToID(FlagsName);
public 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
View File

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

604
Packages/NBPostProcessing/Runtime/PostProcessingController.cs
View File

@@ -1,604 +0,0 @@
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);
public Color blackFlashColor = new Color(0f,0f,0f,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;
PostProcessingManager.blackFlashColor = blackFlashColor;
}
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
View File

@@ -1,14 +0,0 @@
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:

723
Packages/NBPostProcessing/Runtime/PostProcessingManager.cs
View File

@@ -1,723 +0,0 @@
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);
public static Color blackFlashColor = new Color(0, 0, 0, 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 readonly int _blackFlashColorProperty = Shader.PropertyToID("_BlackFlashColor");
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);
material.SetColor(_blackFlashColorProperty,blackFlashColor);
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
View File

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

191
Packages/NBPostProcessing/Runtime/ScreenColorRenderPass.cs
View File

@@ -1,191 +0,0 @@
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);
cmd.SetRenderTarget((RenderTargetIdentifier)_tempRTHandle);
switch (_downSampling)
{
case Downsampling._2xBilinear:
Blitter.BlitTexture(cmd, _screenColorHandle, Vector2.one, _material, 0);
break;
case Downsampling._4xBilinear:
Blitter.BlitTexture(cmd, _screenColorHandle, Vector2.one, _material, 0);
break;
case Downsampling._4xBox:
_material.SetFloat(SampleOffset,2);
Blitter.BlitTexture(cmd, _screenColorHandle, Vector2.one, _material, 1);
break;
default:
Blitter.BlitTexture(cmd, _screenColorHandle, Vector2.one, _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
View File

@@ -1,11 +0,0 @@
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
View File

@@ -1,30 +0,0 @@
{
"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
View File

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

8
Packages/NBPostProcessing/Shader.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: b96c6f78e9ea0924b92677f2c4812124
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

238
Packages/NBPostProcessing/Shader/ColorBlit.shader
View File

@@ -1,238 +0,0 @@
Shader "XuanXuan/ColorBlit"
{
HLSLINCLUDE
#pragma target 2.0
#pragma editor_sync_compilation
#pragma multi_compile _ DISABLE_TEXTURE2D_X_ARRAY
#pragma multi_compile _ BLIT_SINGLE_SLICE
// Core.hlsl for XR dependencies
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
ENDHLSL
SubShader
{
Tags
{
"RenderType"="Opaque" "RenderPipeline" = "UniversalPipeline"
}
ZWrite Off Cull Off
Pass
{
Name "ColorBlitPass0"
HLSLPROGRAM
#pragma vertex vert
// #pragma vertex vert
// #pragma fragment FragNearest
#pragma fragment frag
#pragma enable_d3d11_debug_symbols
Texture2D _CameraTexture;
// Texture2D _CameraTexture;
//
// struct MyAttributes
// {
// float4 positionOS : POSITION;
// float4 texCoord : TEXCOORD0;
// };
//
// Varyings vert(MyAttributes IN)
// {
// Varyings OUT = (Varyings)0;
// OUT.positionCS = float4(IN.positionOS.xyz,1);
// half4 clipVertex = OUT.positionCS/OUT.positionCS.w;
// OUT.texcoord = ComputeScreenPos(clipVertex);
// return OUT;
// }
Varyings vert(Attributes input)//避开官方_BlitScaleBias为0的错误。
{
Varyings output;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if SHADER_API_GLES
float4 pos = input.positionOS;
float2 uv = input.uv;
#else
float4 pos = GetFullScreenTriangleVertexPosition(input.vertexID);
float2 uv = GetFullScreenTriangleTexCoord(input.vertexID);
#endif
output.positionCS = pos;
// output.texcoord = uv * _BlitScaleBias.xy + _BlitScaleBias.zw;
output.texcoord = uv;
return output;
}
half4 frag (Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float4 color = SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_LinearRepeat, input.texcoord);
return color;
}
ENDHLSL
}
Pass
{
Name "BoxDownsample"
ZWrite Off
Cull Off
HLSLPROGRAM
// #pragma vertex Vert
#pragma vertex vert
#pragma fragment FragBoxDownsample
#pragma enable_d3d11_debug_symbols
Texture2D _CameraTexture;
SAMPLER(sampler_CameraTexture);
#if UNITY_VERSION < 202320
float4 _BlitTexture_TexelSize;
#endif
Varyings vert(Attributes input)//避开官方_BlitScaleBias为0的错误。
{
Varyings output;
UNITY_SETUP_INSTANCE_ID(input);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if SHADER_API_GLES
float4 pos = input.positionOS;
float2 uv = input.uv;
#else
float4 pos = GetFullScreenTriangleVertexPosition(input.vertexID);
float2 uv = GetFullScreenTriangleTexCoord(input.vertexID);
#endif
output.positionCS = pos;
// output.texcoord = uv * _BlitScaleBias.xy + _BlitScaleBias.zw;
output.texcoord = uv;
return output;
}
float _SampleOffset;
half4 FragBoxDownsample(Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
float4 d = _BlitTexture_TexelSize.xyxy * float4(-_SampleOffset, -_SampleOffset, _SampleOffset,
_SampleOffset);
half4 s;
s = SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.xy);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.zy);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.xw);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.zw);
return s * 0.25h;
}
ENDHLSL
}
Pass
{
Name "ColorBlitPass_URP_13_1_2_OR_OLDER"
HLSLPROGRAM
#pragma vertex vert
// #pragma vertex vert
// #pragma fragment FragNearest
#pragma fragment frag
#pragma enable_d3d11_debug_symbols
Texture2D _CameraTexture;
// Texture2D _CameraTexture;
struct MyAttributes
{
float4 positionOS : POSITION;
float4 texCoord : TEXCOORD0;
};
Varyings vert(MyAttributes IN)
{
Varyings OUT = (Varyings)0;
OUT.positionCS = float4(IN.positionOS.xyz,1);
half4 clipVertex = OUT.positionCS/OUT.positionCS.w;
OUT.texcoord = ComputeScreenPos(clipVertex);
return OUT;
}
half4 frag (Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float4 color = SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_LinearRepeat, input.texcoord);
return color;
}
ENDHLSL
}
Pass
{
Name "BoxDownsample_URP_13_1_2_OR_OLDER"
ZWrite Off
Cull Off
HLSLPROGRAM
#pragma vertex vert
#pragma fragment FragBoxDownsample
#pragma enable_d3d11_debug_symbols
Texture2D _CameraTexture;
SAMPLER(sampler_CameraTexture);
#if UNITY_VERSION < 202320
float4 _BlitTexture_TexelSize;
#endif
float _SampleOffset;
struct MyAttributes
{
float4 positionOS : POSITION;
float4 texCoord : TEXCOORD0;
};
Varyings vert(MyAttributes IN)
{
Varyings OUT = (Varyings)0;
OUT.positionCS = float4(IN.positionOS.xyz,1);
half4 clipVertex = OUT.positionCS/OUT.positionCS.w;
OUT.texcoord = ComputeScreenPos(clipVertex);
return OUT;
}
half4 FragBoxDownsample(Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
float4 d = _BlitTexture_TexelSize.xyxy * float4(-_SampleOffset, -_SampleOffset, _SampleOffset,
_SampleOffset);
half4 s;
s = SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.xy);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.zy);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.xw);
s += SAMPLE_TEXTURE2D_X(_CameraTexture, sampler_CameraTexture, uv + d.zw);
return s * 0.25h;
}
ENDHLSL
}
}
}

9
Packages/NBPostProcessing/Shader/ColorBlit.shader.meta
View File

@@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 3e92fe624a4f13d4eadc7753e236006a
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

105
Packages/NBPostProcessing/Shader/ColorBufferBlit.shader
View File

@@ -1,105 +0,0 @@
Shader "XuanXuan/ColorBufferBlit"
{
HLSLINCLUDE
#pragma target 2.0
#pragma editor_sync_compilation
#pragma multi_compile _ DISABLE_TEXTURE2D_X_ARRAY
#pragma multi_compile _ BLIT_SINGLE_SLICE
// Core.hlsl for XR dependencies
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
ENDHLSL
SubShader
{
Tags
{
"RenderType"="Opaque" "RenderPipeline" = "UniversalPipeline"
}
ZWrite Off Cull Off
Pass
{
Name "ColorBlitPass0"
HLSLPROGRAM
// #pragma vertex Vert
#pragma vertex vert
// #pragma fragment FragNearest
#pragma fragment frag
#pragma enable_d3d11_debug_symbols
Texture2D _CameraColorTexture;
SAMPLER(sampler_CameraColorTexture);
struct MyAttributes
{
float4 positionOS : POSITION;
float4 texCoord : TEXCOORD0;
};
Varyings vert(MyAttributes IN)
{
Varyings OUT = (Varyings)0;
OUT.positionCS = float4(IN.positionOS.xyz,1);
half4 clipVertex = OUT.positionCS/OUT.positionCS.w;
OUT.texcoord = ComputeScreenPos(clipVertex);
return OUT;
}
half4 frag (Varyings input) : SV_Target
{
// UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float4 color = SAMPLE_TEXTURE2D_X(_CameraColorTexture, sampler_LinearRepeat, input.texcoord);
return color;
}
ENDHLSL
}
Pass
{
Name "BoxDownsample"
ZWrite Off
Cull Off
HLSLPROGRAM
#pragma vertex Vert
#pragma fragment FragBoxDownsample
#pragma enable_d3d11_debug_symbols
// Texture2D _CameraTexture;
// SAMPLER(sampler_CameraTexture);
Texture2D _CameraColorTexture;
SAMPLER(sampler_CameraColorTexture);
#if UNITY_VERSION < 202320
float4 _BlitTexture_TexelSize;
#endif
float _SampleOffset;
half4 FragBoxDownsample(Varyings input) : SV_Target
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
float2 uv = UnityStereoTransformScreenSpaceTex(input.texcoord);
float4 d = _BlitTexture_TexelSize.xyxy * float4(-_SampleOffset, -_SampleOffset, _SampleOffset,
_SampleOffset);
half4 s;
s = SAMPLE_TEXTURE2D_X(_CameraColorTexture, sampler_CameraColorTexture, uv + d.xy);
s += SAMPLE_TEXTURE2D_X(_CameraColorTexture, sampler_CameraColorTexture, uv + d.zy);
s += SAMPLE_TEXTURE2D_X(_CameraColorTexture, sampler_CameraColorTexture, uv + d.xw);
s += SAMPLE_TEXTURE2D_X(_CameraColorTexture, sampler_CameraColorTexture, uv + d.zw);
return s * 0.25h;
}
ENDHLSL
}
}
}

3
Packages/NBPostProcessing/Shader/ColorBufferBlit.shader.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 3150dab783854cd6b791d5db3be4a966
timeCreated: 1747582276

BIN
Packages/NBPostProcessing/Shader/DistortSpeedNoise.png LFS
View File

Binary file not shown.

156
Packages/NBPostProcessing/Shader/DistortSpeedNoise.png.meta
View File

@@ -1,156 +0,0 @@
fileFormatVersion: 2
guid: 7f808d0c8608b954d8f20cb4132c3049
TextureImporter:
internalIDToNameTable: []
externalObjects: {}
serializedVersion: 13
mipmaps:
mipMapMode: 0
enableMipMap: 1
sRGBTexture: 1
linearTexture: 0
fadeOut: 0
borderMipMap: 0
mipMapsPreserveCoverage: 0
alphaTestReferenceValue: 0.5
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: 0.25
normalMapFilter: 0
flipGreenChannel: 0
isReadable: 0
streamingMipmaps: 0
streamingMipmapsPriority: 0
vTOnly: 0
ignoreMipmapLimit: 0
grayScaleToAlpha: 0
generateCubemap: 6
cubemapConvolution: 0
seamlessCubemap: 0
textureFormat: 1
maxTextureSize: 2048
textureSettings:
serializedVersion: 2
filterMode: 1
aniso: 1
mipBias: 0
wrapU: 0
wrapV: 0
wrapW: 0
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: 0.5, y: 0.5}
spritePixelsToUnits: 100
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spriteGenerateFallbackPhysicsShape: 1
alphaUsage: 1
alphaIsTransparency: 0
spriteTessellationDetail: -1
textureType: 0
textureShape: 1
singleChannelComponent: 0
flipbookRows: 1
flipbookColumns: 1
maxTextureSizeSet: 0
compressionQualitySet: 0
textureFormatSet: 0
ignorePngGamma: 0
applyGammaDecoding: 0
swizzle: 50462976
cookieLightType: 0
platformSettings:
- serializedVersion: 4
buildTarget: DefaultTexturePlatform
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 4
buildTarget: Standalone
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 4
buildTarget: Server
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 4
buildTarget: Android
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 4
buildTarget: iOS
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
outline: []
customData:
physicsShape: []
bones: []
spriteID:
internalID: 0
vertices: []
indices:
edges: []
weights: []
secondaryTextures: []
spriteCustomMetadata:
entries: []
nameFileIdTable: {}
mipmapLimitGroupName:
pSDRemoveMatte: 0
userData:
assetBundleName:
assetBundleVariant:

113
Packages/NBPostProcessing/Shader/Disturbance.shader
View File

@@ -1,113 +0,0 @@
Shader "XuanXuan/Disturbance"
{
Properties
{
[MhGroup(Main)]_mainTex("Main", float) = 0
[MhTexture(Main)] _MaskMap("Mask Map", 2D) = "white" {}
[MhTexture(Main,_Strength,on)]_NoiseMap("Noise Map", 2D) = "white"{}
[HideInInspector]_Strength("Strength", Range(-0.2,0.2)) =0.1
[MhToggleKeyword(Main,_PARTICLE_CUSTOMDATA_ON)]_ParticleCustomDataOn("Particle customData Strength", float) = 0
[HideInInspector]_SurfaceType("surfaceType",float)=1
[HideInInspector] _QueueOffset("Queue offset", Float) = 0.0
}
// The SubShader block containing the Shader code.
SubShader
{
// SubShader Tags define when and under which conditions a SubShader block or
// a pass is executed.
Tags
{
"RenderType" = "Transparent" "RenderPipeline" = "UniversalPipeline" "Queue" = "Transparent" "IgnoreProjector" = "True"
}
Pass
{
Blend SrcAlpha OneMinusSrcAlpha
//ZTest Always
Cull Off
HLSLPROGRAM
//gpuInstancing on
#pragma multi_compile_instancing
#pragma instancing_options renderinglayer
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma target 3.5 DOTS_INSTANCING_ON
#pragma shader_feature_local_fragment _PARTICLE_CUSTOMDATA_ON
#pragma enable_d3d11_debug_symbols
// This line defines the name of the vertex shader.
#pragma vertex vert
// This line defines the name of the fragment shader.
#pragma fragment frag
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
// This example uses the Attributes structure as an input structure in
// the vertex shader.
struct Attributes
{
float4 positionOS : POSITION;
float4 uv : TEXCOORD0;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct Varyings
{
// The positions in this struct must have the SV_POSITION semantic.
float4 positionHCS : SV_POSITION;
float4 uv :TEXCOORD0;
UNITY_VERTEX_INPUT_INSTANCE_ID
};
Texture2D _NoiseMap;
SAMPLER(sampler_NoiseMap);
Texture2D _MaskMap;
SAMPLER(sampler_MaskMap);
float _Strength;
CBUFFER_START(UnityPerMaterial)
float4 _NoiseMap_ST;
CBUFFER_END
Varyings vert(Attributes IN)
{
Varyings OUT;
// Declaring the output object (OUT) with the Varyings struct.
UNITY_SETUP_INSTANCE_ID(IN);
UNITY_TRANSFER_INSTANCE_ID(IN, OUT);
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
OUT.uv = IN.uv;
return OUT;
}
half4 frag(Varyings IN) : SV_Target
{
UNITY_SETUP_INSTANCE_ID(IN);
half2 screenSpaceUV = IN.positionHCS.xy / _ScaledScreenParams.xy;
const half2 noiseUV = screenSpaceUV * _NoiseMap_ST.xy + _NoiseMap_ST.zw;
half noise = SAMPLE_TEXTURE2D(_NoiseMap, sampler_NoiseMap, noiseUV).r * 2 - 1;
half mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, IN.uv.xy).r;
noise = lerp(0, noise, mask);
//noise = (noise * _Strength * 5) * 0.5 + 0.5;
noise = (noise * _Strength) * 1.25 + 0.5;
return half4(noise.xxx, 1.0);
}
ENDHLSL
}
}
customEditor "ShaderEditor.MhBaseShaderGUI"
}

9
Packages/NBPostProcessing/Shader/Disturbance.shader.meta
View File

@@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 1b530af6d4d97eb4c8f3725d4cd3e9b8
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

84
Packages/NBPostProcessing/Shader/FullScreenDisturbance.shader
View File

@@ -1,84 +0,0 @@
Shader "XuanXuan/FullScreenDisturbance"
{
Properties
{
_Strength("Strength", Range(-0.2,0.2)) =0
_BaseMap("Base Map", 2D) = "white"
//_Mask("Mask", 2D) = "white"
}
// The SubShader block containing the Shader code.
SubShader
{
// SubShader Tags define when and under which conditions a SubShader block or
// a pass is executed.
Tags
{
"RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"
}
Pass
{
stencil
{
Ref 1
Comp equal
Pass keep
}
HLSLPROGRAM
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
// This line defines the name of the vertex shader.
#pragma vertex vert
// This line defines the name of the fragment shader.
#pragma fragment frag
Texture2D _BlitTexture;
SAMPLER(sampler_BlitTexture);
Texture2D _BaseMap;
SAMPLER(sampler_BaseMap);
Texture2D _Mask;
SAMPLER(simpler_Mask);
float _Strength;
struct Attributes
{
#if UNITY_ANY_INSTANCING_ENABLED
uint instanceID : INSTANCEID_SEMANTIC;
#endif
uint vertexID : VERTEXID_SEMANTIC;
};
struct Varyings
{
float4 position : SV_POSITION;
float2 uv : TEXCOORD0;
#if UNITY_ANY_INSTANCING_ENABLED
uint instanceID : CUSTOM_INSTANCE_ID;
#endif
};
Varyings vert(Attributes input)
{
Varyings output;
output.position = GetFullScreenTriangleVertexPosition(input.vertexID, UNITY_NEAR_CLIP_VALUE);
output.uv = output.position.xy * 0.5 + 0.5;
return output;
}
float4 frag(Varyings packedInput):SV_TARGET
{
float2 baseUV = packedInput.position / _ScreenParams.xy;
float3 noise = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, baseUV);
noise=lerp(0,noise,noise.b);
baseUV += noise.xy * _Strength;
return SAMPLE_TEXTURE2D(_BlitTexture, sampler_BlitTexture, baseUV);
}
ENDHLSL
}
}
}

11
Packages/NBPostProcessing/Shader/FullScreenDisturbance.shader.meta
View File

@@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 126dad763ce350945945655d5c062248
ShaderImporter:
externalObjects: {}
defaultTextures:
- _BaseMap: {instanceID: 0}
- _Mask: {instanceID: 0}
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

8
Packages/NBPostProcessing/Shader/HLSL.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: e73bff430617bbc44ae5b87fb0fa9abf
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

28
Packages/NBPostProcessing/Shader/HLSL/PostProcessingFlags.hlsl
View File

@@ -1,28 +0,0 @@
#ifndef POST_PROCESSING_FLAGS
#define POST_PROCESSING_FLAGS
#if defined(CUSTOM_POSTPROCESS)
uint _NBPostProcessFlags;
#define FLAG_BIT_NB_POSTPROCESS_ON (1 << 0)
#define FLAG_BIT_DISTORT_SPEED (1 << 1)
#define FLAG_BIT_OVERLAYTEXTURE (1 << 2)
#define FLAG_BIT_FLASH (1 << 3)
#define FLAG_BIT_CHORATICABERRAT (1 << 4)
#define FLAG_BIT_RADIALBLUR (1 << 5)
#define FLAG_BIT_VIGNETTE (1 << 6)
#define FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD (1 << 7)
#define FLAG_BIT_OVERLAYTEXTURE_MASKMAP (1 << 8)
#define FLAG_BIT_POST_DISTORT_SCREEN_UV (1 << 9)
#define FLAG_BIT_RADIALBLUR_BY_DISTORT (1 << 10)
#define FLAG_BIT_CHORATICABERRAT_BY_DISTORT (1 << 11)
bool CheckLocalFlags(uint bits)
{
return (_NBPostProcessFlags&bits) != 0;
}
#endif
#endif

7
Packages/NBPostProcessing/Shader/HLSL/PostProcessingFlags.hlsl.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 8d59b331ef0707e49a98c91244bd0c1a
ShaderIncludeImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

380
Packages/NBPostProcessing/Shader/NBPostProcessUber.shader
View File

@@ -1,380 +0,0 @@
Shader "XuanXuan/Postprocess/NBPostProcessUber"
{
Properties
{
// [MainTexture] _BaseMap("Base Map", 2D) = "white"
_SpeedDistortMap("速度径向扭曲贴图", 2D) = "white"
_SpeedDistortVec("速度径向 x强度y位置z范围w速度",Vector) = (0,0,0,0)
_SpeedDistortVec2("速度径向 x:uvX速度 y:uvY速度",Vector) = (0,0,0,0)
_TextureOverlay("肌理附加图",2D) = "white"
_TextureOverlayIntensity("肌理附加强度",Float) = 0
_TextureOverlayAnim("机理图动画",Vector) = (0,0,0,0)
_TextureOverlayMask("肌理图蒙板",2D) = "white"
_InvertIntensity("反向强度",Float) = 0
_DeSaturateIntensity("饱和度强度",Float) = 0
_Contrast("对比度",Float) = 1
_FlashColor("闪颜色", Vector) = (1, 1, 1, 1)
_BlackFlashColor("闪黑颜色", Vector) = (0, 0, 0, 1)
[HideInInspector] _NBPostProcessFlags("_NBPostProcessFlags", Integer) = 0
_ChromaticAberrationVector("色散矢量",Vector) = (1,0,0,0)
_CustomScreenCenter("自定义屏幕中心",Vector) = (0.5,0.5,0,0)
_RadialBlurVec("径向模糊矢量 x强度",Vector) = (1,0,0,0)
_VignetteVec("暗角矢量 x强度,y圆度,z光滑度",Vector) = (1,0,0,0)
//不知道为什么，这里写成Color老是出错。
_VignetteColor("暗角颜色",Vector) = (0.0,0.0,0.0,1.0)
}
// The SubShader block containing the Shader code.
SubShader
{
// SubShader Tags define when and under which conditions a SubShader block or
// a pass is executed.
Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
Pass
{
Blend SrcAlpha OneMinusSrcAlpha
HLSLPROGRAM
// This line defines the name of the vertex shader.
#pragma vertex vert
// This line defines the name of the fragment shader.
#pragma fragment frag
#define CUSTOM_POSTPROCESS
// #define _POLARCOORDINATES
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
#include "HLSL/PostProcessingFlags.hlsl"
#include "Packages/com.xuanxuan.render.utility/Shader/HLSL/XuanXuan_Utility.hlsl"
// This example uses the Attributes structure as an input structure in
// the vertex shader.
struct Attributes
{
float4 positionOS : POSITION;
};
struct Varyings
{
// The positions in this struct must have the SV_POSITION semantic.
float4 positionHCS : SV_POSITION;
half2 uv :TEXCOORD0;
};
TEXTURE2D(_ScreenColorCopy1);
SAMPLER(_linear_clamp);
SAMPLER(sampler_ScreenColorCopy1);
TEXTURE2D(_DisturbanceMaskTex);
SAMPLER(sampler_DisturbanceMaskTex);
Texture2D _SpeedDistortMap;
SAMPLER(sampler_SpeedDistortMap);
TEXTURE2D(_TextureOverlay);
SAMPLER(sampler_TextureOverlay);
TEXTURE2D(_TextureOverlayMask);
SAMPLER(sampler_TextureOverlayMask);
#if UNITY_VERSION < 202220
SAMPLER(sampler_LinearClamp);
#endif
CBUFFER_START(UnityPerMaterial)
float4 _SpeedDistortMap_ST;
half4 _SpeedDistortVec;
float4 _SpeedDistortVec2;
half4 _TextureOverlay_ST;
half _TextureOverlayIntensity;
half4 _TextureOverlayMask_ST;
half4 _TextureOverlayAnim;
half _InvertIntensity;
half _DeSaturateIntensity;
half _Contrast;
half3 _FlashColor;
half3 _BlackFlashColor;
half4 _ChromaticAberrationVec;
half4 _CustomScreenCenter;
half4 _RadialBlurVec;
half4 _VignetteVec;
half4 _VignetteColor;
CBUFFER_END
half4 SAMPLE_TEXTURE2D_CHORATICABERRAT(half2 screenUV,half2 distortUV,half2 blurVec,half distToCenter)
{
if(CheckLocalFlags(FLAG_BIT_CHORATICABERRAT_BY_DISTORT))
{
blurVec = blurVec*0.25*_ChromaticAberrationVec.x;
}
else
{
half intensity = 1;
half range = _ChromaticAberrationVec.z*0.5f;
intensity = NB_Remap(distToCenter,_ChromaticAberrationVec.y-range,_ChromaticAberrationVec.y+range,0,1);
blurVec = blurVec*0.25*_ChromaticAberrationVec.x*intensity;
}
half r = SAMPLE_TEXTURE2D_X(_ScreenColorCopy1, sampler_LinearClamp, screenUV + distortUV ).x;
half g = SAMPLE_TEXTURE2D_X(_ScreenColorCopy1, sampler_LinearClamp, blurVec + screenUV + distortUV ).y;
half b = SAMPLE_TEXTURE2D_X(_ScreenColorCopy1, sampler_LinearClamp, blurVec * 2.0 + screenUV + distortUV).z;
half a = dot(blurVec,blurVec)*100000;
return half4(r,g,b,a);
}
Varyings vert(Attributes IN)
{
// Declaring the output object (OUT) with the Varyings struct.
Varyings OUT;
OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
half4 clipVertex = OUT.positionHCS/OUT.positionHCS.w;
OUT.uv = ComputeScreenPos(clipVertex);
// Returning the output.
return OUT;
}
half4 frag(Varyings IN) : SV_Target
{
half2 screenUV = IN.uv;
half2 distortUV = 0;
half2 distortUVWithoutIntensity=0;
half4 color = 0;
half2 polarCoordinates = 0;
//half disturbanceMask = (SAMPLE_TEXTURE2D(_DisturbanceMaskTex, _linear_clamp, screenUV)) * 2 - 1 + 0.00392; //8位0.5校准
//disturbanceMask *= 0.4;
//half2 disturbanceMask = (SAMPLE_TEXTURE2D(_DisturbanceMaskTex, _linear_clamp, screenUV).xy) * 0.8 - 0.398432; //上面两行合并
half2 disturbanceMask = (SAMPLE_TEXTURE2D(_DisturbanceMaskTex, _linear_clamp, screenUV).xy) * 0.8 - 0.4; //上面两行合并
color.a = SimpleSmoothstep(0,0.01,abs(disturbanceMask.x + disturbanceMask.y));
screenUV += disturbanceMask;
UNITY_BRANCH
if (!CheckLocalFlags(FLAG_BIT_NB_POSTPROCESS_ON))
{
color.rgb = SAMPLE_TEXTURE2D(_ScreenColorCopy1, _linear_clamp, screenUV).rgb;
}
UNITY_BRANCH
if((CheckLocalFlags(FLAG_BIT_DISTORT_SPEED)& (!CheckLocalFlags(FLAG_BIT_POST_DISTORT_SCREEN_UV)))|CheckLocalFlags(FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD))
{
polarCoordinates= PolarCoordinates(screenUV,_CustomScreenCenter.xy);
}
UNITY_BRANCH
if(CheckLocalFlags(FLAG_BIT_DISTORT_SPEED))
{
_SpeedDistortMap_ST.zw += _SpeedDistortVec2.xy * _Time.y;
// return half4(polarCoordinates,0,1);
half2 distortSpeedUV;
if(CheckLocalFlags(FLAG_BIT_POST_DISTORT_SCREEN_UV))
{
distortSpeedUV = screenUV* _SpeedDistortMap_ST.xy+_SpeedDistortMap_ST.zw;
half2 noise = SAMPLE_TEXTURE2D(_SpeedDistortMap,sampler_SpeedDistortMap,distortSpeedUV);
noise = noise * 2-1+_SpeedDistortVec.w*0.1;
half distortStrength = _SpeedDistortVec.x * 0.2;
distortUVWithoutIntensity = noise;
distortUV = noise * distortStrength;
}
else
{
distortSpeedUV = polarCoordinates * _SpeedDistortMap_ST.xy + _SpeedDistortMap_ST.zw;
half noise = SAMPLE_TEXTURE2D(_SpeedDistortMap,sampler_SpeedDistortMap,distortSpeedUV);
noise *= SimpleSmoothstep(_SpeedDistortVec.y,_SpeedDistortVec.y+_SpeedDistortVec.z,(distortSpeedUV.y - _SpeedDistortMap_ST.w)/_SpeedDistortMap_ST.y);
half distortStrength = - _SpeedDistortVec.x * 0.2;
distortUV = normalize(screenUV-_CustomScreenCenter.xy)*noise;
distortUVWithoutIntensity = distortUV;
distortUV *= distortStrength;
}
color.a += dot(distortUV,distortUV)*100000;
}
else
{
distortUVWithoutIntensity = disturbanceMask;
}
// return half4(((dot(distortUV,distortUV)*100000)).rrr,1);
UNITY_BRANCH
if(CheckLocalFlags(FLAG_BIT_CHORATICABERRAT) || CheckLocalFlags(FLAG_BIT_RADIALBLUR))
{
float2 blurVec = 0;
half dist = 0;
if(!CheckLocalFlags(FLAG_BIT_CHORATICABERRAT_BY_DISTORT)|!CheckLocalFlags(FLAG_BIT_RADIALBLUR_BY_DISTORT))
{
blurVec = _CustomScreenCenter.xy - screenUV;
dist = dot(blurVec,blurVec)*4;
}
float2 choraticaBerratBlurVec;
if(CheckLocalFlags(FLAG_BIT_CHORATICABERRAT))
{
if(CheckLocalFlags(FLAG_BIT_CHORATICABERRAT_BY_DISTORT))
{
choraticaBerratBlurVec = distortUVWithoutIntensity;
}
else
{
choraticaBerratBlurVec = blurVec;
}
}
if(CheckLocalFlags(FLAG_BIT_RADIALBLUR))
{
float2 radialblurVec;
if(CheckLocalFlags(FLAG_BIT_RADIALBLUR_BY_DISTORT))
{
radialblurVec = distortUVWithoutIntensity*_RadialBlurVec.x;
}
else
{
_RadialBlurVec.z *= 0.5;
half rangeIntensity = NB_Remap(dist,_RadialBlurVec.y-_RadialBlurVec.z,_RadialBlurVec.y+_RadialBlurVec.z,0,1);
rangeIntensity = saturate(rangeIntensity);
radialblurVec = blurVec*_RadialBlurVec.x*rangeIntensity;
}
color.a += dot(blurVec,blurVec)*100;
half3 acumulateColor = half3(0, 0, 0);
int iteration = _RadialBlurVec.w;
[unroll(12)]
for(int i = 0;i<iteration;i++)
{
if(CheckLocalFlags(FLAG_BIT_CHORATICABERRAT))
{
//sample *3
acumulateColor += SAMPLE_TEXTURE2D_CHORATICABERRAT(screenUV,distortUV,choraticaBerratBlurVec,dist);
}
else
{
acumulateColor += SAMPLE_TEXTURE2D(_ScreenColorCopy1,_linear_clamp,screenUV + distortUV);
}
screenUV += radialblurVec;
}
color.rgb = acumulateColor / iteration;
}
else
{
half4 choraticaBerratColor = SAMPLE_TEXTURE2D_CHORATICABERRAT(screenUV,distortUV,choraticaBerratBlurVec,dist);
color.rgb = choraticaBerratColor.rgb;
color.a += choraticaBerratColor.a;
}
}
else
{
color.rgb = SAMPLE_TEXTURE2D(_ScreenColorCopy1,_linear_clamp,screenUV + distortUV);
}
// return half4(color.aaa,1);
UNITY_BRANCH
if(CheckLocalFlags(FLAG_BIT_OVERLAYTEXTURE))
{
half2 overlayTexUV;
if(CheckLocalFlags(FLAG_BIT_OVERLAYTEXTURE_POLLARCOORD))
{
overlayTexUV = polarCoordinates;
}
else
{
overlayTexUV = screenUV;
}
float2 overlayMainTexUV = TRANSFORM_TEX(overlayTexUV,_TextureOverlay);
overlayMainTexUV = UVOffsetAnimaiton(overlayMainTexUV,_TextureOverlayAnim.xy,_Time.y);
half4 overlayTexSample = SAMPLE_TEXTURE2D(_TextureOverlay,sampler_TextureOverlay,overlayMainTexUV);
half overlayTexMask = 1;
if (CheckLocalFlags(FLAG_BIT_OVERLAYTEXTURE_MASKMAP))
{
float2 overlayTexMaskUV = TRANSFORM_TEX(overlayTexUV,_TextureOverlayMask);
overlayTexMask = SAMPLE_TEXTURE2D(_TextureOverlayMask,sampler_TextureOverlayMask,overlayTexMaskUV);
}
color.rgb *= lerp(1,overlayTexSample.rgb,overlayTexSample.a*_TextureOverlayIntensity*overlayTexMask);
// return half4( lerp(overlayTexSample.rgb,1,overlayTexSample.a*_TextureOverlayIntensity),1);
color.a += _TextureOverlayIntensity;
}
UNITY_BRANCH
if(CheckLocalFlags(FLAG_BIT_FLASH))
{
// //因为颜色空间的特殊原因，这里的转换运算可能会造成性能热点，后续考虑优化。
// half3 invertColor = SRGBToLinear(1- LinearToSRGB(color.xyz));
// color.rgb = lerp(color.rgb,invertColor,_InvertIntensity);
half3 endColor = lerp(_BlackFlashColor,_FlashColor,luminance(color.rgb));
color.rgb = lerp(color.rgb,endColor,_InvertIntensity);
color.xyz = RgbToHsv(color.rgb);
half3 colorHSV = color.xyz;
color.y *= _DeSaturateIntensity;
color.rgb = HsvToRgb(color.xyz);
color.rgb = lerp(half3(0.5,0.5,0.5),color.rgb,_Contrast);
color.a = 1;
}
UNITY_BRANCH
if(CheckLocalFlags(FLAG_BIT_VIGNETTE))
{
_VignetteVec.x *= _VignetteColor.a;
half2 screenVec = (_CustomScreenCenter.xy - screenUV)*_VignetteVec.x;
screenVec.x *= _VignetteVec.y;
half2 dist = dot(screenVec,screenVec);
dist = saturate(dist);
half factor = pow(1-dist,_VignetteVec.z) ;
color.rgb *= lerp(_VignetteColor,(1.0).xxx,factor);
// color.rgb *= saturate(factor);
color.a =1;
}
// return half4(_TextureOverlayIntensity.rrr,1);
// float finalIntensity = (_SpeedDistortVec.x+ _TextureOverlayIntensity +_InvertIntensity +(1- _DeSaturateIntensity)+_Contrast)*2;
// finalIntensity = saturate(finalIntensity);
// return half4(saturate(color.a).rrr,1);
return half4(color.rgb,saturate(color.a));
}
ENDHLSL
}
}
}

12
Packages/NBPostProcessing/Shader/NBPostProcessUber.shader.meta
View File

@@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 5fd213d22763447c4aa106605e06184e
ShaderImporter:
externalObjects: {}
defaultTextures:
- _SpeedDistortMap: {fileID: 2800000, guid: 7f808d0c8608b954d8f20cb4132c3049, type: 3}
- _TextureOverlay: {instanceID: 0}
- _TextureOverlayMask: {instanceID: 0}
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

7
Packages/NBPostProcessing/package.json
View File

@@ -1,7 +0,0 @@
{
"name": "com.xuanxuan.nb.postprocessing",
"version": "0.0.1",
"displayName": "NBPostProcessing",
"description": "NB\u540e\u5904\u7406",
"unity": "2019.1"
}

7
Packages/NBPostProcessing/package.json.meta
View File

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

1
Packages/NBShaders/.gitignore vendored
View File

@@ -1 +0,0 @@
.idea

8
Packages/NBShaders/Editor.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: af9e4a2cbc9cee94485138c3bc876c62
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

2834
Packages/NBShaders/Editor/ParticleBaseGUI.cs
View File

File diff suppressed because it is too large Load Diff

11
Packages/NBShaders/Editor/ParticleBaseGUI.cs.meta
View File

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

20
Packages/NBShaders/Editor/com.xuanxuan.nb.shaders.Editor.asmdef
View File

@@ -1,20 +0,0 @@
{
"name": "com.xuanxuan.nb.shaders.Editor",
"rootNamespace": "",
"references": [
"GUID:0e3b0e6ce60c7a34094f8f9822c0b7f2",
"GUID:8495541fcd41b0c40b5b6e6e7a7639d1",
"GUID:8f9e4d586616f13449cfeb86c5f704c2"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Packages/NBShaders/Editor/com.xuanxuan.nb.shaders.Editor.asmdef.meta
View File

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

21
Packages/NBShaders/LICENSE
View File

@@ -1,21 +0,0 @@
MIT License
Copyright (c) 2024 xuanshushu
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

7
Packages/NBShaders/LICENSE.meta
View File

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

2
Packages/NBShaders/README.md
View File

@@ -1,2 +0,0 @@
# NBShaders
This is a powerful and versatile Unity VFX shader.

7
Packages/NBShaders/README.md.meta
View File

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

8
Packages/NBShaders/Runtime.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 4684518ac782305428f8c0434c85d1c0
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

90
Packages/NBShaders/Runtime/NBShaderSpriteHelper.cs
View File

@@ -1,90 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
// using Sirenix.OdinInspector;
[ExecuteAlways]
public class NBShaderSpriteHelper : MonoBehaviour
{
public Sprite sprite;
// [ReadOnly]
public SpriteRenderer spRenderer;
// [ReadOnly]
public Image image;
[InspectorButton("初始化","Init")]
public bool ButtomInspector;
private Material mat;
// Start is called before the first frame update
void Start()
{
Init();
}
void Init()
{
if (TryGetComponent<SpriteRenderer>(out SpriteRenderer spr))
{
spRenderer = spr;
sprite = spr.sprite;
}
else
{
if (TryGetComponent<Image>(out Image im))
{
image = im;
sprite = im.sprite;
}
}
if (sprite)
{
Texture texture = sprite.texture;
Rect rect = sprite.textureRect;
// sharedMaterial.SetVector("_BaseMapReverseST",CalScaleOffset(spRenderer.sprite.textureRect,spRenderer.sprite.texture));
if (spRenderer)
{
if (Application.isPlaying)
{
mat = spRenderer.material;
}
else
{
mat = spRenderer.sharedMaterial;
}
}
else if(image)
{
mat = image.material;
}
if (mat && mat.shader.name == "XuanXuan/Effects/Particle_NiuBi")
{
mat.SetVector("_MainTex_Reverse_ST",CalScaleOffset(rect,texture));
Debug.Log(mat.name);
}
}
}
Vector4 CalScaleOffset(Rect textureRect,Texture texture)
{
//这是一个反向的scale offset。
//算法：如果原scale offset。转换后会是 scaleAfter= 1 / scale , offsetAfter = - offset/scale;
Vector2 scaleAfter = new Vector2(texture.width / textureRect.width, texture.height / textureRect.height);
Vector2 offsetAfter = new Vector2(-(textureRect.x / texture.width) * scaleAfter.x,
-(textureRect.y / texture.height) * scaleAfter.y);
Vector4 scaleOffset = new Vector4(scaleAfter.x,scaleAfter.y,offsetAfter.x,offsetAfter.y);
return scaleOffset;
}
}

11
Packages/NBShaders/Runtime/NBShaderSpriteHelper.cs.meta
View File

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

670
Packages/NBShaders/Runtime/W9ParticleShaderFlags.cs
View File

@@ -1,670 +0,0 @@
using System;
using UnityEngine;
public class W9ParticleShaderFlags: ShaderFlagsBase
{
public const string FlagsName = "_W9ParticleShaderFlags";
public static int FlagsId = Shader.PropertyToID(FlagsName);
public const string Flags1Name = "_W9ParticleShaderFlags1";
public static int Flags1Id = Shader.PropertyToID(Flags1Name);
public const string WrapFlagsName = "_W9ParticleShaderWrapFlags";
public static int WrapFlagsId = Shader.PropertyToID(WrapFlagsName);
public const string foldOutFlagName = "_W9ParticleShaderGUIFoldToggle";
public static int foldOutFlagId = Shader.PropertyToID(foldOutFlagName);
public const string foldOutFlagName1 = "_W9ParticleShaderGUIFoldToggle1";
public static int foldOutFlagId1 = Shader.PropertyToID(foldOutFlagName1);
public const string foldOutFlagName2 = "_W9ParticleShaderGUIFoldToggle2";
public static int foldOutFlagId2 = Shader.PropertyToID(foldOutFlagName2);
public const string colorChannelFlagName = "_W9ParticleShaderColorChannelFlag";
public static int colorChannelFlagId = Shader.PropertyToID(colorChannelFlagName);
public override int GetShaderFlagsId(int index = 0)
{
switch (index)
{
case 0:
return FlagsId;
case 1:
return Flags1Id;
case 2:
return WrapFlagsId;
//FoldOut必须要紧挨着，因为按照Index去拿AnimBool
case 3:
return foldOutFlagId;
case 4:
return foldOutFlagId1;
case 5:
return foldOutFlagId2;
case 6:
return colorChannelFlagId;
default:
return FlagsId;
}
}
protected override string GetShaderFlagsName(int index = 0)
{
switch (index)
{
case 0:
return FlagsName;
case 1:
return Flags1Name;
case 2:
return WrapFlagsName;
case 3:
return foldOutFlagName;
case 4:
return foldOutFlagName1;
case 5:
return colorChannelFlagName;
default:
return FlagsName;
}
}
public W9ParticleShaderFlags(Material material = null): base(material)
{
}
public const int FLAG_BIT_SATURABILITY_ON = 1 << 0;
public const int FLAG_BIT_PARTICLE_NOISE_CHORATICABERRAT_WITH_NOISE = 1 << 1;
public const int FLAG_BIT_PARTICLE_FRESNEL_FADE_ON = 1 << 2;
public const int FLAG_BIT_PARTICLE_FRESNEL_COLOR_ON = 1 << 3;
public const int FLAG_BIT_PARTICLE_USETEXCOORD2 = 1 << 4;
public const int FLAG_BIT_PARTICLE_DISTANCEFADE_ON = 1 << 5;
public const int FLAG_BIT_PARTICLE_CHORATICABERRAT= 1 << 6;
public const int FLAG_BIT_PARTILCE_MASKMAPROTATIONANIMATION_ON = 1 << 7;
public const int FLAG_BIT_PARTICLE_POLARCOORDINATES_ON = 1 << 8;
public const int FLAG_BIT_PARTICLE_UTWIRL_ON = 1 << 9;
public const int FLAG_BIT_PARTICLE_LINEARTOGAMMA_ON = 1 << 10;
public const int FLAG_BIT_PARTICLE_FRESNEL_ON = 1 << 11;
public const int FLAG_BIT_PARTICLE_NOISEMAP_NORMALIZEED_ON = 1 << 12;
public const int FLAG_BIT_PARTICLE_FRESNEL_COLOR_AFFETCT_BY_ALPHA = 1 << 13;
public const int FLAG_BIT_PARTICLE_UIEFFECT_ON = 1 << 14;
public const int FLAG_BIT_PARTICLE_UNSCALETIME_ON = 1 << 15;
public const int FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON = 1 << 16;
public const int FLAG_BIT_PARTICLE_CUSTOMDATA1_ON = 1 << 17;
public const int FLAG_BIT_PARTICLE_FRESNEL_INVERT_ON = 1 << 18;
public const int FLAG_BIT_HUESHIFT_ON = 1 << 19;
public const int FLAG_BIT_PARTICLE_CUSTOMDATA2_ON = 1 << 20;
public const int FLAG_BIT_PARTICLE_NORMALMAP_MASK_MODE = 1 << 21;
public const int FLAG_BIT_PARTICLE_COLOR_BLEND_FOLLOW_MAINTEX_UV = 1 << 22;
public const int FLAG_BIT_PARTICLE_RAMP_COLOR_MAP_MODE_ON = 1 << 23;
public const int FLAG_BIT_PARTICLE_RAMP_COLOR_BLEND_ADD= 1 << 24;
public const int FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE = 1 << 25;
public const int FLAG_BIT_PARTICLE_DISSOLVE_RAMP_MAP = 1 << 26;
public const int FLAG_BIT_PARTICLE_DISSOLVE_MASK = 1 << 27;
public const int FLAG_BIT_PARTICLE_BACKCOLOR = 1 << 28;
public const int FLAG_BIT_PARTICLE_EMISSION_FOLLOW_MAINTEX_UV= 1 << 29;
public const int FLAG_BIT_PARTICLE_VERTEX_OFFSET_ON = 1 << 30;
public const int FLAG_BIT_PARTICLE_VERTEX_OFFSET_NORMAL_DIR= 1 << 31;
public const int FLAG_BIT_PARTICLE_1_DEPTH_OUTLINE= 1 << 0;
public const int FLAG_BIT_PARTICLE_1_PARALLAX_MAPPING= 1 << 1;
public const int FLAG_BIT_PARTICLE_1_MASKMAP_GRADIENT= 1 << 2;
public const int FLAG_BIT_PARTICLE_1_MASKMAP_2_GRADIENT = 1 << 3;
public const int FLAG_BIT_PARTICLE_1_MASKMAP_3_GRADIENT = 1 << 4;
public const int FLAG_BIT_PARTICLE_1_DISSOLVE_LINE_MASK = 1 << 5;
public const int FLAG_BIT_PARTICLE_1_DISSOLVE_RAMP_MULITPLY = 1 << 6;
public const int FLAG_BIT_PARTICLE_1_MASK_REFINE = 1 << 7;
public const int FLAG_BIT_PARTICLE_CUSTOMDATA2W_CHORATICABERRAT_INTENSITY = 1 << 8;
public const int FLAG_BIT_PARTICLE_1_IGNORE_VERTEX_COLOR = 1 << 9;
public const int FLAG_BIT_PARTICLE_1_DISSOVLE_VORONOI = 1 << 10;
public const int FLAG_BIT_PARTICLE_1_DISSOVLE_USE_RAMP = 1 << 11;
public const int FLAG_BIT_PARTICLE_1_MASK_MAP2 = 1 << 12;
public const int FLAG_BIT_PARTICLE_1_MASK_MAP3 = 1 << 13;
public const int FLAG_BIT_PARTICLE_1_NOISE_MASKMAP = 1 << 14;
public const int FLAG_BIT_PARTICLE_1_ANIMATION_SHEET_HELPER = 1 << 15;
public const int FLAG_BIT_PARTICLE_1_CUSTOMDATA2Z_VERTEXOFFSET_INTENSITY= 1 << 16;
public const int FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE= 1 << 17;
public const int FLAG_BIT_PARTICLE_1_USE_TEXCOORD1= 1 << 18;
public const int FLAG_BIT_PARTICLE_1_USE_TEXCOORD2= 1 << 19;
public const int FLAG_BIT_PARTICLE_1_CYLINDER_CORDINATE= 1 << 20;
public const int FLAG_BIT_PARTICLE_1_UV_FROM_MESH= 1 << 21;//3D条件下，如果不是来源于Mesh，就默认来源于粒子。
public const int FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE= 1 << 22;//3D条件下，如果不是来源于Mesh，就默认来源于粒子。
public const int FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM= 1 << 23;//3D条件下，如果不是来源于Mesh，就默认来源于粒子。
public const int FLAG_BIT_PARTICLE_1_MAINTEX_CONTRAST= 1 << 24;
public const int FLAG_BIT_PARTICLE_1_VERTEXOFFSET_START_FROM_ZERO= 1 << 25;
public const int FLAG_BIT_PARTICLE_1_VERTEXOFFSET_MASKMAP= 1 << 26;
public const int FLAG_BIT_PARTICLE_1_MAINTEX_COLOR_REFINE= 1 << 27;
public const int FLAG_BIT_PARTICLE_1_BUMP_TEX_UV_FOLLOW_MAINTEX= 1 << 28;
public const int FLAG_BIT_PARTICLE_1_SIXWAY_RAMPMAP= 1 << 29;
public const int FLAG_BIT_PARTICLE_1_MATCAP_MULTY_MODE= 1 << 30;
public const int FLAG_BIT_WRAPMODE_BASEMAP= 1 << 0;
public const int FLAG_BIT_WRAPMODE_MASKMAP= 1 << 1;
public const int FLAG_BIT_WRAPMODE_MASKMAP2= 1 << 2;
public const int FLAG_BIT_WRAPMODE_NOISEMAP= 1 << 3;
public const int FLAG_BIT_WRAPMODE_EMISSIONMAP= 1 << 4;
public const int FLAG_BIT_WRAPMODE_DISSOLVE_MAP= 1 << 5;
public const int FLAG_BIT_WRAPMODE_DISSOLVE_MASKMAP= 1 << 6;
public const int FLAG_BIT_WRAPMODE_DISSOLVE_RAMPMAP= 1 << 7;
public const int FLAG_BIT_WRAPMODE_COLORBLENDMAP= 1 << 8;
public const int FLAG_BIT_WRAPMODE_VERTEXOFFSETMAP= 1 << 9;
public const int FLAG_BIT_WRAPMODE_PARALLAXMAPPINGMAP = 1 << 10;
public const int FLAG_BIT_WRAPMODE_MASKMAP3= 1 << 11;
public const int FLAG_BIT_WRAPMODE_NOISE_MASKMAP= 1 << 12;
public const int FLAG_BIT_WRAPMODE_VERTEXOFFSET_MASKMAP= 1 << 13;
public const int FLAG_BIT_WRAPMODE_BUMPTEX= 1 << 14;
public const int FLAG_BIT_WRAPMODE_RAMP_COLOR_MAP= 1 << 15; //很快就要超支了。。。
public const int foldOutBitMeshOption = 1 << 0;
public const int foldOutBitMainTexOption = 1 << 1;
public const int foldOutBitBaseOption = 1 << 2;
public const int foldOutBitFeatureOption = 1 << 3;
public const int foldOutBitBaseMap = 1 << 4;
public const int foldOutBitMask = 1 << 5;
public const int foldOutBitMaskMap = 1 << 6;
public const int foldOutBitMask2 = 1 << 7;
public const int foldOutBitMask3 = 1 << 8;
public const int foldOutBitTwril = 1 << 9;
public const int foldOutBitPolar = 1 << 10;
public const int foldOutBitHueShift = 1 << 11;
public const int foldOutBitSaturability = 1 << 12;
public const int foldOutBitDistanceFade = 1 << 13;
public const int foldOutBitSoftParticles = 1 << 14;
public const int foldOutBitMaskRotate = 1 << 15;
public const int foldOutBitNoise = 1 << 16;
public const int foldOutBitNoiseMap = 1 << 17;
public const int foldOutBitNoiseMaskToggle = 1 << 18;
public const int foldOutBitEmission= 1 << 19;
public const int foldOutBitDistortionChoraticaberrat= 1 << 20;
public const int foldOutDissolve= 1 << 21;
public const int foldOutDissolveMap= 1 << 22;
public const int foldOutDissolveVoronoi= 1 << 23;
public const int foldOutDissolveRampMap= 1 << 24;
public const int foldOutDissolveMask= 1 << 25;
public const int foldOutColorBlend= 1 << 26;
public const int foldOutFresnel= 1 << 27;
public const int foldOutDepthOutline= 1 << 28;
public const int foldOutVertexOffset= 1 << 29;
public const int foldOutParallexMapping= 1 << 30;
// public const int foldOutBit1Portal= 1 << 31;
public const int foldOutBit1UVModeMainTex = 1 << 0;
public const int foldOutBit1UVModeMaskMap= 1 << 1;
public const int foldOutBit1UVModeMaskMap2= 1 << 2;
public const int foldOutBit1UVModeMaskMap3= 1 << 3;
public const int foldOutBit1UVModeNoiseMap = 1 << 4;
public const int foldOutBit1UVModeNoiseMaskMap = 1 << 5;
public const int foldOutBit1UVModeEmissionMap = 1 << 6;
public const int foldOutBit1UVModeDissolveMap = 1 << 7;
public const int foldOutBit1UVModeDissolveMaskMap = 1 << 8;
public const int foldOutBit1UVModeColorBlendMap = 1 << 9;
public const int foldOutBit1UVModeVertexOffsetMap = 1 << 10;
public const int foldOutBit1UVModeVertexOffsetMaskMap = 1 << 11;
public const int foldOutBit1UVModeBumpTex = 1 << 12;
public const int foldOutBit1UVModeRampColorMap = 1 << 13;
//留一些位置给以后可能会增加的贴图。
public const int foldOutBit1Portal= 1 << 20;
public const int foldOutBit1ZOffset= 1 << 21;
public const int foldOutBit1CustomStencilTest= 1 << 22;
public const int foldOutBit1TaOption = 1 << 23;
public const int foldOutBit1MianTexContrast= 1 << 24;
public const int foldOutBit1VertexOffsetMask= 1 << 25;
public const int foldOutBit1MainTexColorRefine= 1 << 26;
public const int foldOutBit1LightOption= 1 << 27;
public const int foldOutBit1ShaderKeyword= 1 << 28;
public const int foldOutBit1BumpTex= 1 << 29;
public const int foldOutBit2BumpTexToggle= 1 << 0;
public const int foldOutBit2MatCapToggle= 1 << 1;
public const int foldOutBit2RampColor= 1 << 2;
public const int foldOutBit2DissolveLine= 1 << 3;
public const int foldOutBit2BaseBackColor= 1 << 4;
public const int foldOutBit2MaskRefine= 1 << 5;
#region CustomDataCodes
public const string CustomDataFlag0Name = "_W9ParticleCustomDataFlag0";
public const string CustomDataFlag1Name = "_W9ParticleCustomDataFlag1";
public const string CustomDataFlag2Name = "_W9ParticleCustomDataFlag2";
public const string CustomDataFlag3Name = "_W9ParticleCustomDataFlag3";
public static int CustomDataFlag0Id = Shader.PropertyToID(CustomDataFlag0Name);
public static int CustomDataFlag1Id = Shader.PropertyToID(CustomDataFlag1Name);
public static int CustomDataFlag2Id = Shader.PropertyToID(CustomDataFlag2Name);
public static int CustomDataFlag3Id = Shader.PropertyToID(CustomDataFlag3Name);
public enum CutomDataComponent
{
Off,
CustomData1X,
CustomData1Y,
CustomData1Z,
CustomData1W,
CustomData2X,
CustomData2Y,
CustomData2Z,
CustomData2W,
UnKnownOrMixed = -1
}
public const int FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_X = 0 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_Y = 1 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_DISSOLVE_INTENSITY = 2 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_HUESHIFT = 3 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_X = 4 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_Y = 5 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_FRESNEL_OFFSET = 6 * 4;
public const int FLAGBIT_POS_0_CUSTOMDATA_CHORATICABERRAT_INTENSITY = 7 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_X = 0 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_Y = 1 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_NOISE_INTENSITY = 2 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_SATURATE = 3 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_X = 4 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_Y = 5 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_VERTEXOFFSET_INTENSITY = 6 * 4;
public const int FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_MASK_INTENSITY = 7 * 4;
public const int FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_X = 0*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_Y = 1*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_X = 2*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_Y = 3*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_X= 4*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_Y= 5*4;
public const int FLAGBIT_POS_2_CUSTOMDATA_MAINTEX_CONTRAST= 6*4;
//---->这里还有一个坑可以用哦
public const int FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_X= 0*4;
public const int FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_Y= 1*4;
public const int isCustomDataBit = 1 << 3;
public const int Data12Bit = 1 << 2;//true CustomData1 / false CustomData2
public const int DataXYorZWBit = 1 << 1;//true xy / false zw
public const int DataXZorYWBit = 1 << 0;//true xz / false yw
public const int CustomData1XBit = isCustomDataBit | Data12Bit | DataXYorZWBit | DataXZorYWBit;
public const int CustomData1YBit = isCustomDataBit | Data12Bit | DataXYorZWBit ;
public const int CustomData1ZBit = isCustomDataBit | Data12Bit | DataXZorYWBit;
public const int CustomData1WBit = isCustomDataBit | Data12Bit;
public const int CustomData2XBit = isCustomDataBit | DataXYorZWBit | DataXZorYWBit;
public const int CustomData2YBit = isCustomDataBit | DataXYorZWBit;
public const int CustomData2ZBit = isCustomDataBit | DataXZorYWBit;
public const int CustomData2WBit = isCustomDataBit;
private int GetCustomDataFlagID(int dataIndex)
{
switch (dataIndex)
{
case 0 :
return CustomDataFlag0Id;
case 1 :
return CustomDataFlag1Id;
case 2 :
return CustomDataFlag2Id;
case 3 :
return CustomDataFlag3Id;
}
return 0;
}
public string GetCustomDataFlagPropertyName(int dataIndex)
{
switch (dataIndex)
{
case 0 :
return CustomDataFlag0Name;
case 1 :
return CustomDataFlag1Name;
case 2:
return CustomDataFlag2Name;
case 3:
return CustomDataFlag3Name;
}
return null;
}
public CutomDataComponent GetCustomDataFlag(int dataBitPos, int dataIndex)
{
int bit = material.GetInteger(GetCustomDataFlagID(dataIndex));
bit = bit >> dataBitPos;
bit &= 15; // binary 1111
if ((bit & isCustomDataBit) == 0)
{
return CutomDataComponent.Off;
}
else if (bit == CustomData1XBit)
{
return CutomDataComponent.CustomData1X;
}
else if (bit == CustomData1YBit)
{
return CutomDataComponent.CustomData1Y;
}
else if (bit == CustomData1ZBit)
{
return CutomDataComponent.CustomData1Z;
}
else if (bit == CustomData1WBit)
{
return CutomDataComponent.CustomData1W;
}
else if (bit == CustomData2XBit)
{
return CutomDataComponent.CustomData2X;
}
else if (bit == CustomData2YBit)
{
return CutomDataComponent.CustomData2Y;
}
else if (bit == CustomData2ZBit)
{
return CutomDataComponent.CustomData2Z;
}
else if (bit == CustomData2WBit)
{
return CutomDataComponent.CustomData2W;
}
else
{
}
Debug.Log("不可能存在的情况");
return CutomDataComponent.Off;
}
public void SetCustomDataFlag(CutomDataComponent cutomDataComponent,int dataBitPos, int dataIndex)
{
int bit = 0;
switch (cutomDataComponent)
{
case CutomDataComponent.Off:
bit = 0;
break;
case CutomDataComponent.CustomData1X:
bit = CustomData1XBit;
break;
case CutomDataComponent.CustomData1Y:
bit = CustomData1YBit;
break;
case CutomDataComponent.CustomData1Z:
bit = CustomData1ZBit;
break;
case CutomDataComponent.CustomData1W:
bit = CustomData1WBit;
break;
case CutomDataComponent.CustomData2X:
bit = CustomData2XBit;
break;
case CutomDataComponent.CustomData2Y:
bit = CustomData2YBit;
break;
case CutomDataComponent.CustomData2Z:
bit = CustomData2ZBit;
break;
case CutomDataComponent.CustomData2W:
bit = CustomData2WBit;
break;
}
bit = bit << dataBitPos;
int clearBit = ~(15 << dataBitPos);//~ (1111 << dataBitPos)
int materialBit = material.GetInteger(GetCustomDataFlagID(dataIndex));
materialBit = materialBit & clearBit;
materialBit = materialBit | bit;
material.SetInteger(GetCustomDataFlagID(dataIndex),materialBit);
}
public bool IsCustomDataOn()
{
int prop0Flag = material.GetInteger(CustomDataFlag0Id);
int prop1Flag = material.GetInteger(CustomDataFlag1Id);
int prop2Flag = material.GetInteger(CustomDataFlag2Id);
int prop3Flag = material.GetInteger(CustomDataFlag3Id);
uint dataOnBit = 0b_1000_1000_1000_1000_1000_1000_1000_1000;//10001000100010001000100010001000;
return ((prop0Flag & dataOnBit) >0) || ((prop1Flag & dataOnBit)>0) || ((prop2Flag & dataOnBit)>0)||((prop3Flag & dataOnBit)>0);
}
bool CheckCustomData(int dataIndex, int flagIndex)
{
int flagID = 0;
switch (flagIndex)
{
case 0:
flagID = CustomDataFlag0Id;
break;
case 1:
flagID = CustomDataFlag1Id;
break;
case 2:
flagID = CustomDataFlag2Id;
break;
case 3:
flagID = CustomDataFlag3Id;
break;
}
int flag = material.GetInteger(flagID);
int i = 0;
while (i<8)
{
int bit = flag >> (4 * i);
if (dataIndex == 1)
{
if ((bit & 0b_1000) > 0 && (bit & 0b_0100) > 0)
{
return true;
}
}
else if(dataIndex == 2)
{
if ((bit & 0b_1000) > 0 && (bit & 0b_0100) == 0)
{
return true;
}
}
i += 1;
}
return false;
}
public bool IsCustomData1On()
{
if (!IsCustomDataOn())
{
return false;
}
bool isCustomData1On = false;
isCustomData1On |= CheckCustomData(1, 0);
isCustomData1On |= CheckCustomData(1, 1);
isCustomData1On |= CheckCustomData(1, 2);
isCustomData1On |= CheckCustomData(1, 3);
return isCustomData1On;
}
public bool IsCustomData2On()
{
if (!IsCustomDataOn())
{
return false;
}
bool isCustomData1On = false;
isCustomData1On |= CheckCustomData(2, 0);
isCustomData1On |= CheckCustomData(2, 1);
isCustomData1On |= CheckCustomData(2, 2);
isCustomData1On |= CheckCustomData(2, 3);
return isCustomData1On;
}
#endregion
public const string UVModeFlag0Name = "_UVModeFlag0";
public static int UVModeFlag0PropID = Shader.PropertyToID(UVModeFlag0Name);
public string GetUVModePropName(int dataIndex)
{
switch (dataIndex)
{
case 0:
return UVModeFlag0Name;
}
return null;
}
public enum UVMode
{
DefaultUVChannel, //0 0b_00
SpecialUVChannel, //1 0b_01
PolarOrTwirl, //2 0b_10
Cylinder, //3 0b_11
UnknownOrMixed = -1
}
public const int FLAG_BIT_UVMODE_POS_0_MAINTEX = 0 * 2;
public const int FLAG_BIT_UVMODE_POS_0_MASKMAP = 1 * 2;
public const int FLAG_BIT_UVMODE_POS_0_MASKMAP_2 = 2 * 2;
public const int FLAG_BIT_UVMODE_POS_0_MASKMAP_3 = 3 * 2;
public const int FLAG_BIT_UVMODE_POS_0_NOISE_MAP = 4 * 2;
public const int FLAG_BIT_UVMODE_POS_0_NOISE_MASK_MAP = 5 * 2;
public const int FLAG_BIT_UVMODE_POS_0_EMISSION_MAP = 6 * 2;
public const int FLAG_BIT_UVMODE_POS_0_DISSOLVE_MAP = 7 * 2;
public const int FLAG_BIT_UVMODE_POS_0_DISSOLVE_MASK_MAP = 8 * 2;
public const int FLAG_BIT_UVMODE_POS_0_COLOR_BLEND_MAP = 9 * 2;
public const int FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MAP = 10 * 2;
public const int FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MASKMAP = 11 * 2;
public const int FLAG_BIT_UVMODE_POS_0_BUMPMAP = 12 * 2;
public const int FLAG_BIT_UVMODE_POS_0_RAMP_COLOR_MAP = 13 * 2;
public int GetUVModeFlagPropID(int flagIndex)
{
switch (flagIndex)
{
case 0:
return UVModeFlag0PropID;
}
return 0;
}
public void SetUVMode(UVMode mode, int uvModePos, int flagIndex = 0)
{
int uvModeFlagPropId = GetUVModeFlagPropID(flagIndex);
int uvModeFlag = material.GetInteger(uvModeFlagPropId);
int clearFlag = 0b_11 << uvModePos;
clearFlag = ~ clearFlag;
uvModeFlag &= clearFlag;
int modeBit = (int)mode << uvModePos;
uvModeFlag |= modeBit;
material.SetInteger(uvModeFlagPropId,uvModeFlag);
}
public UVMode GetUVMode(int uvModePos, int flagIndex = 0)
{
int uvModeFlagPropId = GetUVModeFlagPropID(flagIndex);
int uvModeFlag = material.GetInteger(uvModeFlagPropId);
uvModeFlag = uvModeFlag >> uvModePos;
uvModeFlag &= 0b_11;
return (UVMode)uvModeFlag;
}
public bool CheckIsUVModeOn(UVMode mode)
{
uint uvModeFlag0 = (uint)material.GetInteger(UVModeFlag0PropID);
uint uvModeBit = (uint)mode;
bool isUvMode = false;
for (int i = 0; i < 16; i++)
{
uint checkBit = uvModeFlag0 >> (i * 2);
checkBit = checkBit & 0b_11;
if (checkBit == uvModeBit)
{
isUvMode = true;
break;
}
}
return isUvMode;
}
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_MAINTEX_ALPHA = 0 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP1 = 1 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP2 = 2 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP3 = 3 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_NOISE_MASK = 4 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MAP = 5 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MASK_MAP = 6 * 2;
public const int FLAG_BIT_COLOR_CHANNEL_POS_0_RAMP_COLOR_MAP = 7 * 2;
public enum ColorChannel
{
X,
Y,
Z,
W,
UnKnownOrMixedValue
}
public void SetColorChanel(ColorChannel channel, int colorChannelFlagPos)
{
int colorChannelFlag = material.GetInteger(colorChannelFlagId);
int clearFlag = 0b_11 << colorChannelFlagPos;
clearFlag = ~ clearFlag;
colorChannelFlag &= clearFlag;
int channelBit = (int)channel << colorChannelFlagPos;
colorChannelFlag |= channelBit;
material.SetInteger(colorChannelFlagId,colorChannelFlag);
}
public ColorChannel GetColorChanel(int colorChannelFlagPos)
{
int colorChannelFlag = material.GetInteger(colorChannelFlagId);
colorChannelFlag = colorChannelFlag >> colorChannelFlagPos;
colorChannelFlag &= 0b_11;
return (ColorChannel)colorChannelFlag;
}
}

11
Packages/NBShaders/Runtime/W9ParticleShaderFlags.cs.meta
View File

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

16
Packages/NBShaders/Runtime/com.xuanxuan.nb.shaders.asmdef
View File

@@ -1,16 +0,0 @@
{
"name": "com.xuanxuan.nb.shaders",
"rootNamespace": "",
"references": [
"GUID:8f9e4d586616f13449cfeb86c5f704c2"
],
"includePlatforms": [],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Packages/NBShaders/Runtime/com.xuanxuan.nb.shaders.asmdef.meta
View File

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

8
Packages/NBShaders/Shader.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 5fdc89efbf4a9bf4c9449cc01f16d08a
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Packages/NBShaders/Shader/HLSL.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 944a1679494774748b2936893c18c9ce
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

248
Packages/NBShaders/Shader/HLSL/EffectFlags.hlsl
View File

@@ -1,248 +0,0 @@
#ifndef EFFECT_FLAGS
#define EFFECT_FLAGS
#define FLAG_BIT_SATURABILITY_ON (1 << 0)
#define FLAG_BIT_PARTICLE_NOISE_CHORATICABERRAT_WITH_NOISE (1 << 1)
#define FLAG_BIT_PARTICLE_FRESNEL_FADE_ON (1 << 2)
#define FLAG_BIT_PARTICLE_FRESNEL_COLOR_ON (1 << 3)
#define FLAG_BIT_PARTICLE_USETEXCOORD2 (1 << 4)
#define FLAG_BIT_PARTICLE_DISTANCEFADE_ON (1 << 5)
#define FLAG_BIT_PARTICLE_CHORATICABERRAT (1 << 6)
#define FLAG_BIT_PARTILCE_MASKMAPROTATIONANIMATION_ON (1 << 7)
#define FLAG_BIT_PARTICLE_POLARCOORDINATES_ON (1 << 8)
#define FLAG_BIT_PARTICLE_UTWIRL_ON (1 << 9)
#define FLAG_BIT_PARTICLE_LINEARTOGAMMA_ON (1 << 10)
#define FLAG_BIT_PARTICLE_FRESNEL_ON (1 << 11)
#define FLAG_BIT_PARTICLE_NOISEMAP_NORMALIZEED_ON (1 << 12)
#define FLAG_BIT_PARTICLE_FRESNEL_COLOR_AFFETCT_BY_ALPHA (1 << 13)
#define FLAG_BIT_PARTICLE_UIEFFECT_ON (1 << 14)
#define FLAG_BIT_PARTICLE_UNSCALETIME_ON (1 << 15)
#define FLAG_BIT_PARTICLE_SCRIPTABLETIME_ON (1 << 16)
#define FLAG_BIT_PARTICLE_CUSTOMDATA1_ON (1 << 17)
#define FLAG_BIT_PARTICLE_FRESNEL_INVERT_ON (1 << 18)
#define FLAG_BIT_HUESHIFT_ON (1 << 19)
#define FLAG_BIT_PARTICLE_CUSTOMDATA2_ON (1 << 20)
#define FLAG_BIT_PARTICLE_NORMALMAP_MASK_MODE (1 << 21)
#define FLAG_BIT_PARTICLE_COLOR_BLEND_FOLLOW_MAINTEX_UV (1 << 22)
#define FLAG_BIT_PARTICLE_RAMP_COLOR_MAP_MODE_ON (1 << 23)
#define FLAG_BIT_PARTICLE_RAMP_COLOR_BLEND_ADD (1 << 24)
#define FLAG_BIT_PARTICLE_COLOR_BLEND_ALPHA_MULTIPLY_MODE (1 << 25)
#define FLAG_BIT_PARTICLE_DISSOLVE_RAMP_MAP (1 << 26)
#define FLAG_BIT_PARTICLE_DISSOLVE_MASK (1 << 27)
#define FLAG_BIT_PARTICLE_BACKCOLOR (1 << 28)
#define FLAG_BIT_PARTICLE_EMISSION_FOLLOW_MAINTEX_UV (1 << 29)
#define FLAG_BIT_PARTICLE_VERTEX_OFFSET_ON (1 << 30)
#define FLAG_BIT_PARTICLE_VERTEX_OFFSET_NORMAL_DIR (1 << 31)
// uint _W9ParticleShaderFlags;
#define FLAG_BIT_PARTICLE_1_DEPTH_OUTLINE (1 << 0)
#define FLAG_BIT_PARTICLE_1_PARALLAX_MAPPING (1 << 1)
#define FLAG_BIT_PARTICLE_1_MASKMAP_GRADIENT (1 << 2)
#define FLAG_BIT_PARTICLE_1_MASKMAP_2_GRADIENT (1 << 3)
#define FLAG_BIT_PARTICLE_1_MASKMAP_3_GRADIENT (1 << 4)
#define FLAG_BIT_PARTICLE_1_DISSOLVE_LINE_MASK (1 << 5)
#define FLAG_BIT_PARTICLE_1_DISSOLVE_RAMP_MULITPLY (1 << 6)
#define FLAG_BIT_PARTICLE_1_MASK_REFINE (1 << 7)
#define FLAG_BIT_PARTICLE_CUSTOMDATA2W_CHORATICABERRAT_INTENSITY (1 << 8)
#define FLAG_BIT_PARTICLE_1_IGNORE_VERTEX_COLOR (1 << 9)
#define FLAG_BIT_PARTICLE_1_DISSOVLE_VORONOI (1 << 10)
#define FLAG_BIT_PARTICLE_1_DISSOVLE_USE_RAMP (1 << 11)
#define FLAG_BIT_PARTICLE_1_MASK_MAP2 (1 << 12)
#define FLAG_BIT_PARTICLE_1_MASK_MAP3 (1 << 13)
#define FLAG_BIT_PARTICLE_1_NOISE_MASKMAP (1 << 14)
#define FLAG_BIT_PARTICLE_1_ANIMATION_SHEET_HELPER (1 << 15)
#define FLAG_BIT_PARTICLE_1_CUSTOMDATA2Z_VERTEXOFFSET_INTENSITY (1 << 16)
#define FLAG_BIT_PARTICLE_1_UIEFFECT_SPRITE_MODE (1 << 17)
#define FLAG_BIT_PARTICLE_1_USE_TEXCOORD1 (1 << 18)
#define FLAG_BIT_PARTICLE_1_USE_TEXCOORD2 (1 << 19)
#define FLAG_BIT_PARTICLE_1_CYLINDER_CORDINATE (1 << 20)
#define FLAG_BIT_PARTICLE_1_UV_FROM_MESH (1 << 21)
#define FLAG_BIT_PARTICLE_1_UIEFFECT_BASEMAP_MODE (1 << 22)
#define FLAG_BIT_PARTICLE_1_IS_PARTICLE_SYSTEM (1 << 23)
#define FLAG_BIT_PARTICLE_1_MAINTEX_CONTRAST (1 << 24)
#define FLAG_BIT_PARTICLE_1_VERTEXOFFSET_START_FROM_ZERO (1 << 25)
#define FLAG_BIT_PARTICLE_1_VERTEXOFFSET_MASKMAP (1 << 26)
#define FLAG_BIT_PARTICLE_1_MAINTEX_COLOR_REFINE (1 << 27)
#define FLAG_BIT_PARTICLE_1_BUMP_TEX_UV_FOLLOW_MAINTEX (1 << 28)
#define FLAG_BIT_PARTICLE_1_SIXWAY_RAMPMAP (1 << 29)
#define FLAG_BIT_PARTICLE_1_MATCAP_MULTY_MODE (1 << 30)
//WrapMode不能够超过16位（因为会占用x和x+16两个bit位）
#define FLAG_BIT_WRAPMODE_BASEMAP (1 << 0)
#define FLAG_BIT_WRAPMODE_MASKMAP (1 << 1)
#define FLAG_BIT_WRAPMODE_MASKMAP2 (1 << 2)
#define FLAG_BIT_WRAPMODE_NOISEMAP (1 << 3)
#define FLAG_BIT_WRAPMODE_EMISSIONMAP (1 << 4)
#define FLAG_BIT_WRAPMODE_DISSOLVE_MAP (1 << 5)
#define FLAG_BIT_WRAPMODE_DISSOLVE_MASKMAP (1 << 6)
#define FLAG_BIT_WRAPMODE_DISSOLVE_RAMPMAP (1 << 7)
#define FLAG_BIT_WRAPMODE_COLORBLENDMAP (1 << 8)
#define FLAG_BIT_WRAPMODE_VERTEXOFFSETMAP (1 << 9)
#define FLAG_BIT_WRAPMODE_PARALLAXMAPPINGMAP (1 << 10)
#define FLAG_BIT_WRAPMODE_MASKMAP3 (1 << 11)
#define FLAG_BIT_WRAPMODE_NOISE_MASKMAP (1 << 12)
#define FLAG_BIT_WRAPMODE_VERTEXOFFSET_MASKMAP (1 << 13)
#define FLAG_BIT_WRAPMODE_BUMPTEX (1 << 14)
#define FLAG_BIT_WRAPMODE_RAMP_COLOR_MAP (1 << 15)
#define FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_X (0*4)
#define FLAGBIT_POS_0_CUSTOMDATA_MAINTEX_OFFSET_Y (1*4)
#define FLAGBIT_POS_0_CUSTOMDATA_DISSOLVE_INTENSITY (2*4)
#define FLAGBIT_POS_0_CUSTOMDATA_HUESHIFT (3*4)
#define FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_X (4*4)
#define FLAGBIT_POS_0_CUSTOMDATA_MASK_OFFSET_Y (5*4)
#define FLAGBIT_POS_0_CUSTOMDATA_FRESNEL_OFFSET (6*4)
#define FLAGBIT_POS_0_CUSTOMDATA_CHORATICABERRAT_INTENSITY (7*4)
#define FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_X (0*4)
#define FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_OFFSET_Y (1*4)
#define FLAGBIT_POS_1_CUSTOMDATA_NOISE_INTENSITY (2*4)
#define FLAGBIT_POS_1_CUSTOMDATA_SATURATE (3*4)
#define FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_X (4*4)
#define FLAGBIT_POS_1_CUSTOMDATA_VERTEX_OFFSET_Y (5*4)
#define FLAGBIT_POS_1_CUSTOMDATA_VERTEXOFFSET_INTENSITY (6*4)
#define FLAGBIT_POS_1_CUSTOMDATA_DISSOLVE_MASK_INTENSITY (7*4)
#define FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_X (0*4)
#define FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE1_OFFSET_Y (1*4)
#define FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_X (2*4)
#define FLAGBIT_POS_2_CUSTOMDATA_DISSOLVE_NOISE2_OFFSET_Y (3*4)
#define FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_X (4*4)
#define FLAGBIT_POS_2_CUSTOMDATA_NOISE_DIRECTION_Y (5*4)
#define FLAGBIT_POS_2_CUSTOMDATA_MAINTEX_CONTRAST (6*4)
//---->这里还有一个坑可以用哦
#define FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_X (0*4)
#define FLAGBIT_POS_3_CUSTOMDATA_VERTEX_OFFSET_MASK_Y (1*4)
#define isCustomDataBit (1 << 3)
#define Data12Bit (1 << 2)
#define DataXYorZWBit (1 << 1)
#define DataXZorYWBit (1 << 0)
#define FLAG_BIT_UVMODE_POS_0_MAINTEX (0*2)
#define FLAG_BIT_UVMODE_POS_0_MASKMAP (1*2)
#define FLAG_BIT_UVMODE_POS_0_MASKMAP_2 (2*2)
#define FLAG_BIT_UVMODE_POS_0_MASKMAP_3 (3*2)
#define FLAG_BIT_UVMODE_POS_0_NOISE_MAP (4*2)
#define FLAG_BIT_UVMODE_POS_0_NOISE_MASK_MAP (5*2)
#define FLAG_BIT_UVMODE_POS_0_EMISSION_MAP (6*2)
#define FLAG_BIT_UVMODE_POS_0_DISSOLVE_MAP (7*2)
#define FLAG_BIT_UVMODE_POS_0_DISSOLVE_MASK_MAP (8*2)
#define FLAG_BIT_UVMODE_POS_0_COLOR_BLEND_MAP (9*2)
#define FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MAP (10*2)
#define FLAG_BIT_UVMODE_POS_0_VERTEX_OFFSET_MASKMAP (11*2)
#define FLAG_BIT_UVMODE_POS_0_BUMPTEX (12*2)
#define FLAG_BIT_UVMODE_POS_0_RAMP_COLOR_MAP (13*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_MAINTEX_ALPHA (0*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP1 (1*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP2 (2*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_MASKMAP3 (3*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_NOISE_MASK (4*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MAP (5*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_DISSOLVE_MASK_MAP (6*2)
#define FLAG_BIT_COLOR_CHANNEL_POS_0_RAMP_COLOR_MAP (7*2)
float GetCustomData(uint flagProperty,int flagPos,float orignValue,half4 cutstomData1,half4 customData2)
{
uint bit = flagProperty >> flagPos;
// bit &= 15;// binary 1111 这一步可能是没必要的。
UNITY_BRANCH
if((bit & isCustomDataBit) == 0)
{
return orignValue;
}
else
{
half4 customData = 0;
if((bit & Data12Bit))
{
customData = cutstomData1;
}
else
{
customData = customData2;
}
if(bit & DataXYorZWBit)
{
if(bit & DataXZorYWBit)
{
return customData.x;
}
else
{
return customData.y;
}
}
else
{
if(bit & DataXZorYWBit)
{
return customData.z;
}
else
{
return customData.w;
}
}
}
return 999;//提示错误
}
float2 GetUVByUVMode(uint flagProperty,int flagPos,float2 defaultUVChannel,float2 specialUVChannel,float2 polarOrTwirl,float2 cylinderUV)
{
flagProperty = flagProperty >> flagPos;
flagProperty = flagProperty & 3;
if(flagProperty == 0)
{
return defaultUVChannel;
}
if(flagProperty == 1)
{
return specialUVChannel;
}
if(flagProperty == 2)
{
return polarOrTwirl;
}
return cylinderUV;
}
struct BaseUVs
{
float2 defaultUVChannel;
float2 specialUVChannel;
float2 uvAfterTwirlPolar;
float2 cylinderUV;
};
float2 GetUVByUVMode(uint flagProperty,int flagPos,BaseUVs baseUVs)
{
flagProperty = flagProperty >> flagPos;
flagProperty = flagProperty & 3;
if(flagProperty == 0)
{
return baseUVs.defaultUVChannel;
}
if(flagProperty == 1)
{
return baseUVs.specialUVChannel;
}
if(flagProperty == 2)
{
return baseUVs.uvAfterTwirlPolar;
}
return baseUVs.cylinderUV;
}
#endif

7
Packages/NBShaders/Shader/HLSL/EffectFlags.hlsl.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 4918b275ae4dce948a5cedc6f3612066
ShaderIncludeImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1038
Packages/NBShaders/Shader/HLSL/ParticlesUnlitForwardPassNew.hlsl
View File

File diff suppressed because it is too large Load Diff

7
Packages/NBShaders/Shader/HLSL/ParticlesUnlitForwardPassNew.hlsl.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 9187c1d488f62d9458d6ce67858a43b3
ShaderIncludeImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1346
Packages/NBShaders/Shader/HLSL/ParticlesUnlitInputNew.hlsl
View File

File diff suppressed because it is too large Load Diff

7
Packages/NBShaders/Shader/HLSL/ParticlesUnlitInputNew.hlsl.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 03da5256bb8bf0b4496b10ee6b449be4
ShaderIncludeImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

357
Packages/NBShaders/Shader/HLSL/SixWaySmokeLit.hlsl
View File

@@ -1,357 +0,0 @@
#ifndef SIX_WAY_SMOKE_LIT_HLSL
#define SIX_WAY_SMOKE_LIT_HLSL
//这部分尽量借鉴 UnityEditor.VFX.HDRP.SixWaySmokeLit
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
#include "ParticlesUnlitInputNew.hlsl"
// Generated from UnityEditor.VFX.HDRP.SixWaySmokeLit+BSDFData
// PackingRules = Exact
struct BSDFData
{
uint materialFeatures;
float absorptionRange;
real4 diffuseColor;
real3 fresnel0;
real ambientOcclusion;
float3 normalWS;
float4 tangentWS;
real3 geomNormalWS;
real3 rigRTBk;
real3 rigLBtF;
real3 bakeDiffuseLighting0;//rigRTBk.x
real3 bakeDiffuseLighting1;//rigRTBk.y
real3 bakeDiffuseLighting2;// bsdfData.tangentWS.w > 0.0f ? rigRTBk.z : rigLBtF.z
real3 backBakeDiffuseLighting0;//rigLBtF.x
real3 backBakeDiffuseLighting1;//rigLBtF.y
real3 backBakeDiffuseLighting2;// bsdfData.tangentWS.w > 0.0f ? rigLBtF.z : rigRTBk.z
//-----NBShaders-----
real3 emission;
real emissionInput;//NegativeTex.a
real alpha;//PositiveTex.a
};
#define ABSORPTION_EPSILON max(REAL_MIN, 1e-5)
real3 ComputeDensityScales(real3 absorptionColor)
{
absorptionColor.rgb = max(ABSORPTION_EPSILON, absorptionColor.rgb);
// Empirical value used to parametrize absorption from color
const real absorptionStrength = 0.2f;
return 1.0f + log2(absorptionColor.rgb) / log2(absorptionStrength);
}
real3 GetTransmissionWithAbsorption(real transmission, real4 absorptionColor, real absorptionRange)
{
#if defined(VFX_SIX_WAY_ABSORPTION)
real3 densityScales = ComputeDensityScales(absorptionColor.rgb);
#ifdef VFX_BLENDMODE_PREMULTIPLY
absorptionRange *= (absorptionColor.a > 0) ? absorptionColor.a : 1.0f;
#endif
// real3 outTransmission = GetTransmissionWithAbsorption(transmission, densityScales, absorptionRange);
real3 outTransmission = pow(saturate(transmission / absorptionRange), densityScales);
outTransmission *= absorptionRange;
return outTransmission;
#else
return transmission.xxx * absorptionColor.rgb; // simple multiply
#endif
}
void ModifyBakedDiffuseLighting(BSDFData bsdfData, inout float3 bakeDiffuseLighting)
{
bakeDiffuseLighting = 0;
// Scale to be energy conserving: Total energy = 4*pi; divided by 6 directions
float scale = 4.0f * PI / 6.0f;
float3 frontBakeDiffuseLighting = bsdfData.tangentWS.w > 0.0f ? bsdfData.bakeDiffuseLighting2 : bsdfData.backBakeDiffuseLighting2;
float3 backBakeDiffuseLighting = bsdfData.tangentWS.w > 0.0f ? bsdfData.backBakeDiffuseLighting2 : bsdfData.bakeDiffuseLighting2;
float3x3 bakeDiffuseLightingMat;
bakeDiffuseLightingMat[0] = bsdfData.bakeDiffuseLighting0;
bakeDiffuseLightingMat[1] = bsdfData.bakeDiffuseLighting1;
bakeDiffuseLightingMat[2] = frontBakeDiffuseLighting;
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigRTBk.x, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[0];
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigRTBk.y, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[1];
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigRTBk.z, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[2];
bakeDiffuseLightingMat[0] = bsdfData.backBakeDiffuseLighting0;
bakeDiffuseLightingMat[1] = bsdfData.backBakeDiffuseLighting1;
bakeDiffuseLightingMat[2] = backBakeDiffuseLighting;
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigLBtF.x, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[0];
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigLBtF.y, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[1];
bakeDiffuseLighting += GetTransmissionWithAbsorption(bsdfData.rigLBtF.z, bsdfData.diffuseColor, bsdfData.absorptionRange) * bakeDiffuseLightingMat[2];
bakeDiffuseLighting *= scale;
}
//世界空间到切线空间方向转换
float3 TransformToLocalFrame(float3 L, BSDFData bsdfData)
{
float3 zVec = -bsdfData.normalWS;
float3 xVec = bsdfData.tangentWS.xyz;
float3 yVec = -cross(zVec, xVec) * bsdfData.tangentWS.w;//原代码没有负值，实际测试需要负值
float3x3 tbn = float3x3(xVec, yVec, zVec);
return mul(tbn, L);
}
CBSDF EvaluateBSDF(float3 L, BSDFData bsdfData)
{
CBSDF cbsdf;
ZERO_INITIALIZE(CBSDF, cbsdf);
float3 dir = TransformToLocalFrame(L, bsdfData);
float3 weights = dir >= 0 ? bsdfData.rigRTBk.xyz : bsdfData.rigLBtF.xyz;
float3 sqrDir = dir*dir;
cbsdf.diffR = GetTransmissionWithAbsorption(dot(sqrDir, weights), bsdfData.diffuseColor, bsdfData.absorptionRange);
return cbsdf;
}
//这一步最好在面板上做完
half GetAbsorptionRange(float absorptionStrenth)
{
return INV_PI + saturate(absorptionStrenth) * (1 - INV_PI);
}
//---------NBShaderUtility-----------
//UseInVerTex
void GetSixWayBakeDiffuseLight(real3 normalWS,real3 tangentWS,real3 biTangentWS,
inout half3 bakeDiffuseLighting0,inout half3 bakeDiffuseLighting1,inout half3 bakeDiffuseLighting2,
inout half3 backBakeDiffuseLighting0,inout half3 backBakeDiffuseLighting1,inout half3 backBakeDiffuseLighting2)
{
bakeDiffuseLighting0 = SampleSHVertex(tangentWS);
bakeDiffuseLighting1 = SampleSHVertex(biTangentWS);
bakeDiffuseLighting2 = SampleSHVertex(-normalWS);
backBakeDiffuseLighting0 = SampleSHVertex(-tangentWS);
backBakeDiffuseLighting1 = SampleSHVertex(-biTangentWS);
backBakeDiffuseLighting2 = SampleSHVertex(normalWS);
}
LightingData CreateSixWayLightingData(InputData inputData, half3 emission)
{
LightingData lightingData;
lightingData.giColor = inputData.bakedGI;
lightingData.emissionColor = emission;
lightingData.vertexLightingColor = 0;
lightingData.mainLightColor = 0;
lightingData.additionalLightsColor = 0;
return lightingData;
}
void GetSixWayEmission(inout BSDFData bsdfData,Texture2D rampMap,half4 emissionColor,bool isRampMap)
{
float input = pow(bsdfData.emissionInput,_SixWayInfo.y);
half3 emission = emissionColor * emissionColor.a;
if (isRampMap)
{
half4 rampSample = rampMap.Sample(sampler_linear_clamp,half2(input,0.5));
emission = emission * rampSample * rampSample.a;
}
else
{
emission *= input;
}
bsdfData.emission = emission;
}
half3 LightingSixWay(Light light,InputData inputData, BSDFData bsdfData)
{
half3 cbsdf_R = EvaluateBSDF(light.direction,bsdfData).diffR;
half3 radiance = light.color * light.distanceAttenuation * light.shadowAttenuation;
return PI * cbsdf_R * radiance;
}
//光照流程--->原型为UniversalFragmentBlinnPhong
half4 UniversalFragmentSixWay(InputData inputData,BSDFData bsdfData)
{
// #if defined(DEBUG_DISPLAY)
// half4 debugColor;
//
// if (CanDebugOverrideOutputColor(inputData, surfaceData, debugColor))
// {
// return debugColor;
// }
// #endif
#ifdef _LIGHT_LAYERS
uint meshRenderingLayers = GetMeshRenderingLayer();
#endif
half4 shadowMask = CalculateShadowMask(inputData);
// AmbientOcclusionFactor aoFactor = CreateAmbientOcclusionFactor(inputData, surfaceData);
AmbientOcclusionFactor aoFactor;
aoFactor.directAmbientOcclusion = 1;
aoFactor.indirectAmbientOcclusion = 1;
Light mainLight = GetMainLight(inputData, shadowMask, aoFactor);
// MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, aoFactor);
// inputData.bakedGI *= surfaceData.albedo;
// LightingData lightingData = CreateLightingData(inputData, surfaceData);
LightingData lightingData = CreateSixWayLightingData(inputData,bsdfData.emission);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers))
#endif
{
lightingData.mainLightColor += LightingSixWay(mainLight, inputData, bsdfData);
}
#if defined(_ADDITIONAL_LIGHTS)
uint pixelLightCount = GetAdditionalLightsCount();
#if USE_FORWARD_PLUS
for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
{
FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK
Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
#endif
{
lightingData.additionalLightsColor += LightingSixWay(light, inputData, bsdfData);
}
}
#endif
LIGHT_LOOP_BEGIN(pixelLightCount)
Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
#endif
{
lightingData.additionalLightsColor += LightingSixWay(light, inputData, bsdfData);
}
LIGHT_LOOP_END
#endif
#if defined(_ADDITIONAL_LIGHTS_VERTEX)
lightingData.vertexLightingColor += inputData.vertexLighting * surfaceData.albedo;
#endif
return CalculateFinalColor(lightingData, bsdfData.alpha);
}
half3 LightingHalfLambert(half3 lightColor, half3 lightDir, half3 normal)
{
half NdotL = saturate(dot(normal, lightDir));
NdotL = NdotL*0.5 + 0.5;
return lightColor * NdotL;
}
half3 CalculateHalfLambertBlinnPhong(Light light, InputData inputData, SurfaceData surfaceData)
{
half3 attenuatedLightColor = light.color * (light.distanceAttenuation * light.shadowAttenuation);
half3 lightDiffuseColor = LightingHalfLambert(attenuatedLightColor, light.direction, inputData.normalWS);
half3 lightSpecularColor = half3(0,0,0);
#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
half smoothness = exp2(10 * surfaceData.smoothness + 1);
lightSpecularColor += LightingSpecular(attenuatedLightColor, light.direction, inputData.normalWS, inputData.viewDirectionWS, half4(surfaceData.specular, 1), smoothness);
#endif
#if _ALPHAPREMULTIPLY_ON
return lightDiffuseColor * surfaceData.albedo * surfaceData.alpha + lightSpecularColor;
#else
return lightDiffuseColor * surfaceData.albedo + lightSpecularColor;
#endif
}
half4 UniversalFragmentHalfLambert(InputData inputData, half3 diffuse, half4 specularGloss, half smoothness, half3 emission, half alpha, half3 normalTS)
{
SurfaceData surfaceData;
surfaceData.albedo = diffuse;
surfaceData.alpha = alpha;
surfaceData.emission = emission;
surfaceData.metallic = 0;
surfaceData.occlusion = 1;
surfaceData.smoothness = smoothness;
surfaceData.specular = specularGloss.rgb;
surfaceData.clearCoatMask = 0;
surfaceData.clearCoatSmoothness = 1;
surfaceData.normalTS = normalTS;
// #if defined(DEBUG_DISPLAY)
// half4 debugColor;
//
// if (CanDebugOverrideOutputColor(inputData, surfaceData, debugColor))
// {
// return debugColor;
// }
// #endif
#ifdef _LIGHT_LAYERS
uint meshRenderingLayers = GetMeshRenderingLayer();
#endif
half4 shadowMask = CalculateShadowMask(inputData);
AmbientOcclusionFactor aoFactor = CreateAmbientOcclusionFactor(inputData, surfaceData);
Light mainLight = GetMainLight(inputData, shadowMask, aoFactor);
MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, aoFactor);
inputData.bakedGI *= surfaceData.albedo;
LightingData lightingData = CreateLightingData(inputData, surfaceData);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers))
#endif
{
lightingData.mainLightColor += CalculateHalfLambertBlinnPhong(mainLight, inputData, surfaceData);
}
#if defined(_ADDITIONAL_LIGHTS)
uint pixelLightCount = GetAdditionalLightsCount();
#if USE_FORWARD_PLUS
for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
{
FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK
Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
#endif
{
lightingData.additionalLightsColor += CalculateBlinnPhong(light, inputData, surfaceData);
}
}
#endif
LIGHT_LOOP_BEGIN(pixelLightCount)
Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor);
#ifdef _LIGHT_LAYERS
if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
#endif
{
lightingData.additionalLightsColor += CalculateHalfLambertBlinnPhong(light, inputData, surfaceData);
}
LIGHT_LOOP_END
#endif
#if defined(_ADDITIONAL_LIGHTS_VERTEX)
lightingData.vertexLightingColor += inputData.vertexLighting * surfaceData.albedo;
#endif
return CalculateFinalColor(lightingData, surfaceData.alpha);
}
#endif

3
Packages/NBShaders/Shader/HLSL/SixWaySmokeLit.hlsl.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 70e94bdedafe40bfb7f8e77cdc4bef0f
timeCreated: 1751704445

733
Packages/NBShaders/Shader/ParticleBase.shader
View File

@@ -1,733 +0,0 @@
Shader "Effects/NBShader"
{
Properties
{
_MeshSourceMode("Mesh来源模式",Float) = 0
_UIEffect_Toggle("UI模式_Toggle",Float) = 0
_DistortionBothDirection_Toggle("__DistortionBothDirection_Toggle",Float) = 0
_DistanceFade_Toggle("_DistanceFade_Toggle",Float) = 0
_ChangeSaturability_Toggle("__ChangeSaturability_Toggle",Float) = 0
_Mask_Toggle("__Mask_Toggle",Float) = 0
_Mask_RotationToggle("__Mask_RotationToggle",Float) = 0
_Mask2_Toggle("__Mask2_Toggle",Float) = 0
_Mask3_Toggle("__Mask3_Toggle",Float) = 0
_BaseBackColor_Toggle("__BaseBackColor_Toggle",Float) = 0
_UseUV1_Toggle("__UseUV1_Toggle",Float) = 0
_TransparentMode("_TransparentMode",Float) = 1
_ForceZWriteToggle("_ForceZWriteToggle",Float) = 0
_Dissolve_Toggle("__Dissolve_Toggle",Float) = 0
_DissolveMask_Toggle("__DissolveMask_Toggle",Float) = 0
_DissolveVoronoi_Toggle("__DissolveVoronoi_Toggle",Float) = 0
_Dissolve_useRampMap_Toggle("__Dissolve_useRampMap_Toggle",Float) = 0
_Dissolve_Test_Toggle("__Dissolve_Test_Toggle",Float) = 0
_FresnelMode("__FresnelMode",Float) = 0
_InvertFresnel_Toggle("__InvertFresnel_Toggle",Float) = 0
_HueShift_Toggle("__HueShift_Toggle",Float) = 0
_BackFaceColor_Toggle("_BackFaceColor_Toggle",Float) = 0
_BackFirstPassToggle("_BackFirstPassToggle",Float) = 0
_PolarCordinateOnlySpecialFunciton_Toggle("极坐标仅对特殊功能生效_Toggle",Float) = 0
_CustomData1X_MainTexOffsetX_Toggle("_CustomData1X_MainTexOffsetX_Toggle",Float) = 0
_CustomData1Y_MainTexOffsetY_Toggle("_CustomData1Y_MainTexOffsetY_Toggle",Float) = 0
_CustomData1Z_Dissolve_Toggle("_CustomData1Z_Dissolve_Toggle",Float) = 0
_CustomData1W_HueShift_Toggle("_CustomData1W_HueShift_Toggle",Float) = 0
_CustomData2X_MaskMapOffsetX_Toggle("_CustomData2X_MaskMapOffsetX_Toggle",Float) = 0
_CustomData2Y_MaskMapOffsetY_Toggle("_CustomData2Y_MaskMapOffsetY_Toggle",Float) = 0
_CustomData2Z_FresnelOffset_Toggle("_CustomData2Z_FresnelOffset_Toggle",Float) = 0
_CustomData2W_Toggle("_CustomData2W_Toggle",Float) = 0
// [PerRendererData] [MainTexture] _MainTex("Sprite Texture-ignore", 2D) = "white" {}
[PerRendererData] _MainTex ("Sprite Texture-ignore", 2D) = "white" {}
_Color("颜色贴图叠加", Color) = (1,1,1,1)
_UI_MainTex_ST("UI模式主贴图 xy:UV缩放 zw:UV偏移",vector) = (1,1,0,0)
_MainTex_Reverse_ST("MainTex_Reverse_ST-ignore",Vector) = (1,1,0,0)
_BaseMap ("主贴图 xy:UV缩放 zw:UV偏移", 2D) = "white" { }
_BaseMapMaskMapOffset ("xy主贴图偏移速度", vector) = (0, 0, 0, 0)
_BaseMapUVRotation ("主贴图旋转", Range(0, 360)) = 0
_BaseMapUVRotationSpeed ("主贴图旋转速度",Float) = 0
[HDR]_BaseColor ("主贴图颜色_hdr", Color) = (1, 1, 1, 1)//HDR颜色不需要做Gamma Linear转换，Unity默认用Linear颜色
// _BaseColor ("Base Color", Color) = (1, 1, 1, 1)//HDR颜色不需要做Gamma Linear转换，Unity默认用Linear颜色
[HDR]_BaseBackColor ("背面颜色_hdr", Color) = (1, 1, 1, 1)//HDR颜色不需要做Gamma Linear转换，Unity默认用Linear颜色
_BaseColorIntensityForTimeline("整体颜色强度", Range(0,10)) = 1 //独立出来是以为Timeline K颜色的时候会很奇怪的影响色相
_Saturability("饱和度", range(0,1)) = 0
_Contrast_Toggle("__Contrast_Toggle",Float) = 0
_Contrast("对比度", Float) = 1
_ContrastMidColor ("对比度中值颜色", Color) = (0.5, 0.5, 0.5, 1)//HDR颜色不需要做Gamma Linear转换，Unity默认用Linear颜色
_HueShift("色相",Range(0,1)) = 0
_BaseMapColorRefine_Toggle ("__BaseMapColorRefine_Toggle",Float) = 0
_BaseMapColorRefine("主贴图颜色Refine",Vector) = (1,1,2,1)
_AlphaAll("整体透明度",Range(0,1)) = 1
_IgnoreVetexColor_Toggle("_IgnoreVetexColor_Toggle",Float) = 0
_SpecialUVChannelMode("特殊UV通道选择",Float) = 0
_CylinderUVRotate("圆柱UV旋转",Vector) = (0,0,90,0)
_CylinderUVPosOffset("圆柱UV位置偏移",Vector) = (0,0,0,0)
_CylinderMatrix0("圆柱偏移矩阵0",Vector) = (0,0,0,0)
_CylinderMatrix1("圆柱偏移矩阵1",Vector) = (0,0,0,0)
_CylinderMatrix2("圆柱偏移矩阵2",Vector) = (0,0,0,0)
_CylinderMatrix3("圆柱偏移矩阵3",Vector) = (0,0,0,0)
_Cutoff ("裁剪位置", float) = 0
//--------------光照部分-------------
_FxLightMode("灯光模式",Float) = 0
_BumpMapToggle("法线贴图开关",Float) = 0
_BumpMapMaskMode("法线贴图多通道模式",Float) = 0
_BumpScale("Scale", Float) = 1.0
_BumpTex("Normal Map", 2D) = "bump" {}
_BumpTexFollowMainTexUVToggle("法线跟随主贴图UV",Float) = 0
_MaterialInfo("x:金属度,y:光滑度",Vector) = (1,1,0,0)
_BlinnPhongSpecularToggle("BlinnPhong高光开关",Float) = 0
[HDR]_SpecularColor("BlinnPhong高光颜色",Color) = (1,1,1,1)
//-----------SixWayLight----------
_RigRTBk("六路正方向图(P)",2D) = "white"{}
_RigLBtF("六路反方向图(N)",2D) = "white"{}
_SixWayColorAbsorptionToggle("六路光颜色吸收开关",Float) = 0
_SixWayInfo("x:六路吸收强度",Vector) = (0.5,0,0,0)
_SixWayEmissionRamp("六路自发光Ramp",2D) = "white"{}
[HDR]_SixWayEmissionColor("六路自发光颜色",Color) = (1,0.5,0,1)
//-----MatCap------
_MatCapToggle("MatCap开关",Float) = 0
_MatCapTex("MatCap图",2D) = "white"{}
[HDR]_MatCapColor("MatCap颜色",Color) = (1,1,1,1)
_MatCapInfo("x:MatCap叠加和相乘过渡",Vector) = (1,0,0,0)
// _MatCapBlendMode("MatCap叠加模式",Float) = 0
//时间缩放影响开关----------
[HideInInspector] _TimeMode("__TimeMode",float) = 0.0
_StencilWithoutPlayerToggle("剔除主角色开关",Float) = 0.0
// MaskMap-----------
_MaskRefineToggle("遮罩整体调整开关",Float) = 0
_MaskRefineVec("遮罩整体调整：x:Pow,y:相乘,z:相加",Vector) = (1,1,0,0)
_MaskMap ("遮罩贴图 xy:UV缩放 zw:UV偏移", 2D) = "white" { }
_MaskMap2 ("遮罩2贴图 xy:UV缩放 zw:UV偏移", 2D) = "white"{}
_MaskMap3 ("遮罩3贴图 xy:UV缩放 zw:UV偏移", 2D) = "white"{}
_MaskMapOffsetAnition("xy:遮罩偏移速度，zw:遮罩2偏移速度", vector) = (0,0,0,0)
_MaskMap3OffsetAnition("xy:遮罩3偏移速度", vector) = (0,0,0,0)
_MaskMapUVRotation ("遮罩旋转", Range(0, 360)) = 0.0
_MaskDistortion_intensity ("遮罩扭曲强度", float) = 0.0
_MaskMapRotationSpeed("遮罩旋转速度", float) = 0.0
_MaskMapVec("x整体遮罩强度,y遮罩2旋转,z遮罩3旋转",Vector) = (1,0,0,0)
_MaskMapGradientToggle("遮罩渐变模式",Float) = 0
_MaskMapGradientCount("颜色映射数量",Integer) = 2
_MaskMapGradientFloat0("x:MaskAlpha0,y:Pos0,z:MaskAlpha1,w:Pos1",Vector) = (0,0,1,1)
_MaskMapGradientFloat1("x:MaskAlpha2,y:Pos2,z:MaskAlpha3,w:Pos3",Vector) = (1,0,1,1)
_MaskMapGradientFloat2("x:MaskAlpha4,y:Pos4,z:MaskAlpha5,w:Pos5",Vector) = (1,0,1,1)
_MaskMap2GradientToggle("遮罩2渐变模式",Float) = 0
_MaskMap2GradientCount("颜色映射数量",Integer) = 2
_MaskMap2GradientFloat0("x:Mask2Alpha0,y:Pos0,z:Mask2Alpha1,w:Pos1",Vector) = (0,0,1,1)
_MaskMap2GradientFloat1("x:Mask2Alpha2,y:Pos2,z:Mask2Alpha3,w:Pos3",Vector) = (1,0,1,1)
_MaskMap2GradientFloat2("x:Mask2Alpha4,y:Pos4,z:Mask2Alpha5,w:Pos5",Vector) = (1,0,1,1)
_MaskMap3GradientToggle("遮罩3渐变模式",Float) = 0
_MaskMap3GradientCount("颜色映射数量",Integer) = 2
_MaskMap3GradientFloat0("x:Mask3Alpha0,y:Pos0,z:Mask3Alpha1,w:Pos1",Vector) = (0,0,1,1)
_MaskMap3GradientFloat1("x:Mask3Alpha2,y:Pos2,z:Mask3Alpha3,w:Pos3",Vector) = (1,0,1,1)
_MaskMap3GradientFloat2("x:Mask3Alpha4,y:Pos4,z:Mask3Alpha5,w:Pos5",Vector) = (1,0,1,1)
// 擦除----------------
//[Header(ChaChu(Anima For CustomData.z).......)]
//[KeywordEnum(NoChange,XianXing, JingXiang, Self)] _ch ("ChaChu mode", Float) = 0
[HideInInspector] _Chachu ("__Chachu_ignore", Float) = 0.0
_EdgeFade ("EdgeFade_ignore", Range(0, 1)) = 0.05
_XianXingCH_UVRota ("XianXingCH_UVRota_ignore", float) = 0
_jingxiangCH_dire ("Direction_ignore", Range(0, 1)) = 0
// 漩涡 -------------------
//[Toggle(_JIZUOBIAO)] _N121 ("JIZUOBIAO?", float) = 0
[HideInInspector] _UTwirlEnabled ("__UTwirlEnabled", Float) = 0.0
_TWParameter ("xy:旋转扭曲中心", vector) = (0.5, 0.5, 0, 0)
_TWStrength ("旋转扭曲强度", float) = 0
// 极坐标 -------------------
//[Toggle(_JIZUOBIAO)] _N121 ("JIZUOBIAO?", float) = 0
[HideInInspector]_PolarCoordinatesEnabled ("__PolarCoordinatesEnabled", Float) = 0.0
_PCCenter ("xy:极坐标中心 z:极坐标强度", vector) = (0.5, 0.5, 1, 0)//位置坐标用的前两个分量，z分量给强度。
// 噪波 --------------
//[Toggle(_NOISEMAP)]_N ("NOISEMAP?", float) =0
[HideInInspector] _noisemapEnabled ("__noisemapEnabled", Float) = 0.0
[HideInInspector] _noiseMaskMap_Toggle ("__noiseMaskMap_Toggle", Float) = 0.0
_NoiseMap ("扭曲贴图 xy:UV缩放 zw:UV偏移", 2D) = "white" { }
_NoiseMaskMap ("扭曲遮罩贴图 xy:UV缩放 zw:UV偏移", 2D) = "white" { }
_NoiseMapUVRotation("扭曲旋转",Range(0,360)) = 0
_NoiseOffset ("xy:扭曲偏移速度 ", vector) = (0, 0, 0, 0)//w分量为本地uv坐标到世界坐标的变化
_TexDistortion_intensity ("扭曲强度", float) = 0.5
_DistortionDirection ("扭曲方向xy, 色散强度z", vector) = (1,1,0,0)
_Distortion_Choraticaberrat_Toggle("扭曲色散开关_Toggle",Float) = 0
_Distortion_Choraticaberrat_WithNoise_Toggle("色散受扭曲影响_Toggle",Float) = 1
// 流光 ----------
//[Header(LiuGuang(Anima For CustomData.w).......)]
//[Toggle(_EMISSION)]_N1 ("EMISSION?", float) = 0
[HideInInspector] _EmissionEnabled ("__EmissionEnabled", Float) = 0.0
_EmissionMap ("流光贴图 xy:UV缩放 zw:UV偏移", 2D) = "white" { }
_EmissionMapUVRotation ("流光贴图旋转", Range(0, 360)) = 0
_Emi_Distortion_intensity ("流光贴图扭转强度", float) = 0
_EmissionMapUVOffset ("xy:流光贴图偏移速度", vector) = (0, 0, 0, 0)
_EmissionSelfAlphaWeight ("__EmissionSelfAlphaWeight_ignore", float) = 0
_uvRapSoft ("LiuuvRapSoft-ignore", Range(0, 1)) = 0
[HDR]_EmissionMapColor ("流光贴图颜色_hdr", Color) = (1, 1, 1, 1)
_EmissionMapColorIntensity("流光颜色强度", float) = 1
_EmissionFollowMainTexUV("流光跟随主贴图",Float) = 0
//颜色渐变贴图--------
_ColorBlendMap_Toggle("__ColorBlendMap_Toggle",Float) = 0
_ColorBlendMap("颜色渐变贴图 xy:UV缩放 zw:UV偏移",2D) = "white"{}
[HDR]_ColorBlendColor("颜色渐变叠加_hdr",Color) = (1,1,1,1)
_ColorBlendMapOffset("xy:颜色渐变贴图偏移动画",Vector) = (0,0,0,0)
_ColorBlendAlphaMultiplyMode("颜色渐变Alpha相乘开关",Float) = 0
_ColorBlendFollowMainTexUV("颜色渐变UV跟随主贴图UV",Float) = 0
_ColorBlendVec("x:颜色渐变扰动强度z:Alpha强度w:旋转",Vector) = (0,0,1,0)
//颜色映射Ramp
_RampColorToggle("颜色映射开关",Float) = 0
_RampColorSourceMode("Ramp来源模式",Float) = 0
_RampColorBlendMode("Ramp颜色混合模式",Float) = 0
_RampColorMap("颜色映射黑白图",2D) = "white"{}
_RampColor0("rgb:RampColor0,a:pos",Color) = (0,0,0,0)
_RampColor1("rgb:RampColor1,a:pos",Color) = (1,0,0,1)
_RampColor2("rgb:RampColor2,a:pos",Color) = (1,1,1,1)
_RampColor3("rgb:RampColor3,a:pos",Color) = (1,1,1,1)
_RampColor4("rgb:RampColor4,a:pos",Color) = (1,1,1,1)
_RampColor5("rgb:RampColor5,a:pos",Color) = (1,1,1,1)
_RampColorAlpha0("x:RampColorAlpha0,y:Pos0,z:RampColorAlpha1,w:Pos1",Vector) = (1,0,1,1)
_RampColorAlpha1("x:RampColorAlpha2,y:Pos2,z:RampColorAlpha3,w:Pos3",Vector) = (1,0,1,1)
_RampColorAlpha2("x:RampColorAlpha4,y:Pos4,z:RampColorAlpha5,w:Pos5",Vector) = (1,0,1,1)
_RampColorCount("颜色映射数量",Integer) = 2
[HDR]_RampColorBlendColor("颜色映射叠加颜色_hdr",Color) = (1,1,1,1)
_RampColorMapOffset("xy:颜色映射贴图偏移动画,w:旋转",Vector) = (0,0,0,0)
// Rongjie ------------------
// [Header(RongJie(Anima For CustomData.y).......)]
// [Toggle(_DISSOLVE)]_RJ ("RONGJIE?", float) = 0
_Dissolve ("x:溶解强度 y:溶解值Pow z:过程溶解强度 w:溶解硬软度", vector) = (0.5, 1, 0, 0.1)
_DissolveMap("溶解贴图 xy:UV缩放 zw:UV偏移",2D) = "grey"{}
_DissolveMaskMap("局部溶解蒙版 xy:UV缩放 zw:UV偏移",2D) = "white"{}
_DissolveOffsetRotateDistort("xy:溶解贴图偏移速度 z:溶解贴图旋转",Vector) = (0,0,0,0)
[HDR]_DissolveLineColor("溶解描边颜色_hdr",Color) = (1,0,0,1)
_DissolveVoronoi_Vec("xy:噪波1缩放,zw:噪波2缩放",Vector) = (1,1,2,2)
_DissolveVoronoi_Vec2("x:噪波1和噪波2混合系数(圆尖),y:噪波整体和溶解贴图混合系数,z:噪波1速度,w:噪波2速度",Vector) = (1,1,2,2)
_DissolveVoronoi_Vec3("xy:噪波1偏移速度,zw:噪波2偏移速度",Vector) = (0,0,0,0)
_DissolveVoronoi_Vec4("xy:噪波1偏移,zw:噪波2偏移",Vector) = (0,0,0,0)
_Dissolve_Vec2("x:Ramp位置偏移,y:Ramp范围",Vector) = (0.2,0.1,0,0)
_DissolveRampMap("溶解Ramp图",2D) = "white"{}
_DissolveRampColorBlendMode("溶解Ramp图混合模式",Float) = 0
[HDR]_DissolveRampColor("溶解Ramp颜色_hdr",Color) = (1,1,1,1)
_DissolveLineMaskToggle("溶解描边开关",Float) = 0
_DissolveRampSourceMode("溶解Ramp来源模式",Float) = 0
_DissolveRampColor0("rgb:DissolveRampColor0,a:pos",Color) = (1,0,0,0)
_DissolveRampColor1("rgb:DissolveRampColor1,a:pos",Color) = (0,0,0,1)
_DissolveRampColor2("rgb:DissolveRampColor2,a:pos",Color) = (1,1,1,1)
_DissolveRampColor3("rgb:DissolveRampColor3,a:pos",Color) = (1,1,1,1)
_DissolveRampColor4("rgb:DissolveRampColor4,a:pos",Color) = (1,1,1,1)
_DissolveRampColor5("rgb:DissolveRampColor5,a:pos",Color) = (1,1,1,1)
_DissolveRampAlpha0("x:DissolveRampAlpha0,y:Pos0,z:DissolveRampAlpha1,w:Pos1",Vector) = (1,0,1,1)
_DissolveRampAlpha1("x:DissolveRampAlpha2,y:Pos2,z:DissolveRampAlpha3,w:Pos3",Vector) = (1,0,1,1)
_DissolveRampAlpha2("x:DissolveRampAlpha4,y:Pos4,z:DissolveRampAlpha5,w:Pos5",Vector) = (1,0,1,1)
_DissolveRampCount("溶解Ramp映射数量",Integer) = 2
_CustomData1X ("ignore", float) = 0
_CustomData1Y ("ignore", float) = 0
//因为希望本Shader兼容CanvasRender，由于Canvas渲染只会传递TEXCOORD通道的xy分量（zw分量忽略）的特性,所以强制让CustomedData只传递xy分量。
_CustomData2X ("ignore", float) = 0
// -------------------------------------
// Particle specific 属于粒子特殊的属性
[ToggleOff] _CustomData ("__CustomData_Toggle", Float) = 0.0 //Toggleoff 和 Toggle 的区别
[ToggleOff] _FlipbookBlending ("__flipbookblending_Toggle", Float) = 0.0 //Toggleoff 和 Toggle 的区别
// _SoftParticlesNearFadeDistance ("Soft Particles Near Fade", Float) = 0.0
// _SoftParticlesFarFadeDistance ("Soft Particles Far Fade", Float) = 1.0
//[Toggle] _Fading ("Fading? =Default(1,2,0,0)", Float) = 0.0
_CameraNearFadeDistance ("Camera Near Fade-ignore", Float) = 1.0
_CameraFarFadeDistance ("Camera Far Fade-ignore", Float) = 2.0
//临时
_fogintensity ("雾影响强度", Range(0, 1)) = 1
// -------------------------------------
// Hidden properties - Generic 通用的隐藏属性
_AdditiveToPreMultiplyAlphaLerp("相加到预乘混合",Range(0,1)) = 0.0
[HideInInspector] _Blend ("__mode-ignore", Float) = 0.0
[HideInInspector] _AlphaClip ("__clip-ignore", Float) = 0.0
[HideInInspector] _SrcBlend ("__src-ignore", Float) = 1.0
[HideInInspector] _DstBlend ("__dst-ignore", Float) = 0.0
[HideInInspector] _Cull ("__cull-ignore", Float) = 2.0
[HideInInspector] _ZTest ("__ztest-ignore", Float) = 4.0 //默认值LEqual
[HideInInspector] _ZWrite("__ZWrite-ignore", Float) = 0 //默认值LEqual
// [HideInInspector] _ZTestt ("__ztestt", Float) = 4.0//雨轩：注释掉了。。。这是个什么鬼。。。
_CustomStencilTest ("__CustomStencilTest-ignore", Float) = 0
_StencilKeyIndex("__StencilKeyIndex-ignore",Float) = 0
[Enum(UnityEngine.Rendering.CompareFunction)] _StencilComp ("__StencilComp-ignore", Float) = 8
_Stencil("Stencil ID-ignore", Float) = 0
[Enum(UnityEngine.Rendering.StencilOp)]_StencilOp("Stencil Operation-ignore", Float) = 0
_StencilWriteMask ("Stencil Write Mask-ignore", Float) = 255
_StencilReadMask ("Stencil Read Mask-ignore", Float) = 255
_ColorMask("Color Mask-ignore", Float) = 15
//[HideInInspector] _ZTestO ("__ztest0", Float) = 1.0
_FresnelFadeDistance ("菲涅尔透明乘数", float) = 1
_FresnelUnit("菲涅尔通用", Vector) = (0,0.5,1,0.5)
_DepthOutline_Toggle("深度描边",Float) = 0
[HDR]_DepthOutline_Color("深度描边颜色_hdr",Color) = (1,1,1,1)
_DepthOutline_Vec("菲涅尔深度描边参数",Vector) = (0,0.5,0,0)
_FresnelColorAffectByAlpha("菲涅尔颜色受Alpha影响",Float) = 1
// _DepthOutline_withoutFresnel_Toggle("深度描边关闭菲涅尔",Float) = 0
// _FresnelUnit2("菲涅尔通用2", Vector) = (1,1,0,0)
_DepthDecal_Toggle("深度贴花",Float) = 0
_VertexOffset_Toggle("顶点偏移",Float) = 0
_VertexOffset_Map("顶点偏移贴图",2D) = "white"{}
_VertexOffset_Vec("xy:顶点偏移动画z:顶点偏移强度",Vector) = (0,0,1,0)
_VertexOffset_NormalDir_Toggle("顶点偏移自定义方向开关",Float) = 0
_VertexOffset_StartFromZero("顶点偏移从零开始开关",Float) = 0
_VertexOffset_CustomDir("顶点偏移自定义方向",Vector) = (1,1,1,0)
_VertexOffset_Mask_Toggle("顶点偏移遮罩开关",Float) = 0
_VertexOffset_MaskMap("顶点偏移遮罩贴图",2D) = "white"{}
_VertexOffset_MaskMap_Vec("xy:顶点偏移遮罩动画z:顶点偏移遮罩强度",Vector) = (0,0,1,0)
_ParallaxMapping_Toggle("视差",Float) = 0
_ParallaxMapping_Map("视差贴图",2D) = "white"{}
_ParallaxMapping_Intensity("视差强度",Float) = 0.05
_ParallaxMapping_Vec("遮蔽视差层数 x:最小值,y:最大值",Vector) = (5,30,0,0)
// Particle specific 粒子特殊的隐藏属性
[HideInInspector] _ColorMode ("_ColorMode", Float) = 0.0
[HideInInspector] _BaseColorAddSubDiff ("_ColorMode", Vector) = (0, 0, 0, 0)
[HideInInspector] _SoftParticlesEnabled ("__softparticlesenabled", Float) = 0.0
[HideInInspector] _CameraFadingEnabled ("__camerafadingenabled", Float) = 0.0
[HideInInspector] _SoftParticleFadeParams ("xy:软粒子远近裁剪面", Vector) = (0, 0.5, 0, 0)
[HideInInspector] _CameraFadeParams ("__camerafadeparams_ignore", Vector) = (0, 0, 0, 0)
[HideInInspector] _IntersectEnabled("__IntersectEnabled_ignore",Float) = 0.0
[HideInInspector] _IntersectRadius("__IntersectRadius_ignore",Float) = 0.3
[HideInInspector] _IntersectColor("__IntersectColor_ignore",Color) = (1,1,1,1)
[HideInInspector] _ScreenDistortModeToggle("_ScreenDistortModeToggle",Float) = 0
// Editmode props 编辑模式下的PropFlags？
[HideInInspector] _QueueBias ("Queue偏移_QueueBias", Float) =0
// ObsoleteProperties 弃用的属性？？？？
[HideInInspector] _FlipbookMode ("flipbook mode", Float) = 0
[HideInInspector] _Mode ("mode", Float) = 0
// [HideInInspector] _Color ("color", Color) = (1, 1, 1, 1)
[HideInInspector]_fresnelEnabled ("__fresnelEnabled", Float) = 0.0
[NoScaleOffset]_FresnelHDRITex("__FresnelHDRITex_ignore",Cube) = "white"{}
[HDR]_FresnelColor ("菲涅尔颜色_hdr", COLOR) = (1, 1, 1, 1)
_FresnelRotation("菲涅尔方向偏移",vector) = (0,0,0,0.5)
_FresnelInOutSlider ("direction-ignore", Range(0, 1)) = 1
_FrePower ("FrePower-ignore", Range(0,1)) = 0.5
_FresnelSelfAlphaWeight("__FresnelSelfAlphaWeight-ignore",float) = 0
//用于程序控制透明属性
[HideInInspector] _ColorA ("ColorA-ignore", Color) = (1,1,1,1)
_Portal_Toggle("模板视差开关",Float) = 0
_Portal_MaskToggle("模板视差蒙版开关",Float) = 0
//基于深度的a通道控制
[HideInInspector] _Fade("xy:近距离透明过度范围", Vector) = (2,4,0,0)
[HideInInspector] _InspectorData("__InspectorData-ignore",vector) = (1,1,0,0)
[Header(ZOffset)]
_ZOffset_Toggle("深度偏移_Toggle",Float) = 0
_offsetFactor("深度偏移Sacle-ignore", range(-2000,2000)) = 0
_offsetUnits("深度偏移单位距离-ignore", range(-2000,2000)) = 0
[HideInInspector] _W9ParticleShaderFlags("_W9ParticleShaderFlags", Integer) = 0
[HideInInspector] _W9ParticleShaderFlags1("_W9ParticleShaderFlags1", Integer) = 0
[HideInInspector] _W9ParticleShaderWrapFlags("_W9ParticleShaderWrapFlags", Integer) = 0
[HideInInspector] _W9ParticleCustomDataFlag0("_W9ParticleCustomDataFlag0", Integer) = 0
[HideInInspector] _W9ParticleCustomDataFlag1("_W9ParticleCustomDataFlag1", Integer) = 0
[HideInInspector] _W9ParticleCustomDataFlag2("_W9ParticleCustomDataFlag2", Integer) = 0
[HideInInspector] _W9ParticleCustomDataFlag3("_W9ParticleCustomDataFlag3", Integer) = 0
[HideInInspector] _UVModeFlag0("_UVModeFlag0", Integer) = 0
[HideInInspector] _W9ParticleShaderGUIFoldToggle("_W9ParticleShaderGUIFoldToggle", Integer) = 3//前2个开关默认打开
[HideInInspector] _W9ParticleShaderGUIFoldToggle1("_W9ParticleShaderGUIFoldToggle1", Integer) = 255//这边默认全开
[HideInInspector] _W9ParticleShaderGUIFoldToggle2("_W9ParticleShaderGUIFoldToggle2", Integer) = 255//这边默认全开
[HideInInspector] _W9ParticleShaderColorChannelFlag("_W9ParticleShaderColorChannelFlag", Integer) = 3//默认主贴图开A通道
SaturabilityRangeVec("_Saturability",Vector) = (0,1,0,0)
TexDistortionintensityRangeVec("_TexDistortion_intensity",Vector) = (-1,1,0,0)
MaskDistortionIntensityRangeVec("_MaskDistortion_intensity",Vector) = (-2,2,0,0)
EmiDistortionIntensityRangeVec("_TexDistortion_intensity",Vector) = (-1,1,0,0)
BumpScaleRangeVec("_BumpScale",Vector) = (-1,1,0,0)
DissolveXRangeVec("_Dissolve.x",Vector) = (-1,2,0,0)
Dissolve2XRangeVec("_Dissolve_Vec2.x",Vector) = (0,1,0,0)
Dissolve2YRangeVec("_Dissolve_Vec2.y",Vector) = (0,1,0,0)
AlphaAllRangeVec("_AlphaAll",Vector) = (0,1,0,0)
// _offsetUnits("深度偏移单位距离-ignore", range(-2000,2000)) = 0
}
SubShader
{
Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" "PreviewType"="Sphere" "CanUseSpriteAtlas"="True" }
Stencil
{
Ref [_Stencil]
Comp [_StencilComp]
Pass [_StencilOp]
ReadMask [_StencilReadMask]
WriteMask [_StencilWriteMask]
}
//BlendOp[_BlendOp] //考虑注释~
Blend[_SrcBlend][_DstBlend]
ZWrite [_ZWrite]//粒子不写入深度缓冲
ZTest[_ZTest]
ColorMask [_ColorMask]
// ------------------------------------------------------------------
// 预渲染反面Pass，基本理念。先剔除正面棉片，渲染反面面片（一般在后），然后常规Pass再渲染正面（一般在前）
// 这样可以应对大部分的特效半透明渲染的次序问题。
// URP下的多Pass渲染，需要使用特定的LightModeTag：
// https://zhuanlan.zhihu.com/p/469589277#:~:text=%E6%B3%A8%E6%84%8F%E7%AC%AC%E4%BA%8C%E4%B8%AA%E5%85%89%E7%85%A7pass%E7%9A%84%E5%85%89%E7%85%A7tag%E4%B8%BA%20%22LightMode%22%20%3D%20%22SRPDefaultUnlit%22%EF%BC%8C%E8%BF%99%E6%98%AF%E5%9B%A0%E4%B8%BA%E5%BF%85%E9%A1%BB%E8%AE%BE%E7%BD%AE%E4%B8%BA%E7%89%B9%E5%AE%9A%E7%9A%84%E5%87%A0%E4%B8%AALightMode%20%E6%89%8D%E8%83%BD%E6%AD%A3%E7%A1%AE%E8%A2%AB%E6%B8%B2%E6%9F%93%E3%80%82%E5%85%B7%E4%BD%93%E5%93%AA%E5%87%A0%E4%B8%AA%20LightMode%20%E8%A7%81URP%E5%8C%85%E9%87%8C%E7%9A%84%20Runtime/Passes%20%E9%87%8C%E7%9A%84%20DrawObjectsPass.cs%E8%84%9A%E6%9C%AC%EF%BC%8C%E9%87%8C%E9%9D%A2%E6%9C%89%E5%A6%82%E4%B8%8B%E4%BB%A3%E7%A0%81%EF%BC%9A
// 开关Pass，同样也需要用到LightTag
// https://blog.csdn.net/shaoy1234567/article/details/106494878
Pass
{
Tags
{
"LightMode" = "SRPDefaultUnlit" "Queue"="Opaque"
}
offset [_offsetFactor], [_offsetUnits]
Name "SRPDefaultUnlit"
Cull Front
HLSLPROGRAM
#define PARTICLE
#pragma target 4.5
#pragma exclude_renderers d3d11_9x
#pragma exclude_renderers d3d9
#pragma enable_d3d11_debug_symbols // 保留D3D11调试符号
// -------------------------------------
// Material Keywords
#pragma shader_feature_local _ _SCREEN_DISTORT_MODE
#pragma shader_feature_local _ _MASKMAP_ON
// #pragma shader_feature_local _MASKMAP
// #pragma shader_feature_local _MASKMAP2
//#pragma shader_feature_local _NOISEMAP
#pragma shader_feature_local _NOISEMAP
//#pragma shader_feature_local _EMISSION //流光
#pragma shader_feature_local _EMISSION
//#pragma shader_feature_local _ _DISSOLVE //溶解
#pragma shader_feature_local _DISSOLVE
//后续Test类的关键字要找机会排除
#pragma shader_feature_local _DISSOLVE_EDITOR_TEST
#pragma shader_feature_local _COLORMAPBLEND//颜色渐变
#pragma shader_feature_local _COLOR_RAMP//颜色映射
//将光照和UI混用，达到节省Keywords的目的。
#pragma multi_compile _ UNITY_UI_CLIP_RECT _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS//UI 2D遮罩
// #pragma multi_compile _ _UIPARTICLE_ON//用于UIParticle组件动态更改参数//暂时注释掉，觉得没什么意义
#pragma multi_compile _ SOFT_UI_FRAME EVALUATE_SH_MIXED EVALUATE_SH_VERTEX//用于UI软蒙版
#pragma shader_feature_local _PARCUSTOMDATA_ON
//用于特效层关键字
// #pragma shader_feature_local _UIEFFECT_ON
#pragma shader_feature_local _ FRESNEL_CUBEMAP FRESNEL_REFLECTIONPROBE
// -------------------------------------
// Particle Keywords
#pragma shader_feature_local _ _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON //设置alpah Add 。。组合
#pragma shader_feature_local _ALPHATEST_ON
//#pragma shader_feature_local _ _COLOROVERLAY_ON _COLORCOLOR_ON _COLORADDSUBDIFF_ON //粒子颜色和材质颜色的混合运算 暂时先不要了
#pragma shader_feature_local _FLIPBOOKBLENDING_ON
#pragma shader_feature_local _SOFTPARTICLES_ON
// #pragma shader_feature_local _OCCLUDEOPACITY_ON
// #pragma shader_feature_local _ _SATURABILITY_ON
//UnscaleTime用于接收项目传的公开不受缩放影响的Time值
#pragma shader_feature_local _UNSCALETIME
//scriptableTime用于程序每帧传值
#pragma shader_feature_local _SCRIPTABLETIME
//#pragma shader_feature_local _DISTORTION_ON
#pragma shader_feature_local _NOISEMAP_NORMALIZEED
#pragma shader_feature_local _DEPTH_DECAL
#pragma shader_feature_local _PARALLAX_MAPPING
#pragma shader_feature_local _STENCIL_WITHOUT_PLAYER
//LIGHTING
#pragma shader_feature_local _FX_LIGHT_MODE_UNLIT _FX_LIGHT_MODE_BLINN_PHONG _FX_LIGHT_MODE_HALF_LAMBERT _FX_LIGHT_MODE_PBR _FX_LIGHT_MODE_SIX_WAY
#pragma shader_feature_local _ _NORMALMAP
#pragma shader_feature_local _ _MATCAP
#pragma shader_feature_local _ _SPECULAR_COLOR
#pragma shader_feature_local _ VFX_SIX_WAY_ABSORPTION
// -------------------------------------
// Unity defined keywords
// 之后进行优化时再说。
#pragma multi_compile_fog
// #define FOG_EXP2 1
// #if defined(_SOFTPARTICLES_ON)
// #define NEED_EYE_DEPTH
// #endif
#define PARTICLE_BACKFACE_PASS
#pragma vertex vertParticleUnlit
#pragma fragment fragParticleUnlit
// #include "UnityCG.cginc"
// #include "AutoLight.cginc"
// #include "UnityUI.cginc"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.xuanxuan.render.utility/Shader/HLSL/XuanXuan_Utility.hlsl"
#include "HLSL/ParticlesUnlitForwardPassNew.hlsl"
ENDHLSL
}
// ------------------------------------------------------------------
// Forward pass.
Pass
{
Tags
{
"LightMode" = "UniversalForward"
} //Queue设置是希望特效渲染在场景透明物体前面
offset [_offsetFactor], [_offsetUnits]
Cull[_Cull]
HLSLPROGRAM
#define PARTICLE
//20240228 target3.0 顶点着色器限制16个输出。提高版本
#pragma target 4.5
// -------------------------------------
// Material Keywords
#pragma enable_d3d11_debug_symbols // 保留D3D11调试符号
#pragma shader_feature_local _ _SCREEN_DISTORT_MODE
#pragma shader_feature_local _ _MASKMAP_ON
// #pragma shader_feature_local _MASKMAP
// #pragma shader_feature_local _MASKMAP2
//#pragma shader_feature_local _NOISEMAP
#pragma shader_feature_local _NOISEMAP
//#pragma shader_feature_local _EMISSION //流光
#pragma shader_feature_local _EMISSION
//#pragma shader_feature_local _ _DISSOLVE //溶解
#pragma shader_feature_local _DISSOLVE
//后续Test类的关键字要找机会排除
#pragma shader_feature_local _DISSOLVE_EDITOR_TEST
#pragma shader_feature_local _COLORMAPBLEND//颜色渐变
#pragma shader_feature_local _COLOR_RAMP//颜色映射
#pragma multi_compile_local _ UNITY_UI_CLIP_RECT _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS //UI 2D遮罩
// #pragma shader_feature_local _ _CH_XIANXING _CH_JINGXIANG _CH_SELF //线性擦除 径向擦除 mask擦除
#pragma shader_feature_local _PARCUSTOMDATA_ON
//用于特效层关键字
// #pragma shader_feature_local _UIEFFECT_ON
#pragma shader_feature_local _ FRESNEL_CUBEMAP FRESNEL_REFLECTIONPROBE
// #pragma multi_compile _ _UIPARTICLE_ON//用于UIParticle组件动态更改参数//暂时注释掉，觉得没什么意义
#pragma multi_compile _ SOFT_UI_FRAME EVALUATE_SH_MIXED EVALUATE_SH_VERTEX//用于UI软蒙版
// -------------------------------------
// Particle Keywords
#pragma shader_feature_local _ _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON //设置alpah Add 。。组合
#pragma shader_feature_local _ALPHATEST_ON
//#pragma shader_feature_local _ _COLOROVERLAY_ON _COLORCOLOR_ON _COLORADDSUBDIFF_ON //粒子颜色和材质颜色的混合运算 暂时先不要了
#pragma shader_feature_local _FLIPBOOKBLENDING_ON
#pragma shader_feature_local _SOFTPARTICLES_ON
// #pragma shader_feature_local _OCCLUDEOPACITY_ON
// #pragma shader_feature_local _ _SATURABILITY_ON
//UnscaleTime用于接收项目传的公开不受缩放影响的Time值
#pragma shader_feature_local _UNSCALETIME
//scriptableTime用于程序每帧传值
#pragma shader_feature_local _SCRIPTABLETIME
//#pragma shader_feature_local _DISTORTION_ON
#pragma shader_feature_local _NOISEMAP_NORMALIZEED
#pragma shader_feature_local _DEPTH_DECAL
#pragma shader_feature_local _PARALLAX_MAPPING
#pragma shader_feature_local _STENCIL_WITHOUT_PLAYER
//LIGHTING
#pragma shader_feature_local _FX_LIGHT_MODE_UNLIT _FX_LIGHT_MODE_BLINN_PHONG _FX_LIGHT_MODE_HALF_LAMBERT _FX_LIGHT_MODE_PBR _FX_LIGHT_MODE_SIX_WAY
#pragma shader_feature_local _ _NORMALMAP
#pragma shader_feature_local _ _MATCAP
#pragma shader_feature_local _ _SPECULAR_COLOR
#pragma shader_feature_local _ VFX_SIX_WAY_ABSORPTION
// -------------------------------------
// Unity defined keywords
// 之后进行优化时再说。
#pragma multi_compile_fog
// #define FOG_EXP2 1
#pragma vertex vertParticleUnlit
#pragma fragment fragParticleUnlit
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
// The DeclareDepthTexture.hlsl file contains utilities for sampling the Camera
// depth texture.
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.xuanxuan.render.utility/Shader/HLSL/XuanXuan_Utility.hlsl"
#include "HLSL/ParticlesUnlitForwardPassNew.hlsl"
ENDHLSL
}
// ------------------------------------------------------------------
// Forward pass.
Pass
{
Tags
{
"LightMode" = "Universal2D"
} //Queue设置是希望特效渲染在场景透明物体前面
offset [_offsetFactor], [_offsetUnits]
Cull[_Cull]
HLSLPROGRAM
#define PARTICLE
//20240228 target3.0 顶点着色器限制16个输出。提高版本
#pragma target 4.5
// -------------------------------------
// Material Keywords
#pragma enable_d3d11_debug_symbols // 保留D3D11调试符号
#pragma shader_feature_local _ _SCREEN_DISTORT_MODE
#pragma shader_feature_local _ _MASKMAP_ON
// #pragma shader_feature_local _MASKMAP
// #pragma shader_feature_local _MASKMAP2
//#pragma shader_feature_local _NOISEMAP
#pragma shader_feature_local _NOISEMAP
//#pragma shader_feature_local _EMISSION //流光
#pragma shader_feature_local _EMISSION
//#pragma shader_feature_local _ _DISSOLVE //溶解
#pragma shader_feature_local _DISSOLVE
//后续Test类的关键字要找机会排除
#pragma shader_feature_local _DISSOLVE_EDITOR_TEST
#pragma shader_feature_local _COLORMAPBLEND//颜色渐变
#pragma shader_feature_local _COLOR_RAMP//颜色映射
#pragma multi_compile_local _ UNITY_UI_CLIP_RECT _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS //UI 2D遮罩
// #pragma shader_feature_local _ _CH_XIANXING _CH_JINGXIANG _CH_SELF //线性擦除 径向擦除 mask擦除
#pragma shader_feature_local _PARCUSTOMDATA_ON
//用于特效层关键字
// #pragma shader_feature_local _UIEFFECT_ON
#pragma shader_feature_local _ FRESNEL_CUBEMAP FRESNEL_REFLECTIONPROBE
// #pragma multi_compile _ _UIPARTICLE_ON//用于UIParticle组件动态更改参数//暂时注释掉，觉得没什么意义
#pragma multi_compile _ SOFT_UI_FRAME EVALUATE_SH_MIXED EVALUATE_SH_VERTEX//用于UI软蒙版
// -------------------------------------
// Particle Keywords
#pragma shader_feature_local _ _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON //设置alpah Add 。。组合
#pragma shader_feature_local _ALPHATEST_ON
//#pragma shader_feature_local _ _COLOROVERLAY_ON _COLORCOLOR_ON _COLORADDSUBDIFF_ON //粒子颜色和材质颜色的混合运算 暂时先不要了
#pragma shader_feature_local _FLIPBOOKBLENDING_ON
#pragma shader_feature_local _SOFTPARTICLES_ON
// #pragma shader_feature_local _OCCLUDEOPACITY_ON
// #pragma shader_feature_local _ _SATURABILITY_ON
//UnscaleTime用于接收项目传的公开不受缩放影响的Time值
#pragma shader_feature_local _UNSCALETIME
//scriptableTime用于程序每帧传值
#pragma shader_feature_local _SCRIPTABLETIME
//#pragma shader_feature_local _DISTORTION_ON
#pragma shader_feature_local _NOISEMAP_NORMALIZEED
#pragma shader_feature_local _DEPTH_DECAL
#pragma shader_feature_local _PARALLAX_MAPPING
#pragma shader_feature_local _STENCIL_WITHOUT_PLAYER
//LIGHTING
#pragma shader_feature_local _FX_LIGHT_MODE_UNLIT _FX_LIGHT_MODE_BLINN_PHONG _FX_LIGHT_MODE_HALF_LAMBERT _FX_LIGHT_MODE_PBR _FX_LIGHT_MODE_SIX_WAY
#pragma shader_feature_local _ _NORMALMAP
#pragma shader_feature_local _ _MATCAP
#pragma shader_feature_local _ _SPECULAR_COLOR
#pragma shader_feature_local _ VFX_SIX_WAY_ABSORPTION
// -------------------------------------
// Unity defined keywords
// 之后进行优化时再说。
#pragma multi_compile_fog
// #define FOG_EXP2 1
#pragma vertex vertParticleUnlit
#pragma fragment fragParticleUnlit
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
// The DeclareDepthTexture.hlsl file contains utilities for sampling the Camera
// depth texture.
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
#include "Packages/com.xuanxuan.render.utility/Shader/HLSL/XuanXuan_Utility.hlsl"
#include "HLSL/ParticlesUnlitForwardPassNew.hlsl"
ENDHLSL
}
}
CustomEditor "NBShaderEditor.ParticleBaseGUI"
}

9
Packages/NBShaders/Shader/ParticleBase.shader.meta
View File

@@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: 7184a95c20fc1a441a8815af4c795ccd
ShaderImporter:
externalObjects: {}
defaultTextures: []
nonModifiableTextures: []
userData:
assetBundleName:
assetBundleVariant:

BIN
Packages/NBShaders/Shader/StencilConfig.asset LFS
View File

Binary file not shown.

8
Packages/NBShaders/Shader/StencilConfig.asset.meta
View File

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

7
Packages/NBShaders/package.json
View File

@@ -1,7 +0,0 @@
{
"name": "com.xuanxuan.nb.shaders",
"version": "0.0.1",
"displayName": "NBShaders",
"description": "NB特效渲染相关功能",
"unity": "2019.1"
}

7
Packages/NBShaders/package.json.meta
View File

@@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 48379e0a1548d0744956d75379b0c724
PackageManifestImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

3
Packages/XuanXuanRenderUtility/Editor.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: fd758a702a9040fcb8614b232817cff9
timeCreated: 1721290722

100
Packages/XuanXuanRenderUtility/Editor/BinaryIntAttribute.cs
View File

@@ -1,100 +0,0 @@
using UnityEditor;
using UnityEngine;
using System;
// using Unity.Properties;
public class BinaryIntAttribute : PropertyAttribute
{
public int binaryBits;
public bool showInputFiled;
public int tabNums;
public BinaryIntAttribute(int Bits = 32,bool showInput = false,int tab = 0)
{
binaryBits = Bits;
showInputFiled = showInput;
tabNums = tab;
}
}
[CustomPropertyDrawer(typeof(BinaryIntAttribute))]
public class BinaryIntDrawer : PropertyDrawer
{
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
GUIStyle richTextStyle = EditorStyles.label;
richTextStyle.richText = true;
BinaryIntAttribute binaryIntAttribute = (BinaryIntAttribute)attribute;
// int value = property.intValue;
// int largestBit = 0;
// for (int i = 0; i < 32; i++)
// {
// if ((~value & (1 << i)) == 0)
// {
// largestBit = i;
// }
// }
//
// int addZeroCount = 0;
// if (largestBit < binaryIntAttribute.binaryBits)
// {
// addZeroCount = binaryIntAttribute.binaryBits - largestBit - 1;
// }
//
// string addZeroString = "";
// for (int i = 0; i < addZeroCount; i++)
// {
// addZeroString += "0";
// }
// string binary = addZeroString+Convert.ToString(property.intValue, 2);
string binary = DrawBinaryInt(property.intValue, binaryIntAttribute.binaryBits);
string tabs = "";
for (int i = 0; i < binaryIntAttribute.tabNums; i++)
{
tabs += "\t";
}
if (binaryIntAttribute.showInputFiled)
{
string labelText = property.displayName + tabs + "<mspace=1em>" + binary + "</mspace>";
Rect intRect = EditorGUI.PrefixLabel(position,new GUIContent(labelText),richTextStyle);
property.intValue = EditorGUI.IntField( intRect,property.intValue);
}
else
{
EditorGUILayout.LabelField(property.displayName + tabs);
EditorGUILayout.LabelField(binary);
}
}
public static string DrawBinaryInt(int value ,int binaryBits)
{
int largestBit = 0;
for (int i = 0; i < 32; i++)
{
if ((~value & (1 << i)) == 0)
{
largestBit = i;
}
}
int addZeroCount = 0;
if (largestBit < binaryBits)
{
addZeroCount = binaryBits - largestBit - 1;
}
string addZeroString = "";
for (int i = 0; i < addZeroCount; i++)
{
addZeroString += "0";
}
string binary = addZeroString+Convert.ToString(value, 2);
return binary;
}
}

11
Packages/XuanXuanRenderUtility/Editor/BinaryIntAttribute.cs.meta
View File

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

249
Packages/XuanXuanRenderUtility/Editor/GradientRefletctionHelper.cs
View File

@@ -1,249 +0,0 @@
using System;
using System.Reflection;
using UnityEngine;
//因为GradientPicker窗口，在窗口打开时使用的是Gradient对象的Cache。
//如果有Undo操作，导致MaterialProperty更新了，但Gradient却更新不到ColorPicer里。所以在这里进行强制更新。
//后续需要强制更新Picker的时候，也可以用这里。
//DeepSeek写的。谨慎用。
public static class GradientReflectionHelper
{
#region GradientPicker 相关
private static Type _gradientPickerType;
// SetCurrentGradient 方法
private static MethodInfo _setGradientMethod;
private static Action<Gradient> _setGradientDelegate;
// RefreshGradientData 方法
private static MethodInfo _refreshMethod;
private static Action _refreshDelegate;
#endregion
#region GradientPreviewCache 相关
private static Type _gradientCacheType;
private static MethodInfo _clearCacheMethod;
private static Action _clearCacheDelegate;
#endregion
// 初始化状态
private static bool _initialized;
private static bool _isValid;
private static readonly object _initLock = new object();
#region 公共API
[System.Diagnostics.Conditional("UNITY_EDITOR")]
public static void SetCurrentGradient(Gradient gradient)
{
ExecuteAction(() =>
{
if (_setGradientDelegate != null)
_setGradientDelegate(gradient);
else if (_setGradientMethod != null)
_setGradientMethod.Invoke(null, new object[] { gradient });
}, "SetCurrentGradient");
}
[System.Diagnostics.Conditional("UNITY_EDITOR")]
public static void RefreshGradientData()
{
ExecuteAction(() =>
{
if (_refreshDelegate != null)
_refreshDelegate();
else if (_refreshMethod != null)
_refreshMethod.Invoke(null, null);
}, "RefreshGradientData");
}
[System.Diagnostics.Conditional("UNITY_EDITOR")]
public static void ClearGradientCache()
{
ExecuteAction(() =>
{
if (_clearCacheDelegate != null)
_clearCacheDelegate();
else if (_clearCacheMethod != null)
_clearCacheMethod.Invoke(null, null);
}, "ClearGradientCache");
}
#endregion
#region 核心实现
private static void ExecuteAction(Action action, string methodName)
{
if (!Application.isEditor) return;
EnsureInitialized();
if (!_isValid) return;
try
{
action?.Invoke();
}
catch (Exception ex)
{
Debug.LogError($"[GradientReflection] {methodName} failed: {ex.Message}");
// 可选择性地禁用后续调用
// _isValid = false;
}
}
private static void EnsureInitialized()
{
if (_initialized) return;
lock (_initLock)
{
if (_initialized) return;
try
{
// 1. 初始化 GradientPicker 类型
_gradientPickerType = Type.GetType("UnityEditor.GradientPicker, UnityEditor");
if (_gradientPickerType != null)
{
// 初始化 SetCurrentGradient
_setGradientMethod = GetStaticMethod(
_gradientPickerType,
"SetCurrentGradient",
new[] { typeof(Gradient) }
);
if (_setGradientMethod != null)
{
_setGradientDelegate = CreateActionDelegate<Gradient>(_setGradientMethod);
}
// 初始化 RefreshGradientData
_refreshMethod = GetStaticMethod(
_gradientPickerType,
"RefreshGradientData",
Type.EmptyTypes
);
if (_refreshMethod != null)
{
_refreshDelegate = CreateActionDelegate(_refreshMethod);
}
}
else
{
Debug.LogWarning("[GradientReflection] GradientPicker type not found");
}
// 2. 初始化 GradientPreviewCache
_gradientCacheType = Type.GetType("UnityEditorInternal.GradientPreviewCache, UnityEditor");
if (_gradientCacheType != null)
{
_clearCacheMethod = GetStaticMethod(
_gradientCacheType,
"ClearCache",
Type.EmptyTypes
);
if (_clearCacheMethod != null)
{
_clearCacheDelegate = CreateActionDelegate(_clearCacheMethod);
}
}
else
{
Debug.LogWarning("[GradientReflection] GradientPreviewCache type not found");
}
// 3. 验证初始化状态
_isValid = (_setGradientMethod != null || _refreshMethod != null) &&
_clearCacheMethod != null;
if (!_isValid)
{
Debug.LogWarning($"[GradientReflection] Initialization incomplete. " +
$"SetCurrentGradient: {(_setGradientMethod != null ? "OK" : "Missing")}, " +
$"RefreshGradientData: {(_refreshMethod != null ? "OK" : "Missing")}, " +
$"ClearCache: {(_clearCacheMethod != null ? "OK" : "Missing")}");
}
else
{
// Debug.Log("[GradientReflection] Initialized successfully");
}
}
catch (Exception e)
{
Debug.LogError($"[GradientReflection] Initialization failed: {e}");
_isValid = false;
}
finally
{
_initialized = true;
}
}
}
private static MethodInfo GetStaticMethod(Type type, string methodName, Type[] parameterTypes)
{
if (type == null) return null;
return type.GetMethod(
methodName,
BindingFlags.Public | BindingFlags.Static,
null,
parameterTypes,
null
);
}
private static Action CreateActionDelegate(MethodInfo method)
{
try
{
return (Action)Delegate.CreateDelegate(typeof(Action), method);
}
catch (Exception ex)
{
Debug.LogWarning($"[GradientReflection] Failed to create delegate for {method.Name}: {ex.Message}");
return null;
}
}
private static Action<T> CreateActionDelegate<T>(MethodInfo method)
{
try
{
return (Action<T>)Delegate.CreateDelegate(typeof(Action<T>), method);
}
catch (Exception ex)
{
Debug.LogWarning($"[GradientReflection] Failed to create delegate for {method.Name}: {ex.Message}");
return null;
}
}
#endregion
#region 辅助功能
/// <summary>
/// 检查是否所有反射方法都可用
/// </summary>
public static bool IsFullySupported => _isValid;
/// <summary>
/// 获取反射初始化状态
/// </summary>
public static string GetReflectionStatus()
{
if (!_initialized) return "Not Initialized";
return $"GradientPicker: {(_gradientPickerType != null ? "Found" : "Missing")}\n" +
$"- SetCurrentGradient: {(_setGradientMethod != null ? "OK" : "Missing")}\n" +
$"- RefreshGradientData: {(_refreshMethod != null ? "OK" : "Missing")}\n" +
$"GradientPreviewCache: {(_gradientCacheType != null ? "Found" : "Missing")}\n" +
$"- ClearCache: {(_clearCacheMethod != null ? "OK" : "Missing")}";
}
#endregion
}

3
Packages/XuanXuanRenderUtility/Editor/GradientRefletctionHelper.cs.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: ebe6cf7ae30f4357bae940f8ce409628
timeCreated: 1753589587

236
Packages/XuanXuanRenderUtility/Editor/MaterialPropertyAgentInspector.cs
View File

@@ -1,236 +0,0 @@
using UnityEditor;
using UnityEngine;
using UnityEditor.Experimental.GraphView;
using System;
using System.Collections.Generic;
// #if UNITY_EDITOR
[CustomEditor(typeof(MaterialPropertyAgent))]
public class MaterialPropertyAgentInspector : UnityEditor.Editor
{
private MaterialPropertyAgent agent;
private void OnEnable()
{
agent = (MaterialPropertyAgent)target;
}
private GUIContent materialIndexContent = new GUIContent("材质序号:", "只有模型模式下需要使用，谨慎修改");
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUI.BeginChangeCheck();
if (!agent.isGetByComponet)
{
EditorGUILayout.PropertyField(serializedObject.FindProperty("customRenderer"),new GUIContent("指定Renderer"));
}
if (agent.isRendererMode)
{
EditorGUILayout.BeginHorizontal();
int lastIndex = agent.materialIndex;
agent.materialIndex = EditorGUILayout.IntField(materialIndexContent ,agent.materialIndex);
if (lastIndex != agent.materialIndex)
{
agent.initMatAndShaderByMaterialIndexChange();
}
EditorGUILayout.LabelField("材质名："+agent.mat.name+"\t"+"Shader名："+agent.shader.name);
EditorGUILayout.EndHorizontal();
}
DrawPropertyData(ref agent.data0, "Data0", serializedObject.FindProperty("data0"));
DrawPropertyData(ref agent.data1, "Data1", serializedObject.FindProperty("data1"));
DrawPropertyData(ref agent.data2, "Data2", serializedObject.FindProperty("data2"));
DrawPropertyData(ref agent.data3, "Data3", serializedObject.FindProperty("data3"));
DrawPropertyData(ref agent.data4, "Data4", serializedObject.FindProperty("data4"));
DrawPropertyData(ref agent.data5, "Data5", serializedObject.FindProperty("data5"));
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("添加"))
{
agent.addProperteData();
}
if (GUILayout.Button("全部删除"))
{
agent.removeAllProperty();
}
EditorGUILayout.EndHorizontal();
serializedObject.ApplyModifiedProperties();
if (EditorGUI.EndChangeCheck())
{
PrefabUtility.RecordPrefabInstancePropertyModifications(agent);
if (!agent.isGetByComponet && agent.mat)
{
if(matEditor) DestroyImmediate(matEditor);
matEditor = (MaterialEditor)CreateEditor(agent.mat);
}
}
if (!agent.isGetByComponet && agent.mat)
{
DrawMaterialInspector(matEditor,agent.mat);
}
}
void DrawPropertyData(ref MaterialPropertyAgent.PropertyData data, string dataLabel, SerializedProperty property)
{
EditorGUI.BeginProperty(EditorGUILayout.GetControlRect(false, 0f), GUIContent.none, property);
if (data.isActive)
{
EditorGUILayout.LabelField(dataLabel, EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUILayout.BeginHorizontal();
float originLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 80;
// data.index = EditorGUILayout.Popup("属性名:", data.index, agent.shaderPropNameArr);
// data.index = EditorGUILayout.Popup("属性名:", data.index, agent.shaderPropDescripArr);
// string dataDesript = data.descripName;
if (GUILayout.Button(data.descripName, EditorStyles.popup))
{
int dataIndexInAgent = data.dataIndexInAgent;
StringListSerchProvider provider = ScriptableObject.CreateInstance<StringListSerchProvider>();
provider.Initialize(agent.shaderPropDescripsForSerch, (x) =>
{
if (x != null)
{
AfterShaderPropSerch(dataIndexInAgent,x);
}
});
SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(Event.current.mousePosition)), provider);
// SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(Event.current.mousePosition)),
// new StringListSerchProvider(agent.shaderPropDescripsForSerch, (x) =>
// {
// if (x != null)
// {
// AfterShaderPropSerch(dataIndexInAgent,x);
// }
// }));
}
EditorGUILayout.LabelField("属性类型:", data.type.ToString());
EditorGUILayout.EndHorizontal();
EditorGUIUtility.labelWidth = originLabelWidth;
switch (data.type)
{
case MaterialPropertyAgent.shaderPropertyType.Color:
SerializedProperty colorProp = property.FindPropertyRelative("colorValue");
if (data.descripName.ToLower().Contains("hdr"))
{
colorProp.colorValue = EditorGUILayout.ColorField(new GUIContent(data.propName + " :") , colorProp.colorValue,true,true,true);
}
else
{
colorProp.colorValue = EditorGUILayout.ColorField(data.propName + " :", colorProp.colorValue);
}
break;
case MaterialPropertyAgent.shaderPropertyType.Vector:
case MaterialPropertyAgent.shaderPropertyType.TexEnv:
SerializedProperty vecProp = property.FindPropertyRelative("vecValue");
if (data.type == MaterialPropertyAgent.shaderPropertyType.Vector)
{
vecProp.vector4Value = EditorGUILayout.Vector4Field(data.propName + " :", vecProp.vector4Value);
}
else if (data.type == MaterialPropertyAgent.shaderPropertyType.TexEnv)
{
vecProp.vector4Value = EditorGUILayout.Vector4Field(data.propName + ":", vecProp.vector4Value);
}
break;
case MaterialPropertyAgent.shaderPropertyType.Float:
case MaterialPropertyAgent.shaderPropertyType.Range:
SerializedProperty floatProp = property.FindPropertyRelative("floatValue");
if (data.type == MaterialPropertyAgent.shaderPropertyType.Float)
{
floatProp.floatValue = EditorGUILayout.FloatField(data.propName + ":", floatProp.floatValue);
}
else if (data.type == MaterialPropertyAgent.shaderPropertyType.Range)
{
floatProp.floatValue = EditorGUILayout.Slider(data.propName + ":", floatProp.floatValue, data.rangMin, data.rangMax);
}
break;
}
if (GUILayout.Button("删除", new[] { GUILayout.Width(200) }))
{
data.isActive = false;
}
EditorGUI.indentLevel--;
// EditorGUILayout.Space();
}
EditorGUI.EndProperty();
}
//因为Action不能有Ref。所以有了这个丑陋的HardCode
public void AfterShaderPropSerch(int dataIndexInAgent, string propertyDesrpt)
{
switch (dataIndexInAgent)
{
case 0:
AfterShaderPropSerch(ref agent.data0,propertyDesrpt);
break;
case 1:
AfterShaderPropSerch(ref agent.data1,propertyDesrpt);
break;
case 2:
AfterShaderPropSerch(ref agent.data2,propertyDesrpt);
break;
case 3:
AfterShaderPropSerch(ref agent.data3,propertyDesrpt);
break;
case 4:
AfterShaderPropSerch(ref agent.data4,propertyDesrpt);
break;
case 5:
AfterShaderPropSerch(ref agent.data5,propertyDesrpt);
break;
}
}
public void AfterShaderPropSerch(ref MaterialPropertyAgent.PropertyData data, string propertyDesrpt)
{
int preservedIndex = data.index;
// string propname = data.propName;
data.index = Array.FindIndex(agent.shaderPropDescripArr, x=> x.Equals(propertyDesrpt) );
// Debug.Log();
if (preservedIndex != data.index)//证明用户进行了更改
{
if (!agent.isCanUsedIndex(data.index))
{
//TODO给一个报错提示
Debug.LogError("材质属性已经存在：" + ShaderUtil.GetPropertyDescription(agent.shader, data.index));
data.index = agent.getCanUsedIndex();
}
//此处进行内容刷新
data.setValueByPropChange();
}
}
private MaterialEditor matEditor;
void DrawMaterialInspector(MaterialEditor editor,Material mat)
{
if (editor != null && mat != null)
{
// Draw the material's foldout and the material shader field
// Required to call _materialEditor.OnInspectorGUI ();
editor.DrawHeader();
// We need to prevent the user to edit Unity default materials
bool isDefaultMaterial = !AssetDatabase.GetAssetPath (mat).StartsWith ("Assets");
using (new EditorGUI.DisabledGroupScope(isDefaultMaterial)) {
// Draw the material properties
// Works only if the foldout of _materialEditor.DrawHeader () is open
editor.OnInspectorGUI ();
}
}
}
}
// #endif

3
Packages/XuanXuanRenderUtility/Editor/MaterialPropertyAgentInspector.cs.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: b9544bec10c84ecca289bece4a630d65
timeCreated: 1702126025

1946
Packages/XuanXuanRenderUtility/Editor/ShaderGUIHelper.cs
View File

File diff suppressed because it is too large Load Diff

11
Packages/XuanXuanRenderUtility/Editor/ShaderGUIHelper.cs.meta
View File

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

399
Packages/XuanXuanRenderUtility/Editor/ShaderGUIResetTool.cs
View File

@@ -1,399 +0,0 @@
using System.Collections.Generic;
using System;
using PlasticGui;
using UnityEngine;
using UnityEngine.UIElements;
using ShaderPropertyPack = NBShaderEditor.ShaderGUIHelper.ShaderPropertyPack;
using UnityEditor;
namespace NBShaderEditor
{
public class ShaderGUIResetTool
{
private ShaderGUIHelper _helper;
private Shader _shader;
public bool IsInitResetData = false;
private Stack<(string,string)> _scopeContextStack = new Stack<(string,string)>();
public void CheckAllModifyOnValueChange()
{
foreach (var item in ResetItemDict.Values)
{
item.HasModified = item.CheckHasModifyOnValueChange();
}
}
public void Init(ShaderGUIHelper helper)
{
_helper = helper;
_shader = helper.shader;
IsInitResetData = true;
ResetItemDict.Clear();
_scopeContextStack.Clear();
}
public void EndInit()
{
IsInitResetData = false;
}
public void Update()
{
if (_needUpdate)
{
_needUpdate = false;
CheckAllModifyOnValueChange();
}
}
private bool _needUpdate = false;
public void NeedUpdate()
{
_needUpdate = true;
}
public ShaderGUIResetTool(ShaderGUIHelper helper)
{
Init(helper);
}
public Dictionary<(string, string), ResetItem> ResetItemDict = new Dictionary<(string, string), ResetItem>();
public class ResetItem
{
public ResetItem Parent;
public List<ResetItem> ChildResetItems = new List<ResetItem>();
public Action ResetCallBack;
public Action OnValueChangedCallBack;
public Func<bool> CheckHasModifyOnValueChange;
public Func<bool> CheckHasMixedValueOnValueChange;
public (string, string) NameTuple;
public bool HasModified = false;
public bool HasMixedValue =false;
public bool ChildHasModified = false;
public bool ChildHasMixedValue = false;
public void Init((string, string) nameTuple,Action resetCallBack,Action onValueChangedCallBack,Func<bool> checkHasModifyOnValueChange,Func<bool> checkHasMixedValueOnValueChange)
{
NameTuple = nameTuple;
ResetCallBack = resetCallBack;
OnValueChangedCallBack = onValueChangedCallBack;
CheckHasModifyOnValueChange = checkHasModifyOnValueChange;
CheckHasMixedValueOnValueChange = checkHasMixedValueOnValueChange;
}
public void Execute(bool isParentCall = false)
{
ResetCallBack?.Invoke();
OnValueChangedCallBack?.Invoke();
HasModified = CheckHasModifyOnValueChange();
HasMixedValue = CheckHasMixedValueOnValueChange();
CheckOnValueChange(isParentCall);
foreach (var item in ChildResetItems)
{
item.Execute(true);
}
}
public void CheckOnValueChange(bool isParentCall = false)
{
HasModified = CheckHasModifyOnValueChange();
HasMixedValue = CheckHasMixedValueOnValueChange();
foreach (var childItem in ChildResetItems)
{
HasMixedValue |= childItem.HasMixedValue;
HasModified |= childItem.HasModified;
}
if (!isParentCall && Parent != null)
{
Parent.CheckOnValueChange();
}
}
}
public void CheckOnValueChange((string,string) nameTuple)
{
if (ResetItemDict.ContainsKey(nameTuple))
{
ResetItemDict[nameTuple].CheckOnValueChange();
}
else
{
Debug.LogError("不包含ResetItemDict:"+nameTuple);
}
}
public void DrawResetModifyButton(Rect rect,(string, string) nameTuple, Action resetCallBack,
Action onValueChangedCallBack,Func<bool> checkHasModifyOnValueChange,Func<bool> checkHasMixedValueOnValueChange,bool isSharedGlobalParent = false)
{
ConstructResetItem(nameTuple,resetCallBack,onValueChangedCallBack,checkHasModifyOnValueChange,checkHasMixedValueOnValueChange,isSharedGlobalParent);
DrawResetModifyButtonFinal(rect,nameTuple);
}
public void DrawResetModifyButton(Rect rect,(string,string)nameTuple,ShaderPropertyPack pack, Action resetAction,Action onValueChangedCallBack,VectorValeType vectorValeType = VectorValeType.Undefine,bool isSharedGlobalParent = false)
{
// (string, string) nameTuple = (label, pack.property.name);
ConstructResetItem(nameTuple,
resetAction: ()=>{
SetPropertyToDefaultValue(pack,vectorValeType);
resetAction?.Invoke();
},onValueChangedCallBack:onValueChangedCallBack,
checkHasModifyOnValueChange: () => IsPropertyModified(pack,vectorValeType),
checkHasMixedValueOnValueChange: () => pack.property.hasMixedValue,
isSharedGlobalParent: isSharedGlobalParent
);
if (ResetItemDict.ContainsKey(nameTuple))
{
DrawResetModifyButtonFinal(rect,nameTuple);
}
}
public void DrawResetModifyButton(Rect rect, string label)
{
//大部分功能都是触发子类
ConstructResetItem((label, ""), resetAction: () => { },onValueChangedCallBack: () => { }, () => false, () => false);
DrawResetModifyButtonFinal(rect,(label,""));
}
//isSharedGlobalParent==>有些组件是公用的，比如极坐标一类。这些是不会设置父Item的。
public void ConstructResetItem((string,string) nameTuple, Action resetAction,
Action onValueChangedCallBack,Func<bool> checkHasModifyOnValueChange,Func<bool> checkHasMixedValueOnValueChange,bool isSharedGlobalParent = false)
{
if(!IsInitResetData) return;
if (!ResetItemDict.ContainsKey(nameTuple))
{
ResetItem item = new ResetItem();
item.Init(nameTuple,resetAction,onValueChangedCallBack,checkHasModifyOnValueChange,checkHasMixedValueOnValueChange);
ResetItemDict.Add(nameTuple,item);
if (_scopeContextStack.Count > 0 && !isSharedGlobalParent)
{
var contextNameTuple = _scopeContextStack.Peek();
ResetItem parentItem = ResetItemDict[contextNameTuple];
parentItem.ChildResetItems.Add(item);
item.Parent = parentItem;
}
item.CheckOnValueChange();//Init
}
else
{
// Debug.LogError("ResetItem已经存在:"+nameTuple.ToString());
}
//就算是已经ContainsKey了，也Push和Pop一下。没有作用，但让写法更简单。
_scopeContextStack.Push(nameTuple);
}
public void EndResetModifyButtonScope()
{
if(!IsInitResetData) return;
if(_scopeContextStack.Count == 0) return;
_scopeContextStack.Pop();
}
public float ResetButtonSize => EditorGUIUtility.singleLineHeight;
private GUIContent resetIconContent = new GUIContent();
//仅仅只是Drawer
private void DrawResetModifyButtonFinal(Rect position, (string, string) nameTuple)
{
ResetItem item;
// GUILayout.FlexibleSpace();
if (ResetItemDict.ContainsKey(nameTuple))
{
item = ResetItemDict[nameTuple];
}
else
{
return;
}
float btnSize = ResetButtonSize;
string iconText;
bool isDisabled = true;
GUIStyle iconStyle;
if (item.HasModified || item.HasMixedValue)
{
isDisabled = false;
iconText = "R";
iconStyle = GUI.skin.button;
}
else
{
isDisabled = true;
iconText = "";
iconStyle = GUI.skin.label;
}
resetIconContent.text = iconText;
EditorGUI.BeginDisabledGroup(isDisabled);
// if (GUILayout.Button(iconTexture, GUILayout.Width(btnSize), GUILayout.Height(btnSize)))
if (position.width <= 0)
{
position = GUILayoutUtility.GetRect(resetIconContent, GUI.skin.button, GUILayout.Width(btnSize),
GUILayout.Height(btnSize));
}
if(GUI.Button(position,resetIconContent,iconStyle))
{
item.Execute();
}
EditorGUI.EndDisabledGroup();
}
public void SetPropertyToDefaultValue(ShaderPropertyPack pack,VectorValeType vectorValeType = VectorValeType.Undefine)
{
MaterialProperty property = pack.property;
UnityEngine.Rendering.ShaderPropertyType propertyType = property.propertyType;
if (pack.property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Texture && vectorValeType != VectorValeType.Undefine)
{
propertyType = UnityEngine.Rendering.ShaderPropertyType.Vector;//Tilling or Offset
}
switch (propertyType)
{
case UnityEngine.Rendering.ShaderPropertyType.Color:
Vector4 colorValue = _shader.GetPropertyDefaultVectorValue(pack.index);
property.colorValue = new Color(colorValue.x, colorValue.y, colorValue.z, colorValue.x);
break;
case UnityEngine.Rendering.ShaderPropertyType.Vector:
Vector4 defaultVecValue;
Vector4 vecValue;
if (vectorValeType == VectorValeType.Tilling || vectorValeType == VectorValeType.Offset)
{
defaultVecValue = new Vector4(1f, 1f, 0f, 0f);
vecValue = property.textureScaleAndOffset;
}
else
{
defaultVecValue = _shader.GetPropertyDefaultVectorValue(pack.index);
vecValue = property.vectorValue;
}
switch (vectorValeType)
{
case VectorValeType.Undefine: Debug.LogError("VectorValeType is undefined"); break;
case VectorValeType.X: vecValue.x = defaultVecValue.x;property.vectorValue = vecValue;break;
case VectorValeType.Y: vecValue.y = defaultVecValue.y;property.vectorValue = vecValue;break;
case VectorValeType.Z: vecValue.z = defaultVecValue.z;property.vectorValue = vecValue;break;
case VectorValeType.W: vecValue.w = defaultVecValue.w;property.vectorValue = vecValue;break;
case VectorValeType.XY:vecValue.x = defaultVecValue.x; vecValue.y = defaultVecValue.y;
property.vectorValue = vecValue;break;
case VectorValeType.Tilling:vecValue.x = defaultVecValue.x; vecValue.y = defaultVecValue.y;
property.textureScaleAndOffset = vecValue;break;
case VectorValeType.ZW:vecValue.z = defaultVecValue.z; vecValue.w = defaultVecValue.w;
property.vectorValue = vecValue;break;
case VectorValeType.Offset:vecValue.z = defaultVecValue.z; vecValue.w = defaultVecValue.w;
property.textureScaleAndOffset = vecValue;break;
case VectorValeType.XYZ:vecValue.x = defaultVecValue.x; vecValue.y = defaultVecValue.y;
vecValue.z = defaultVecValue.z; property.vectorValue = vecValue;break;
case VectorValeType.XYZW: property.vectorValue = defaultVecValue;break;
}
break;
case UnityEngine.Rendering.ShaderPropertyType.Float or UnityEngine.Rendering.ShaderPropertyType.Range:
float value = _shader.GetPropertyDefaultFloatValue(pack.index);
property.floatValue = value;
break;
case UnityEngine.Rendering.ShaderPropertyType.Texture:
if (property.textureValue == null)
{
break;
}
else
{
property.textureValue = null;
break;
}
// return property.textureValue.name == shader.GetPropertyTextureDefaultName(pack.index) ? false : true;
default:
// 如果不属于上述类型，输出提示信息
Debug.Log($"{property.displayName} has no default value or unsupported type");
break;
}
}
public bool IsPropertyModified(ShaderPropertyPack pack,VectorValeType vectorValeType = VectorValeType.Undefine)
{
MaterialProperty property = pack.property;
UnityEngine.Rendering.ShaderPropertyType propertyType = property.propertyType;
if (pack.property.propertyType == UnityEngine.Rendering.ShaderPropertyType.Texture && vectorValeType != VectorValeType.Undefine)
{
propertyType = UnityEngine.Rendering.ShaderPropertyType.Vector;//Tilling or Offset
}
switch (propertyType)
{
case UnityEngine.Rendering.ShaderPropertyType.Color:
Vector4 colorValue = _shader.GetPropertyDefaultVectorValue(pack.index);
Color color = new Color(colorValue.x, colorValue.y, colorValue.z, colorValue.w);
return property.colorValue == color ? false : true;
case UnityEngine.Rendering.ShaderPropertyType.Vector:
Vector4 defaultVecValue;
Vector4 vecValue;
if (vectorValeType == VectorValeType.Tilling || vectorValeType == VectorValeType.Offset)
{
defaultVecValue = new Vector4(1f, 1f, 0f, 0f);
vecValue = property.textureScaleAndOffset;
}
else
{
defaultVecValue = _shader.GetPropertyDefaultVectorValue(pack.index);
vecValue = property.vectorValue;
}
Vector2 defaultVecXYValue = new Vector2(defaultVecValue.x, defaultVecValue.y);
Vector2 defaultVecZWValue = new Vector2(defaultVecValue.z, defaultVecValue.w);
Vector2 vecXYValue = new Vector2(vecValue.x, vecValue.y);
Vector2 vecZWValue = new Vector2(vecValue.z, vecValue.w);
Vector2 defaultVecXYZValue = new Vector3(defaultVecValue.x, defaultVecValue.y,defaultVecValue.z);
Vector2 vecXYZValue = new Vector3(vecValue.x, vecValue.y,vecValue.z);
bool isVecModified = false;
switch (vectorValeType)
{
case VectorValeType.Undefine: Debug.LogError("VectorValeType is undefined"); break;
case VectorValeType.X: isVecModified = Mathf.Approximately(vecValue.x,defaultVecValue.x) ? false : true;break;
case VectorValeType.Y: isVecModified = Mathf.Approximately(vecValue.y,defaultVecValue.y) ? false : true;break;
case VectorValeType.Z: isVecModified = Mathf.Approximately(vecValue.z,defaultVecValue.z) ? false : true;break;
case VectorValeType.W: isVecModified = Mathf.Approximately(vecValue.w,defaultVecValue.w) ? false : true;break;
case VectorValeType.XY:case VectorValeType.Tilling:
isVecModified = vecXYValue == defaultVecXYValue ? false : true;break;
case VectorValeType.ZW:case VectorValeType.Offset:
isVecModified = vecZWValue == defaultVecZWValue ? false : true;break;
case VectorValeType.XYZ:isVecModified = vecXYZValue == defaultVecXYZValue ? false : true ; break;
case VectorValeType.XYZW:isVecModified= vecValue == defaultVecValue? false : true ; break;
}
return isVecModified;
case UnityEngine.Rendering.ShaderPropertyType.Float or UnityEngine.Rendering.ShaderPropertyType.Range:
return Mathf.Approximately(property.floatValue, _shader.GetPropertyDefaultFloatValue(pack.index)) ? false : true;
case UnityEngine.Rendering.ShaderPropertyType.Texture:
if (property.textureValue == null)
{
return false;
}
else
{
return property.textureValue.name == "textureExternal" ? false : true;
}
// return property.textureValue.name == shader.GetPropertyTextureDefaultName(pack.index) ? false : true;
default:
// 如果不属于上述类型，输出提示信息
return false;
// Debug.Log($"{property.displayName} has no default value or unsupported type");
// break;
}
}
}
}

3
Packages/XuanXuanRenderUtility/Editor/ShaderGUIResetTool.cs.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: 73135babda09451c9e5798b36897637b
timeCreated: 1754727843

248
Packages/XuanXuanRenderUtility/Editor/ShaderGUIToolBar.cs
View File

@@ -1,248 +0,0 @@
using UnityEngine;
using UnityEditor;
using System.Collections.Generic;
namespace NBShaderEditor
{
public class ShaderGUIToolBar
{
public ShaderGUIHelper Helper;
private int viewModeIndex;
private readonly string[] viewModes = { "List", "Grid" };
// private string searchText = "";
private MaterialEditor _editor=>Helper.matEditor;
public ShaderGUIToolBar(ShaderGUIHelper helper)
{
Helper = helper;
}
private static Material copiedMaterial;
private static Shader copiedShader;
// 帮助链接URL
private const string HELP_URL = "https://owejt9diz2c.feishu.cn/wiki/BHz8wHHSjiYJagk7WrmcAcconlb?from=from_copylink";
private Vector2 imagePos;
private Texture2D icon;
private Texture2D image;
public void DrawToolbar()
{
float BtnWidth = 30f;
// 开始工具栏区域 (背景)
EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
// 1. 选择当前材质
if (GUILayout.Button(EditorGUIUtility.IconContent("Material On Icon","跳到当前材质|跳到当前材质"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
EditorGUIUtility.PingObject(Helper.mats[0]);
}
if (GUILayout.Button(EditorGUIUtility.IconContent("TreeEditor.Trash","清除没有使用的贴图|清除没有使用的贴图"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
foreach (var mat in Helper.mats)
{
CleanUnusedTextureProperties(Helper.mats[0]);//先清理不属于当前Shader的贴图
}
Helper.isClearUnUsedTexture = true;
}
if (GUILayout.Button(new GUIContent("C","复制材质属性"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
copiedMaterial = Helper.mats[0];
copiedShader = copiedMaterial.shader;
}
if (GUILayout.Button(new GUIContent("V","粘贴材质属性"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
if (copiedShader)
{
Helper.mats[0].shader = copiedShader;
}
if (copiedMaterial)
{
Helper.mats[0].CopyPropertiesFromMaterial(copiedMaterial);
}
}
if (GUILayout.Button(new GUIContent("R","特殊重置功能"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
ShowResetPopupMenu();
}
if (GUILayout.Button(EditorGUIUtility.IconContent("d_UnityEditor.HierarchyWindow","折叠所有控件|折叠所有控件"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
for (int i = 0;i<Helper.shaderFlags.Length;i++)
{
W9ParticleShaderFlags shaderFlags = (W9ParticleShaderFlags)Helper.shaderFlags[i];
for (int j = 3; j <= 5; j++)
{
Helper.mats[i].SetInteger(shaderFlags.GetShaderFlagsId(j),0);
}
}
}
// 2. 添加下拉菜单
// viewModeIndex = EditorGUILayout.Popup(viewModeIndex, viewModes, EditorStyles.toolbarPopup, GUILayout.Width(BtnWidth));
// 3. 添加搜索框
GUILayout.FlexibleSpace(); // 将搜索框推到中间
// // 搜索框样式
// GUIStyle searchField = new GUIStyle("SearchTextField");
// GUIStyle cancelButton = new GUIStyle("SearchCancelButton");
//
// EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(300));
// {
// EditorGUI.BeginChangeCheck();
// searchText = EditorGUILayout.TextField(searchText, searchField);
// if (EditorGUI.EndChangeCheck())
// {
// Helper.isSearchText = searchText.Length > 0;
// Helper.searchText = searchText;
// }
//
// // 清除搜索按钮
// if (GUILayout.Button("", cancelButton))
// {
// searchText = "";
// GUI.FocusControl(null); // 移除焦点
// }
// }
// EditorGUILayout.EndHorizontal();
// // 4. 右侧按钮组
// if (GUILayout.Button(EditorGUIUtility.IconContent("TreeEditor.Refresh"), EditorStyles.toolbarButton))
// {
// Debug.Log("Refresh clicked");
// }
//
// // 选项菜单
// if (GUILayout.Button(EditorGUIUtility.IconContent("_Popup"), EditorStyles.toolbarButton))
// {
// // 创建下拉菜单
// GenericMenu menu = new GenericMenu();
// menu.AddItem(new GUIContent("Option 1"), false, () => Debug.Log("Option 1"));
// menu.AddItem(new GUIContent("Option 2"), false, () => Debug.Log("Option 2"));
// menu.ShowAsContext();
// }
// 贴图加载
if (icon == null)
icon = AssetDatabase.LoadAssetAtPath<Texture2D>(AssetDatabase.GUIDToAssetPath("eaa39f504c2ce7646aece103ba9c4766"));
if (image == null)
image = AssetDatabase.LoadAssetAtPath<Texture2D>(AssetDatabase.GUIDToAssetPath("cc6c30349a33a1d4c8242a9ef1a68830"));
if (GUILayout.Button(new GUIContent(icon,"爸爸！"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
// 弹出 PopupWindow
// 弹出浮动窗口
FloatingImageWindow.ShowWindow(image);
}
if (GUILayout.Button(EditorGUIUtility.IconContent("d__Help@2x","说明文档|说明文档"), EditorStyles.toolbarButton,GUILayout.Width(BtnWidth)))
{
// 打开浏览器跳转到帮助链接
Application.OpenURL(HELP_URL);
}
EditorGUILayout.EndHorizontal(); // 结束工具栏
}
private void ShowResetPopupMenu()
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("重置特殊UV通道"), false, () =>
{
Helper.ResetTool.ResetItemDict[("特殊UV通道选择","_SpecialUVChannelMode")].Execute();
});
menu.AddItem(new GUIContent("重置旋转扭曲"), false, () =>
{
Helper.ResetTool.ResetItemDict[("","_UTwirlEnabled")].Execute();
});
menu.AddItem(new GUIContent("重置极坐标"), false, () =>
{
Helper.ResetTool.ResetItemDict[("","_PolarCoordinatesEnabled")].Execute();
});
// 弹出位置可以用 Event.current.mousePosition
menu.DropDown(new Rect(Event.current.mousePosition, Vector2.zero));
}
private void CleanUnusedTextureProperties(Material mat)
{
if (mat == null || mat.shader == null) return;
Shader shader = mat.shader;
// 收集 Shader 里声明过的贴图属性
var shaderTexProps = new HashSet<string>();
int count = ShaderUtil.GetPropertyCount(shader);
for (int i = 0; i < count; i++)
{
if (ShaderUtil.GetPropertyType(shader, i) == ShaderUtil.ShaderPropertyType.TexEnv)
{
shaderTexProps.Add(ShaderUtil.GetPropertyName(shader, i));
}
}
// 遍历材质所有贴图属性，找到 shader 不再声明的
var allProps = mat.GetTexturePropertyNames();
foreach (var propName in allProps)
{
if (!shaderTexProps.Contains(propName))
{
if (mat.GetTexture(propName) != null)
{
mat.SetTexture(propName, null);
Debug.Log($"清理 {mat.name} 的无效贴图属性: {propName}");
}
}
}
}
// EditorWindow 显示图片
public class FloatingImageWindow : EditorWindow
{
private Texture2D popupImage;
public static void ShowWindow(Texture2D image)
{
// 创建窗口
FloatingImageWindow window = CreateInstance<FloatingImageWindow>();
window.titleContent = new GUIContent("谢谢爸爸");
window.popupImage = image;
// 设置初始尺寸
if (image != null)
window.position = new Rect(Screen.width / 2f - image.width / 2f,
Screen.height / 2f - image.height / 2f,
image.width,
image.height);
else
window.position = new Rect(Screen.width / 2f - 100, Screen.height / 2f - 100, 200, 200);
window.ShowUtility(); // 浮动窗口
}
private void OnGUI()
{
if (popupImage != null)
{
// 绘制图片
Rect rect = new Rect(0, 0, position.width, position.height);
GUI.DrawTexture(rect, popupImage, ScaleMode.ScaleToFit);
}
// 可选：增加关闭按钮
if (GUI.Button(new Rect(position.width - 25, 5, 20, 20), "X"))
{
Close();
}
}
}
}
}

3
Packages/XuanXuanRenderUtility/Editor/ShaderGUIToolBar.cs.meta
View File

@@ -1,3 +0,0 @@
fileFormatVersion: 2
guid: deccdbc6963a48b2ace3358cbba67689
timeCreated: 1754406958

158
Packages/XuanXuanRenderUtility/Editor/StencilTestHelper.cs
View File

@@ -1,158 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
// using Sirenix.OdinInspector;
// using Sirenix.OdinInspector.Editor;
using UnityEditor;
namespace stencilTestHelper
{
[Serializable]
public class StencilValues
{
public int DefaultQueue = 2000;
[BinaryInt(8,true,2)]
public int Ref = 0;
public CompareFunction Comp = CompareFunction.Always;
public StencilOp Pass = StencilOp.Keep;
public StencilOp Fail = StencilOp.Keep;
public StencilOp ZFail = StencilOp.Keep;
[BinaryInt(8,true,1)]
public int ReadMask = 255;
[BinaryInt(8,true,1)]
public int WriteMask = 255;
}
public static class StencilTestHelper
{
// private static StencilValuesConfig stencilValuesConfig;
public class StencilPropertyNames
{
public string stencil = "_Stencil";
public string stencilComp = "_StencilComp";
public string stencilOp = "_StencilOp";
public string stencilWriteMask = "_StencilWriteMask";
public string stencilReadMask = "_StencilReadMask";
public string stencilZFail = "_StencilZFail";
public string stencilFail = "_StencilFail";
public string stencilKexIndex = "_StencilKeyIndex";
public StencilPropertyNames()
{
}
public StencilPropertyNames(string stencilName, string stencilCompName, string stencilOpName,
string stencilWriteMaskName, string stencilReadMaskName, string stencilZFailName,
string stencilFailName,string stencilKexIndexName)
{
if (!string.IsNullOrEmpty(stencilName))
{
stencil = stencilName;
}
if (!string.IsNullOrEmpty(stencilCompName))
{
stencilComp = stencilCompName;
}
if (!string.IsNullOrEmpty(stencilOpName))
{
stencilOp = stencilOpName;
}
if (!string.IsNullOrEmpty(stencilWriteMaskName))
{
stencilWriteMask = stencilWriteMaskName;
}
if (!string.IsNullOrEmpty(stencilReadMaskName))
{
stencilReadMask = stencilReadMaskName;
}
if (!string.IsNullOrEmpty(stencilZFailName))
{
stencilZFail = stencilZFailName;
}
if (!string.IsNullOrEmpty(stencilFailName))
{
stencilFail = stencilFailName;
}
if (!string.IsNullOrEmpty(stencilKexIndexName))
{
stencilKexIndex = stencilKexIndexName;
}
}
}
private static StencilPropertyNames defaultStencilPropertyNames = new StencilPropertyNames();
// public static void SetMaterialStencil(Material mat,StencilValues stencilValues,out int defaultQueue)
public static void SetMaterialStencil(Material mat, string stencilConfigKey,StencilValuesConfig stencilValuesConfig, out int defaultQueue,StencilPropertyNames stencilPropertyNames = null)
{
if (stencilValuesConfig == null)
{
Debug.LogError(mat.name+": 缺少模板预设,设置Stencil失败");
// stencilValuesConfig =
// AssetDatabase.LoadAssetAtPath<StencilValuesConfig>(
// "Assets/AddressableAssets/Shader/StencilConfig.asset");
}
if (stencilPropertyNames == null)
{
stencilPropertyNames = defaultStencilPropertyNames;
}
StencilValues stencilValues;
if (stencilValuesConfig.ContainsKey(stencilConfigKey))
{
stencilValues = stencilValuesConfig[stencilConfigKey];
if (!string.IsNullOrEmpty(stencilPropertyNames.stencil))
{
mat.SetFloat(stencilPropertyNames.stencil, stencilValues.Ref);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilComp) )
{
mat.SetFloat(stencilPropertyNames.stencilComp, (float)stencilValues.Comp);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilOp))
{
mat.SetFloat(stencilPropertyNames.stencilOp, (float)stencilValues.Pass);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilWriteMask))
{
mat.SetFloat(stencilPropertyNames.stencilWriteMask, stencilValues.WriteMask);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilReadMask))
{
mat.SetFloat(stencilPropertyNames.stencilReadMask, stencilValues.ReadMask);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilZFail))
{
mat.SetFloat(stencilPropertyNames.stencilZFail, (float)stencilValues.ZFail);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilFail))
{
mat.SetFloat(stencilPropertyNames.stencilFail, (float)stencilValues.Fail);
}
if (!string.IsNullOrEmpty(stencilPropertyNames.stencilKexIndex))
{
mat.SetFloat(stencilPropertyNames.stencilKexIndex,stencilValuesConfig.GetKeyIndex(stencilConfigKey));
}
defaultQueue = stencilValues.DefaultQueue;
}
else
{
Debug.LogError("无法设置材质模板参数，因为没有配置模板值", mat);
defaultQueue = mat.renderQueue;
}
}
}
}

11
Packages/XuanXuanRenderUtility/Editor/StencilTestHelper.cs.meta
View File

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

78
Packages/XuanXuanRenderUtility/Editor/StencilValuesConfig.cs
View File

@@ -1,78 +0,0 @@
using System;
using System.Collections.Generic;
using UnityEngine;
namespace stencilTestHelper
{
public class StencilValuesConfig : ScriptableObject
{
// public Dictionary<string, StencilValues> Config = new Dictionary<string, StencilValues>();
// public StencilValuesConfigDictionary Config = new StencilValuesConfigDictionary();
[Serializable]
public class KeyStencilValues
{
public string key;
public StencilValues Values;
}
[SerializeField]
public List<KeyStencilValues> Config = new List<KeyStencilValues>();
public bool ContainsKey(string key)
{
if (GetStencilValues(key) != null)
{
return true;
}
else
{
return false;
}
}
public StencilValues GetStencilValues(string key)
{
foreach (var item in Config)
{
if (item.key == key)
{
return item.Values;
}
}
Debug.LogError("StencilValuesConfig: 不存在Key"+key);
return null;
}
public int GetKeyIndex(string key)
{
for (int i = 0; i < Config.Count; i++)
{
if (Config[i].key == key)
{
return i;
}
}
Debug.LogError("StencilValuesConfig: 不存在Key"+key);
return -1;
}
public string GetKeyByIndex(int index)
{
return Config[index].key;
}
public StencilValues this[string key]
{
get
{
return GetStencilValues(key);
}
}
}
}

11
Packages/XuanXuanRenderUtility/Editor/StencilValuesConfig.cs.meta
View File

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

101
Packages/XuanXuanRenderUtility/Editor/StringListSerchProvider.cs
View File

@@ -1,101 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEditor.Experimental.GraphView;
using UnityEngine;
using UnityEditor;
public class StringListSerchProvider : ScriptableObject , ISearchWindowProvider
// public class StringListSerchProvider
{
public List<SearchTreeEntry> CreateSearchTree(SearchWindowContext context)
{
List<SearchTreeEntry> serchList = new List<SearchTreeEntry>();
serchList.Add(new SearchTreeGroupEntry(new GUIContent("List"),0));
List<string> listItemAfterSort = listItems.ToList();
sortListItems(ref listItemAfterSort);
List<string> groups = new List<string>();
foreach (var item in listItemAfterSort)
{
string[] entryTitle = item.Split("/");
string groupName = "";
for (int i = 0; i < entryTitle.Length - 1; i++)
{
groupName += entryTitle[i];
if (!groups.Contains(groupName))
{
serchList.Add(new SearchTreeGroupEntry(new GUIContent(entryTitle[i]),i+1));
}
groupName += "/";
}
SearchTreeEntry entry = new SearchTreeEntry(new GUIContent(entryTitle.Last()));
entry.level = entryTitle.Length;
entry.userData = item;//这里是serch操作点击最后的返回值，是什么都可以的。
// Debug.Log(entry.userData);
serchList.Add(entry);
}
return serchList;
}
public bool OnSelectEntry(SearchTreeEntry searchTreeEntry, SearchWindowContext context)
{
string data = (string)searchTreeEntry.userData;
onSetIndexCallback?.Invoke(data);
return true;
}
private string[] listItems;
private Action<string> onSetIndexCallback;
public StringListSerchProvider(string[] items, Action<string> callBack)
{
listItems = items;
onSetIndexCallback = callBack;
}
public void Initialize(string[] items, Action<string> callBack)
{
listItems = items;
onSetIndexCallback = callBack;
}
// private List<string> sortListItems;
void sortListItems(ref List<string> list)
{
// sortListItems = listItems.ToList();
list.Sort((a, b) =>
{
string[] splits1 = a.Split('/');
string[] splits2 = b.Split('/');
for (int i = 0; i < splits1.Length; i++)
{
if (i >= splits2.Length)
{
return 1;
}
int value = splits1[i].CompareTo(splits2[i]);
if (value != 0)
{
if (splits1.Length != splits2.Length && (i == splits1.Length - 1 || i == splits2.Length - 1))
{
return splits1.Length < splits2.Length ? 1 : -1;
}
return value;
}
}
return 0;
});
}
}

11
Packages/XuanXuanRenderUtility/Editor/StringListSerchProvider.cs.meta
View File

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

8
Packages/XuanXuanRenderUtility/Editor/Textures.meta
View File

@@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 37a388ed2acdda44cba962b4f9196106
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

BIN
Packages/XuanXuanRenderUtility/Editor/Textures/GiveMeMoney.jpg LFS
View File

Binary file not shown.

127
Packages/XuanXuanRenderUtility/Editor/Textures/GiveMeMoney.jpg.meta
View File

@@ -1,127 +0,0 @@
fileFormatVersion: 2
guid: cc6c30349a33a1d4c8242a9ef1a68830
TextureImporter:
internalIDToNameTable: []
externalObjects: {}
serializedVersion: 13
mipmaps:
mipMapMode: 0
enableMipMap: 1
sRGBTexture: 1
linearTexture: 0
fadeOut: 0
borderMipMap: 0
mipMapsPreserveCoverage: 0
alphaTestReferenceValue: 0.5
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: 0.25
normalMapFilter: 0
flipGreenChannel: 0
isReadable: 0
streamingMipmaps: 0
streamingMipmapsPriority: 0
vTOnly: 0
ignoreMipmapLimit: 0
grayScaleToAlpha: 0
generateCubemap: 6
cubemapConvolution: 0
seamlessCubemap: 0
textureFormat: 1
maxTextureSize: 2048
textureSettings:
serializedVersion: 2
filterMode: 1
aniso: 1
mipBias: 0
wrapU: 0
wrapV: 0
wrapW: 0
nPOTScale: 0
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: 0.5, y: 0.5}
spritePixelsToUnits: 100
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spriteGenerateFallbackPhysicsShape: 1
alphaUsage: 1
alphaIsTransparency: 0
spriteTessellationDetail: -1
textureType: 0
textureShape: 1
singleChannelComponent: 0
flipbookRows: 1
flipbookColumns: 1
maxTextureSizeSet: 0
compressionQualitySet: 0
textureFormatSet: 0
ignorePngGamma: 0
applyGammaDecoding: 0
swizzle: 50462976
cookieLightType: 0
platformSettings:
- serializedVersion: 3
buildTarget: DefaultTexturePlatform
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 2
compressionQuality: 20
crunchedCompression: 1
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 3
buildTarget: Standalone
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 3
buildTarget: Android
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
outline: []
physicsShape: []
bones: []
spriteID:
internalID: 0
vertices: []
indices:
edges: []
weights: []
secondaryTextures: []
nameFileIdTable: {}
mipmapLimitGroupName:
pSDRemoveMatte: 0
userData:
assetBundleName:
assetBundleVariant:

BIN
Packages/XuanXuanRenderUtility/Editor/Textures/alipayLogo.png LFS
View File

Binary file not shown.

127
Packages/XuanXuanRenderUtility/Editor/Textures/alipayLogo.png.meta
View File

@@ -1,127 +0,0 @@
fileFormatVersion: 2
guid: eaa39f504c2ce7646aece103ba9c4766
TextureImporter:
internalIDToNameTable: []
externalObjects: {}
serializedVersion: 13
mipmaps:
mipMapMode: 0
enableMipMap: 1
sRGBTexture: 1
linearTexture: 0
fadeOut: 0
borderMipMap: 0
mipMapsPreserveCoverage: 0
alphaTestReferenceValue: 0.5
mipMapFadeDistanceStart: 1
mipMapFadeDistanceEnd: 3
bumpmap:
convertToNormalMap: 0
externalNormalMap: 0
heightScale: 0.25
normalMapFilter: 0
flipGreenChannel: 0
isReadable: 0
streamingMipmaps: 0
streamingMipmapsPriority: 0
vTOnly: 0
ignoreMipmapLimit: 0
grayScaleToAlpha: 0
generateCubemap: 6
cubemapConvolution: 0
seamlessCubemap: 0
textureFormat: 1
maxTextureSize: 2048
textureSettings:
serializedVersion: 2
filterMode: 1
aniso: 1
mipBias: 0
wrapU: 0
wrapV: 0
wrapW: 0
nPOTScale: 1
lightmap: 0
compressionQuality: 50
spriteMode: 0
spriteExtrude: 1
spriteMeshType: 1
alignment: 0
spritePivot: {x: 0.5, y: 0.5}
spritePixelsToUnits: 100
spriteBorder: {x: 0, y: 0, z: 0, w: 0}
spriteGenerateFallbackPhysicsShape: 1
alphaUsage: 1
alphaIsTransparency: 1
spriteTessellationDetail: -1
textureType: 0
textureShape: 1
singleChannelComponent: 0
flipbookRows: 1
flipbookColumns: 1
maxTextureSizeSet: 0
compressionQualitySet: 0
textureFormatSet: 0
ignorePngGamma: 0
applyGammaDecoding: 0
swizzle: 50462976
cookieLightType: 0
platformSettings:
- serializedVersion: 3
buildTarget: DefaultTexturePlatform
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 3
buildTarget: Standalone
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 3
buildTarget: Android
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
ignorePlatformSupport: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
outline: []
physicsShape: []
bones: []
spriteID:
internalID: 0
vertices: []
indices:
edges: []
weights: []
secondaryTextures: []
nameFileIdTable: {}
mipmapLimitGroupName:
pSDRemoveMatte: 0
userData:
assetBundleName:
assetBundleVariant:

Some files were not shown because too many files have changed in this diff Show More