public DeferredShadingUtils()
{
AssetBundle AB = AssetBundle.LoadFromFile(Application.dataPath + "/../plugins/PHIBL/deferredskin");
if (AB == null)
{
Console.WriteLine("DeferredShadingUtil: \"deferredskin\" file missing!");
}
DiffuseScatteringOnRing = AB.LoadAsset <Texture2D>("DiffuseScatteringOnRing");
DefaultSpotCookie = AB.LoadAsset <Texture2D>("DefaultSpotCookie");
AlloyBlurNormal = AB.LoadAsset <Shader>("Assets/Alloy/Scripts/DeferredRendererPlus/Shaders/BlurNormals.shader");
AlloyTransmissionBlit = AB.LoadAsset <Shader>("Assets/Alloy/Scripts/DeferredRendererPlus/Shaders/TransmissionBlit.shader");
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredReflections, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.DeferredShading, AB.LoadAsset <Shader>("Assets/Alloy/Shaders/Alloy Deferred Skin.shader"));
GraphicsSettings.SetCustomShader(BuiltinShaderType.DeferredReflections, AB.LoadAsset <Shader>("Assets/Alloy/Shaders/Alloy Deferred Reflections.shader"));
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, AB.LoadAsset <Shader>("Assets/Psychose Interactive/NGSS/Internal-ScreenSpaceShadows.shader"));
AlloyDeferredSkinShader = AB.LoadAsset <Material>("skin").shader;
AlloyAlpha = AB.LoadAsset <Material>("nip").shader;
if (AlloyDeferredSkinShader == null)
{
Console.WriteLine("DeferredShadingUtil: Can't find deferred skin shader!");
}
AB.Unload(false);
skinMaterials = new List <Material>();
}
private void OnApplicationQuit()
{
if (this.isGraphicSet)
{
this.isGraphicSet = false;
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/Internal-ScreenSpaceShadows"));
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseBuiltin);
}
this.RemoveCommandBuffers();
}
void SetCustomShader()
{
if (depthNormalShader != null)
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.DepthNormals, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.DepthNormals, depthNormalShader);
}
else
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.DepthNormals, BuiltinShaderMode.UseBuiltin);
}
}
private void Init()
{
if (this.isInitialized)
{
return;
}
if (!this.isGraphicSet)
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/NGSS_Directional"));
this.isGraphicSet = true;
}
this.isInitialized = true;
}
private void OnDisable()
{
this.isInitialized = false;
if (this.KEEP_NGSS_ONDISABLE)
{
return;
}
if (this.isGraphicSet)
{
this.isGraphicSet = false;
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/Internal-ScreenSpaceShadows"));
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseBuiltin);
}
}
public void Setup()
{
_light = GetComponent <Light>();
if (!_light)
{
return;
}
resolution = Mathf.ClosestPowerOfTwo(resolution);
if (customShadowResolution)
{
_light.shadowCustomResolution = resolution;
}
else
{
_light.shadowCustomResolution = 0;
}
shader = Shader.Find(shaderName);
// if (!Application.isEditor)
// {
// if (shader)
// Debug.LogErrorFormat("Custom Shadow Shader Found: {0} | Supported {1}", shader.name, shader.isSupported);
// else
// Debug.LogError("Custom Shadow Shader Not Found!!!");
// }
shadowmapPropID = Shader.PropertyToID("_ShadowMap");
copyShadowBuffer = new CommandBuffer();
copyShadowBuffer.name = "PCSS Shadows";
var buffers = _light.GetCommandBuffers(lightEvent);
for (int i = 0; i < buffers.Length; i++)
{
if (buffers[i].name == "PCSS Shadows")
{
_light.RemoveCommandBuffer(lightEvent, buffers[i]);
}
}
_light.AddCommandBuffer(lightEvent, copyShadowBuffer);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, shader);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
CreateShadowRenderTexture();
UpdateShaderValues();
UpdateCommandBuffer();
}
public void ResetShadowMode()
{
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/Internal-ScreenSpaceShadows"));
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.Disabled);
_light.shadowCustomResolution = 0;
DestroyImmediate(shadowRenderTexture);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseBuiltin);
if (!_light)
{
return;
}
_light.RemoveCommandBuffer(LightEvent.AfterShadowMap, copyShadowBuffer);
}
void Init()
{
if (isInitialized)
{
return;
}
if (isGraphicSet == false)
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/NGSS_Directional"));//Shader.Find can sometimes return null in Player builds (careful).
DirLight.shadows = LightShadows.Soft;
isGraphicSet = true;
}
isInitialized = true;
}
void Init()
{
if (isInitialized)
{
return;
}
if (isGraphicSet == false)
{
//QualitySettings.shadowProjection = ShadowProjection.StableFit;
//QualitySettings.shadowCascades = 4;
//QualitySettings.shadowCascade4Split = new Vector3(0.1f, 0.275f, 0.5f);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/NGSS_Directional"));//Shader.Find can sometimes return null in Player builds (careful).
isGraphicSet = true;
}
isInitialized = true;
}
void OnValidate()
{
if (enableInverseSquareFalloff)
{
GraphicsSettings.SetCustomShader(BuiltinShaderType.DeferredShading, deferredShading);
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.UseCustom);
RegenerateFalloff();
}
else
{
GraphicsSettings.SetCustomShader(BuiltinShaderType.DeferredShading, Shader.Find("Hidden/Internal-DeferredShading"));
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.Disabled);
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.UseBuiltin);
}
AssetDatabase.Refresh();
}
private void Init()
{
if (this.isInitialized)
{
return;
}
if (!this.isGraphicSet)
{
this.isGraphicSet = true;
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/NGSS_Directional"));
}
if (!this.PCSS_ENABLED)
{
return;
}
this.m_Light = base.GetComponent <Light>();
int num = (QualitySettings.shadowResolution != ShadowResolution.VeryHigh) ? ((QualitySettings.shadowResolution != ShadowResolution.High) ? ((QualitySettings.shadowResolution != ShadowResolution.Medium) ? 512 : 1024) : 2048) : 4096;
this.m_ShadowmapCopy = null;
this.m_ShadowmapCopy = new RenderTexture(num, num, 0, RenderTextureFormat.RFloat);
this.m_ShadowmapCopy.filterMode = FilterMode.Bilinear;
this.m_ShadowmapCopy.useMipMap = false;
this.rawShadowDepthCB = new CommandBuffer
{
name = "NGSS Directional PCSS buffer"
};
this.rawShadowDepthCB.Clear();
this.rawShadowDepthCB.SetShadowSamplingMode(BuiltinRenderTextureType.CurrentActive, ShadowSamplingMode.RawDepth);
this.rawShadowDepthCB.Blit(BuiltinRenderTextureType.CurrentActive, this.m_ShadowmapCopy);
this.rawShadowDepthCB.SetGlobalTexture("NGSS_DirectionalRawDepth", this.m_ShadowmapCopy);
foreach (CommandBuffer commandBuffer in this.m_Light.GetCommandBuffers(LightEvent.AfterShadowMap))
{
if (commandBuffer.name == this.rawShadowDepthCB.name)
{
this.isInitialized = true;
return;
}
}
this.m_Light.AddCommandBuffer(LightEvent.AfterShadowMap, this.rawShadowDepthCB);
this.isInitialized = true;
}
public void Setup()
{
_light = GetComponent <Light>();
if (!_light)
{
return;
}
resolution = Mathf.ClosestPowerOfTwo(resolution);
if (customShadowResolution)
{
_light.shadowCustomResolution = resolution;
}
else
{
_light.shadowCustomResolution = 0;
}
shader = Shader.Find(shaderName);
shadowmapPropID = Shader.PropertyToID("_ShadowMap");
copyShadowBuffer = new CommandBuffer();
copyShadowBuffer.name = "PCSS Shadows";
var buffers = _light.GetCommandBuffers(lightEvent);
for (int i = 0; i < buffers.Length; i++)
{
if (buffers[i].name == "PCSS Shadows")
{
_light.RemoveCommandBuffer(lightEvent, buffers[i]);
}
}
_light.AddCommandBuffer(lightEvent, copyShadowBuffer);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, shader);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
CreateShadowRenderTexture();
UpdateShaderValues();
UpdateCommandBuffer();
}
public static int SetShaderMode_s(IntPtr l)
{
int result;
try
{
BuiltinShaderType type;
LuaObject.checkEnum <BuiltinShaderType>(l, 1, out type);
BuiltinShaderMode mode;
LuaObject.checkEnum <BuiltinShaderMode>(l, 2, out mode);
GraphicsSettings.SetShaderMode(type, mode);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private void UpdateGraphics()
{
if (deferredShading == null)
{
deferredShading = Resources.Load <Shader>("Internal-DeferredShading-Dithering");
}
if (screenSpaceShadows == null)
{
screenSpaceShadows = Resources.Load <Shader>("Internal-ScreenSpaceShadows-Dithering");
}
if (noise == null)
{
noise = Resources.Load <Texture2D>("NoiseHigh");
}
GraphicsSettings.SetShaderMode(DS, ((_point || _spot) && enabled) ? CUSTOM : BUILT_IN);
GraphicsSettings.SetCustomShader(DS, ((_point || _spot) && enabled) ? deferredShading : null);
GraphicsSettings.SetShaderMode(SSS, (direction && enabled) ? CUSTOM : BUILT_IN);
GraphicsSettings.SetCustomShader(SSS, (direction && enabled) ? screenSpaceShadows : null);
UpdateShaders();
}
void Init()
{
if (isInitialized)
{
return;
}
if (isGraphicSet == false)
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, Shader.Find("Hidden/NGSS_Directional"));//Shader.Find can sometimes return null in Player builds (careful).
DirLight.shadows = DirLight.shadows == LightShadows.None ? LightShadows.None : LightShadows.Soft;
isGraphicSet = true;
}
if (NGSS_NOISE_TEXTURE == null)
{
NGSS_NOISE_TEXTURE = Resources.Load <Texture2D>("BlueNoise_R8_8");
}
Shader.SetGlobalTexture("_BlueNoiseTextureDir", NGSS_NOISE_TEXTURE);
isInitialized = true;
}
public void ResetShadowMode()
{
builtinShader = Shader.Find(builtinShaderName);
// if (!Application.isEditor)
// {
// if (builtinShader)
// Debug.LogErrorFormat("Built-In Shadow Shader Found: {0} | Supported {1}", builtinShader.name, builtinShader.isSupported);
// else
// Debug.LogError("Shadow Shader Not Found!!!");
// }
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, builtinShader);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.Disabled);
_light.shadowCustomResolution = 0;
DestroyImmediate(shadowRenderTexture);
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseBuiltin);
if (!_light)
{
return;
}
_light.RemoveCommandBuffer(LightEvent.AfterShadowMap, copyShadowBuffer);
}
void SetShadows()
{
if (HighLogic.LoadedScene != GameScenes.MAINMENU)
{
if (unifiedCameraMode && (mainSettings.d3d11ShadowFix || mainSettings.terrainShadows))
{
QualitySettings.shadowProjection = ShadowProjection.StableFit; //way more resistant to jittering
GraphicsSettings.SetShaderMode(BuiltinShaderType.ScreenSpaceShadows, BuiltinShaderMode.UseCustom);
if ((mainSettings.terrainShadows) && (mainSettings.unifiedCamShadowsDistance > 8000f))
{
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, ShaderReplacer.Instance.LoadedShaders [("Scatterer/longDistanceScreenSpaceShadows")]);
partialUnifiedCameraDepthBuffer = (PartialDepthBuffer)nearCamera.gameObject.AddComponent(typeof(PartialDepthBuffer));
partialUnifiedCameraDepthBuffer.Init(nearCamera);
}
else
{
GraphicsSettings.SetCustomShader(BuiltinShaderType.ScreenSpaceShadows, ShaderReplacer.Instance.LoadedShaders [("Scatterer/fixedScreenSpaceShadows")]);
}
}
if (mainSettings.shadowsOnOcean)
{
if (unifiedCameraMode || SystemInfo.graphicsDeviceVersion.Contains("Direct3D 11.0"))
{
QualitySettings.shadowProjection = ShadowProjection.StableFit; //StableFit + splitSpheres is the only thing that works Correctly for unified camera (dx11) ocean shadows
//Otherwise we get artifacts near shadow cascade edges
}
else
{
QualitySettings.shadowProjection = ShadowProjection.CloseFit; //CloseFit without SplitSpheres seems to be the only setting that works for OpenGL for ocean shadows
//Seems like I lack the correct variables to determine which shadow path to take
//also try without the transparent tag
}
shadowMapRetriever = (ShadowMapRetrieveCommandBuffer)sunLight.gameObject.AddComponent(typeof(ShadowMapRetrieveCommandBuffer));
}
if (mainSettings.terrainShadows)
{
QualitySettings.shadowDistance = unifiedCameraMode ? mainSettings.unifiedCamShadowsDistance : mainSettings.dualCamShadowsDistance;
Utils.LogDebug("Set shadow distance: " + QualitySettings.shadowDistance.ToString());
Utils.LogDebug("Number of shadow cascades detected " + QualitySettings.shadowCascades.ToString());
if (sunLight)
{
//fixes checkerboard artifacts aka shadow acne
float bias = unifiedCameraMode ? mainSettings.unifiedCamShadowNormalBiasOverride : mainSettings.dualCamShadowNormalBiasOverride;
float normalBias = unifiedCameraMode ? mainSettings.unifiedCamShadowBiasOverride : mainSettings.dualCamShadowBiasOverride;
if (bias > 0f)
{
sunLight.shadowBias = bias;
}
if (normalBias > 0f)
{
sunLight.shadowNormalBias = normalBias;
}
int customRes = unifiedCameraMode ? mainSettings.unifiedCamShadowResolutionOverride : mainSettings.dualCamShadowResolutionOverride;
if (customRes != 0)
{
if (Utils.IsPowerOfTwo(customRes))
{
Utils.LogDebug("Setting shadowmap resolution to: " + customRes.ToString());
sunLight.shadowCustomResolution = customRes;
}
else
{
Utils.LogError("Selected shadowmap resolution not a power of 2: " + customRes.ToString());
}
}
}
//and finally force shadow Casting and receiving on celestial bodies if not already set
foreach (CelestialBody _sc in scattererCelestialBodiesManager.CelestialBodies)
{
if (_sc.pqsController)
{
_sc.pqsController.meshCastShadows = true;
_sc.pqsController.meshRecieveShadows = true;
}
}
}
}
}
public void Setup()
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.DeferredShading, _deferredShader);
this.enabled = true;
}
public void UnSetup()
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.DeferredShading, BuiltinShaderMode.UseBuiltin);
this.enabled = false;
}
void OnEnable()
{
GraphicsSettings.SetShaderMode(BuiltinShaderType.DepthNormals, BuiltinShaderMode.UseCustom);
GraphicsSettings.SetCustomShader(BuiltinShaderType.DepthNormals, customShader);
}
