public override void RenderLight(CommandBuffer cmd, ref LightRenderingData data)
{
cmd.SetRenderTarget(data.lightmap);
cmd.SetGlobalTexture("_MainTex", LightTexture);
cmd.SetGlobalColor("_Color", LightColor);
cmd.SetGlobalFloat("_Attenuation", Attenuation);
cmd.SetGlobalFloat("_Intensity", Intensity);
cmd.SetGlobalVector("_2DLightPos", transform.position);
cmd.SetGlobalFloat("_LightRange", LightDistance);
cmd.SetGlobalFloat("_Intensity", Intensity);
cmd.SetGlobalTexture("_ShadowMap", data.shadowmap);
cmd.SetGlobalTexture("_LightCookie", LightTexture);
var trs = Matrix4x4.TRS(transform.position, transform.rotation, transform.localScale);
switch (LightType)
{
case LightType.Analytical:
cmd.DrawMesh(Mesh, trs, LightMaterial, 0, 0);
break;
case LightType.Textured:
cmd.DrawMesh(Mesh, trs, LightMaterial, 0, 1);
break;
}
}
public void Render(CommandBuffer cmd, ref LightRenderingData data)
{
var lightmap = ShaderIDLightMap;
var shadowmap = ShaderIDShadowMap;
var screenSize = new Vector2(data.camera.pixelWidth, data.camera.pixelHeight);
cmd.GetTemporaryRT(
lightmap,
Mathf.FloorToInt(screenSize.x * data.settings.LightMapResolutionScale),
Mathf.FloorToInt(screenSize.y * data.settings.LightMapResolutionScale),
0,
FilterMode.Bilinear,
data.settings.LightMapFormat);
cmd.GetTemporaryRT(
shadowmap,
Mathf.FloorToInt(screenSize.x * data.settings.ShadowMapResolutionScale),
Mathf.FloorToInt(screenSize.y * data.settings.ShadowMapResolutionScale),
0,
FilterMode.Bilinear,
data.settings.ShadowMapFormat);
data.lightmap = lightmap;
data.shadowmap = shadowmap;
cmd.SetRenderTarget(lightmap);
cmd.ClearRenderTarget(true, true, Color.black);
bool shouldClearShadowMap = true;
foreach (var light in Light2DBase.AssetsManager.Assets)
{
if (!light.enabled || !light.gameObject.activeInHierarchy)
{
continue;
}
if (shouldClearShadowMap)
{
cmd.SetRenderTarget(shadowmap);
cmd.ClearRenderTarget(true, true, Color.black);
shouldClearShadowMap = false;
}
if (light.LightShadows != LightShadows.None)
{
light.RenderShadow(cmd, ref data);
shouldClearShadowMap = true;
}
light.RenderLight(cmd, ref data);
}
cmd.SetGlobalFloat("_ExposureLimit", data.settings.ExposureLimit);
cmd.SetGlobalTexture("_LightMap", lightmap);
cmd.SetGlobalColor("_GlobalLight", data.settings.GlobalLight);
cmd.Blit(BuiltinRenderTextureType.None, data.cameraColorTarget, ShaderPool.Get("Lighting2D/DeferredLighting"), 0);
cmd.ReleaseTemporaryRT(lightmap);
cmd.ReleaseTemporaryRT(shadowmap);
}
public override void RenderLight(CommandBuffer cmd, ref LightRenderingData data)
{
cmd.SetRenderTarget(data.lightmap);
var renderer = GetComponent <SpriteRenderer>();
renderer.material.color *= Intensity;
cmd.DrawRenderer(renderer, renderer.material);
renderer.material.color = renderer.color;
}
public void RenderShadow(CommandBuffer cmd, ref LightRenderingData data)
{
if (LightShadows == LightShadows.None)
{
return;
}
if (shadowMat == null)
{
shadowMat = new Material(Shader.Find("Lighting2D/Shadow"));
}
if (!ShadowMesh)
{
ShadowMesh = new Mesh();
}
if (!tempMesh)
{
tempMesh = new Mesh();
}
ShadowMesh.Clear();
//subShadowMesh.ForEach(mesh => mesh.Clear());
//subShadowMesh.Clear();
var meshBuilder = new MeshBuilder();
int count = Physics2D.OverlapCircleNonAlloc(transform.position, LightDistance, shadowCasters);
CombineInstance[] combineArr = new CombineInstance[count];
for (var i = 0; i < count; i++)
{
Collider2D caster = shadowCasters[i];
if (caster is PolygonCollider2D)
{
var mesh = PolygonShadowMesh(caster as PolygonCollider2D);
combineArr[i].mesh = mesh;
meshBuilder.AddCopiedMesh(mesh);
mesh.Clear();
}
}
ShadowMesh = meshBuilder.ToMesh(ShadowMesh);
if (LightShadows == LightShadows.Soft && ShadowSmooth == ShadowSmooth.VolumnLight)
{
cmd.SetGlobalFloat("_LightSize", LightVolumn);
cmd.DrawMesh(ShadowMesh, Matrix4x4.TRS(transform.position, transform.rotation, transform.localScale), shadowMat, 0, 1);
}
else
{
cmd.DrawMesh(ShadowMesh, Matrix4x4.TRS(transform.position, transform.rotation, transform.localScale), shadowMat, 0, 0);
if (LightShadows == LightShadows.Soft && ShadowSmooth == ShadowSmooth.Blur)
{
GaussianBlur.Blur(SmoothRadius, cmd, data.shadowmap, data.shadowmap, ShaderPool.Get("GaussianBlur/Blur"));
}
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
var cmd = CommandBufferPool.Get("Lighting 2D");
var data = new LightRenderingData()
{
camera = renderingData.cameraData.camera,
cameraColorTarget = cameraColorTarget,
settings = settings,
};
pass.Render(cmd, ref data);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
}
public abstract void RenderLight(CommandBuffer cmd, ref LightRenderingData data);
public void RenderDeffer(Light2DProfile profile)
{
var camera = profile.Camera;
var cmd = profile.CommandBuffer;
cmd.Clear();
cmd.BeginSample("2D Lighting");
// !IMPORTANT! to prevent blit image upside down
// STUPID UNITY
var useMSAA = profile.Camera.allowMSAA && QualitySettings.antiAliasing > 0 ? 1 : 0;
cmd.SetGlobalInt("_UseMSAA", useMSAA);
#if UNITY_EDITOR
// In SceneView
if (UnityEditor.SceneView.GetAllSceneCameras().Any(cmr => cmr == camera))
{
if (!PreviewInInspector)
{
return;
}
cmd.SetGlobalInt("_SceneView", 1);
}
else
{
cmd.SetGlobalInt("_SceneView", 0);
}
#endif
var diffuse = Shader.PropertyToID("_Diffuse");
cmd.GetTemporaryRT(diffuse, -1, -1, 0, FilterMode.Bilinear, RenderTextureFormat.Default, RenderTextureReadWrite.Default, 1);
cmd.Blit(BuiltinRenderTextureType.CameraTarget, diffuse);
var shadowMap = Shader.PropertyToID("_ShadowMap");
var lightMap = profile.LightMap;
cmd.SetRenderTarget(lightMap, lightMap);
cmd.ClearRenderTarget(true, true, Color.black);
cmd.GetTemporaryRT(shadowMap, camera.pixelWidth / ShadowMapResolutionScale, camera.pixelHeight / ShadowMapResolutionScale, 0, ShadowMapFilterMode);
cmd.SetRenderTarget(shadowMap);
cmd.ClearRenderTarget(true, true, Color.black);
cmd.SetRenderTarget(lightMap);
bool renderedShadow = false;
var lights = GameObject.FindObjectsOfType <Light2D>();
var data = new LightRenderingData()
{
camera = camera,
lightmap = lightMap,
shadowmap = shadowMap,
settings = this.settings,
};
foreach (var light in lights)
{
if (renderedShadow)
{
cmd.SetRenderTarget(shadowMap);
cmd.ClearRenderTarget(true, true, Color.black);
}
if (light.LightShadows != LightShadows.None)
{
cmd.SetRenderTarget(shadowMap);
light.RenderShadow(cmd, ref data);
renderedShadow = true;
cmd.SetRenderTarget(lightMap);
}
else
{
renderedShadow = false;
}
light.RenderLight(cmd, ref data);
}
cmd.SetGlobalFloat("_ExposureLimit", ExposureLimit);
cmd.SetGlobalTexture("_LightMap", lightMap);
cmd.Blit(diffuse, BuiltinRenderTextureType.CameraTarget, LightingMaterial, 0);
cmd.ReleaseTemporaryRT(shadowMap);
cmd.ReleaseTemporaryRT(diffuse);
cmd.SetRenderTarget(BuiltinRenderTextureType.CameraTarget, BuiltinRenderTextureType.CameraTarget);
// GaussianBlur.Blur(256, cmd, BuiltinRenderTextureType.CameraTarget, BuiltinRenderTextureType.CameraTarget, gaussianMat);
cmd.EndSample("2D Lighting");
}
