You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
312 lines
11 KiB
312 lines
11 KiB
using System.Collections.Generic;
|
|
using LeTai.Effects;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace LeTai.TrueShadow
|
|
{
|
|
public class ShadowFactory
|
|
{
|
|
private static ShadowFactory instance;
|
|
public static ShadowFactory Instance => instance ?? (instance = new ShadowFactory());
|
|
|
|
readonly Dictionary<int, ShadowContainer> shadowCache =
|
|
new Dictionary<int, ShadowContainer>();
|
|
|
|
readonly CommandBuffer cmd;
|
|
readonly MaterialPropertyBlock materialProps;
|
|
readonly ScalableBlur blurProcessor;
|
|
readonly ScalableBlurConfig blurConfig;
|
|
|
|
Material cutoutMaterial;
|
|
Material imprintPostProcessMaterial;
|
|
Material shadowPostProcessMaterial;
|
|
|
|
Material CutoutMaterial =>
|
|
cutoutMaterial ? cutoutMaterial : cutoutMaterial = new Material(Shader.Find("Hidden/TrueShadow/Cutout"));
|
|
|
|
Material ImprintPostProcessMaterial =>
|
|
imprintPostProcessMaterial
|
|
? imprintPostProcessMaterial
|
|
: imprintPostProcessMaterial = new Material(Shader.Find("Hidden/TrueShadow/ImprintPostProcess"));
|
|
|
|
Material ShadowPostProcessMaterial =>
|
|
shadowPostProcessMaterial
|
|
? shadowPostProcessMaterial
|
|
: shadowPostProcessMaterial = new Material(Shader.Find("Hidden/TrueShadow/PostProcess"));
|
|
|
|
private ShadowFactory()
|
|
{
|
|
cmd = new CommandBuffer {name = "Shadow Commands"};
|
|
materialProps = new MaterialPropertyBlock();
|
|
materialProps.SetVector(ShaderId.CLIP_RECT,
|
|
new Vector4(float.NegativeInfinity, float.NegativeInfinity,
|
|
float.PositiveInfinity, float.PositiveInfinity));
|
|
materialProps.SetInt(ShaderId.COLOR_MASK, (int) ColorWriteMask.All); // Render shadow even if mask hide graphic
|
|
|
|
ShaderProperties.Init(8);
|
|
blurConfig = ScriptableObject.CreateInstance<ScalableBlurConfig>();
|
|
blurConfig.hideFlags = HideFlags.HideAndDontSave;
|
|
blurProcessor = new ScalableBlur();
|
|
blurProcessor.Configure(blurConfig);
|
|
}
|
|
|
|
~ShadowFactory()
|
|
{
|
|
cmd.Dispose();
|
|
Utility.SafeDestroy(blurConfig);
|
|
Utility.SafeDestroy(cutoutMaterial);
|
|
Utility.SafeDestroy(imprintPostProcessMaterial);
|
|
}
|
|
|
|
#if LETAI_TRUESHADOW_DEBUG
|
|
RenderTexture debugTexture;
|
|
#endif
|
|
|
|
// public int createdContainerCount;
|
|
// public int releasedContainerCount;
|
|
|
|
internal void Get(ShadowSettingSnapshot snapshot, ref ShadowContainer container)
|
|
{
|
|
if (float.IsNaN(snapshot.dimensions.x) || snapshot.dimensions.x < 1 ||
|
|
float.IsNaN(snapshot.dimensions.y) || snapshot.dimensions.y < 1)
|
|
{
|
|
ReleaseContainer(container);
|
|
return;
|
|
}
|
|
|
|
#if LETAI_TRUESHADOW_DEBUG
|
|
RenderTexture.ReleaseTemporary(debugTexture);
|
|
if (snapshot.shadow.alwaysRender)
|
|
debugTexture = GenerateShadow(snapshot).Texture;
|
|
#endif
|
|
|
|
// Each request need a coresponding shadow texture
|
|
// Texture may be shared by multiple elements
|
|
// Texture are released when no longer used by any element
|
|
// ShadowContainer keep track of texture and their usage
|
|
|
|
|
|
int requestHash = snapshot.GetHashCode();
|
|
|
|
// Case: requester can keep the same texture
|
|
if (container?.requestHash == requestHash)
|
|
return;
|
|
|
|
ReleaseContainer(container);
|
|
|
|
if (shadowCache.TryGetValue(requestHash, out var existingContainer))
|
|
{
|
|
// Case: requester got texture from someone else
|
|
existingContainer.RefCount++;
|
|
container = existingContainer;
|
|
}
|
|
else
|
|
{
|
|
// Case: requester got new unique texture
|
|
container = shadowCache[requestHash] = GenerateShadow(snapshot);
|
|
// Debug.Log($"Created new container for request\t{requestHash}\tTotal Created: {++createdContainerCount}\t Alive: {createdContainerCount - releasedContainerCount}");
|
|
}
|
|
}
|
|
|
|
internal void ReleaseContainer(ShadowContainer container)
|
|
{
|
|
if (container == null)
|
|
return;
|
|
|
|
if (--container.RefCount > 0)
|
|
return;
|
|
|
|
RenderTexture.ReleaseTemporary(container.Texture);
|
|
shadowCache.Remove(container.requestHash);
|
|
|
|
// Debug.Log($"Released container for request\t{container.requestHash}\tTotal Released: {++releasedContainerCount}\t Alive: {createdContainerCount - releasedContainerCount}");
|
|
}
|
|
|
|
static readonly Rect UNIT_RECT = new Rect(0, 0, 1, 1);
|
|
|
|
ShadowContainer GenerateShadow(ShadowSettingSnapshot snapshot)
|
|
{
|
|
// return GenColoredTexture(request.GetHashCode());
|
|
|
|
cmd.Clear();
|
|
cmd.BeginSample("TrueShadow:Capture");
|
|
|
|
var bounds = snapshot.shadow.SpriteMesh.bounds;
|
|
var misalignment = CalcMisalignment(snapshot.canvas, snapshot.canvasRt, snapshot.shadow.RectTransform, bounds);
|
|
|
|
var padding = Mathf.CeilToInt(snapshot.size);
|
|
var imprintViewW = Mathf.RoundToInt(snapshot.dimensions.x + misalignment.bothSS.x);
|
|
var imprintViewH = Mathf.RoundToInt(snapshot.dimensions.y + misalignment.bothSS.y);
|
|
var tw = imprintViewW + padding * 2;
|
|
var th = imprintViewH + padding * 2;
|
|
|
|
var shadowTex = RenderTexture.GetTemporary(tw, th, 0, RenderTextureFormat.ARGB32);
|
|
var imprintTexDesc = shadowTex.descriptor;
|
|
imprintTexDesc.msaaSamples = snapshot.shouldAntialiasImprint ? Mathf.Max(1, QualitySettings.antiAliasing) : 1;
|
|
var imprintTex = RenderTexture.GetTemporary(imprintTexDesc);
|
|
|
|
RenderTexture imprintTexProcessed = null;
|
|
|
|
bool needProcessImprint = snapshot.shadow.IgnoreCasterColor || snapshot.shadow.Inset;
|
|
if (needProcessImprint)
|
|
imprintTexProcessed = RenderTexture.GetTemporary(imprintTexDesc);
|
|
|
|
var texture = snapshot.shadow.Content;
|
|
if (texture)
|
|
materialProps.SetTexture(ShaderId.MAIN_TEX, texture);
|
|
else
|
|
materialProps.SetTexture(ShaderId.MAIN_TEX, Texture2D.whiteTexture);
|
|
|
|
cmd.SetRenderTarget(imprintTex);
|
|
cmd.ClearRenderTarget(true, true, snapshot.shadow.ClearColor);
|
|
|
|
cmd.SetViewport(new Rect(padding, padding, imprintViewW, imprintViewH));
|
|
|
|
var imprintBoundMin = (Vector2) bounds.min - misalignment.minLS;
|
|
var imprintBoundMax = (Vector2) bounds.max + misalignment.maxLS;
|
|
cmd.SetViewProjectionMatrices(
|
|
Matrix4x4.identity,
|
|
Matrix4x4.Ortho(imprintBoundMin.x, imprintBoundMax.x,
|
|
imprintBoundMin.y, imprintBoundMax.y,
|
|
-1, 1)
|
|
);
|
|
|
|
snapshot.shadow.ModifyShadowCastingMesh(snapshot.shadow.SpriteMesh);
|
|
snapshot.shadow.ModifyShadowCastingMaterialProperties(materialProps);
|
|
cmd.DrawMesh(snapshot.shadow.SpriteMesh,
|
|
Matrix4x4.identity,
|
|
snapshot.shadow.GetShadowCastingMaterial(),
|
|
0, 0,
|
|
materialProps);
|
|
|
|
if (needProcessImprint)
|
|
{
|
|
ImprintPostProcessMaterial.SetKeyword("BLEACH", snapshot.shadow.IgnoreCasterColor);
|
|
ImprintPostProcessMaterial.SetKeyword("INSET", snapshot.shadow.Inset);
|
|
|
|
cmd.Blit(imprintTex, imprintTexProcessed, ImprintPostProcessMaterial);
|
|
}
|
|
|
|
cmd.EndSample("TrueShadow:Capture");
|
|
|
|
var needPostProcess = snapshot.shadow.Spread > 1e-3;
|
|
|
|
cmd.BeginSample("TrueShadow:Cast");
|
|
RenderTexture blurSrc = needProcessImprint ? imprintTexProcessed : imprintTex;
|
|
RenderTexture blurDst;
|
|
if (needPostProcess)
|
|
blurDst = RenderTexture.GetTemporary(shadowTex.descriptor);
|
|
else
|
|
blurDst = shadowTex;
|
|
|
|
if (snapshot.size < 1e-2)
|
|
{
|
|
cmd.Blit(blurSrc, blurDst);
|
|
}
|
|
else
|
|
{
|
|
blurConfig.Strength = snapshot.size;
|
|
blurProcessor.Blur(cmd, blurSrc, UNIT_RECT, blurDst);
|
|
}
|
|
|
|
cmd.EndSample("TrueShadow:Cast");
|
|
|
|
var relativeOffset = new Vector2(snapshot.canvasRelativeOffset.x / tw,
|
|
snapshot.canvasRelativeOffset.y / th);
|
|
var overflowAlpha = snapshot.shadow.Inset ? 1 : 0;
|
|
if (needPostProcess)
|
|
{
|
|
cmd.BeginSample("TrueShadow:PostProcess");
|
|
|
|
ShadowPostProcessMaterial.SetTexture(ShaderId.SHADOW_TEX, blurDst);
|
|
ShadowPostProcessMaterial.SetVector(ShaderId.OFFSET, relativeOffset);
|
|
ShadowPostProcessMaterial.SetFloat(ShaderId.OVERFLOW_ALPHA, overflowAlpha);
|
|
ShadowPostProcessMaterial.SetFloat(ShaderId.ALPHA_MULTIPLIER,
|
|
1f / Mathf.Max(1e-6f, 1f - snapshot.shadow.Spread));
|
|
|
|
cmd.SetViewport(UNIT_RECT);
|
|
cmd.Blit(blurSrc, shadowTex, ShadowPostProcessMaterial);
|
|
|
|
cmd.EndSample("TrueShadow:PostProcess");
|
|
}
|
|
else if (snapshot.shadow.Cutout)
|
|
{
|
|
cmd.BeginSample("TrueShadow:Cutout");
|
|
|
|
CutoutMaterial.SetVector(ShaderId.OFFSET, relativeOffset);
|
|
CutoutMaterial.SetFloat(ShaderId.OVERFLOW_ALPHA, overflowAlpha);
|
|
|
|
cmd.SetViewport(UNIT_RECT);
|
|
cmd.Blit(blurSrc, shadowTex, CutoutMaterial);
|
|
|
|
cmd.EndSample("TrueShadow:Cutout");
|
|
}
|
|
|
|
Graphics.ExecuteCommandBuffer(cmd);
|
|
|
|
RenderTexture.ReleaseTemporary(imprintTex);
|
|
RenderTexture.ReleaseTemporary(blurSrc);
|
|
if (needPostProcess)
|
|
RenderTexture.ReleaseTemporary(blurDst);
|
|
|
|
return new ShadowContainer(shadowTex, snapshot, padding, misalignment.minLS);
|
|
}
|
|
|
|
readonly struct PixelMisalignment
|
|
{
|
|
public readonly Vector2 bothSS;
|
|
public readonly Vector2 minLS;
|
|
public readonly Vector2 maxLS;
|
|
|
|
public PixelMisalignment(Vector2 bothSS, Vector2 minLS, Vector2 maxLS)
|
|
{
|
|
this.bothSS = bothSS;
|
|
this.minLS = minLS;
|
|
this.maxLS = maxLS;
|
|
}
|
|
}
|
|
|
|
PixelMisalignment CalcMisalignment(Canvas canvas, RectTransform canvasRt, RectTransform casterRt, Bounds meshBound)
|
|
{
|
|
PixelMisalignment misalignment;
|
|
|
|
if (canvas.renderMode == RenderMode.WorldSpace)
|
|
{
|
|
misalignment = new PixelMisalignment();
|
|
}
|
|
else
|
|
{
|
|
var referenceCamera = canvas.renderMode == RenderMode.ScreenSpaceCamera ? canvas.worldCamera : null;
|
|
|
|
var pxMisalignmentAtMin = casterRt.LocalToScreenPoint(meshBound.min, referenceCamera).Frac();
|
|
var pxMisalignmentAtMax =
|
|
Vector2.one - casterRt.LocalToScreenPoint(meshBound.max, referenceCamera).Frac();
|
|
if (pxMisalignmentAtMax.x > 1 - 1e-5)
|
|
pxMisalignmentAtMax.x = 0;
|
|
if (pxMisalignmentAtMax.y > 1 - 1e-5)
|
|
pxMisalignmentAtMax.y = 0;
|
|
|
|
misalignment = new PixelMisalignment(
|
|
pxMisalignmentAtMin + pxMisalignmentAtMax,
|
|
canvasRt.ScreenToCanvasSize(pxMisalignmentAtMin, referenceCamera),
|
|
canvasRt.ScreenToCanvasSize(pxMisalignmentAtMax, referenceCamera)
|
|
);
|
|
}
|
|
|
|
return misalignment;
|
|
}
|
|
|
|
RenderTexture GenColoredTexture(int hash)
|
|
{
|
|
var tex = new Texture2D(1, 1);
|
|
tex.SetPixels32(new[] {new Color32((byte) (hash >> 8), (byte) (hash >> 16), (byte) (hash >> 24), 255)});
|
|
tex.Apply();
|
|
|
|
var rt = RenderTexture.GetTemporary(1, 1);
|
|
Graphics.Blit(tex, rt);
|
|
|
|
return rt;
|
|
}
|
|
}
|
|
}
|