public override void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters, ref CameraData cameraData)
{
ShadowTextureRenderer shadowTextureRenderer = cameraData.camera.GetComponent <ShadowTextureRenderer>();
if (shadowTextureRenderer == null)
{
#if UNITY_EDITOR
Debug.LogWarning("No ShadowTextureRenderer found.");
#endif
return;
}
shadowTextureRenderer.UpdateVisibilityAndPrepareRendering();
cullingParameters.cullingMask = 0;
if (shadowTextureRenderer.isProjectorVisible)
{
DrawSceneObject drawScene = cameraData.camera.GetComponent <DrawSceneObject>();
if (drawScene != null)
{
cullingParameters.cullingMask = (uint)drawScene.cullingMask.value;
}
DrawTargetObject drawTarget = shadowTextureRenderer.GetComponent <DrawTargetObject>();
if (drawTarget != null)
{
drawTarget.SendMessage("OnPreCull");
}
shadowTextureRenderer.ConfigureRenderTarget(m_renderShadowTexturePass, ref cameraData);
}
cullingParameters.cullingOptions = CullingOptions.None;
cullingParameters.shadowDistance = 0;
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
DynamicShadowProjectorRenderer.DynamicShadowProjectorComponents components = m_renderer.GetDynamicShadowProjectorComponents(renderingData.cameraData.camera);
ShadowTextureRenderer shadowTextureRenderer = components.shadowTextureRenderer;
if (shadowTextureRenderer == null || !shadowTextureRenderer.isProjectorVisible)
{
return;
}
DrawSceneObject drawScene = components.drawSceneObject;
if (drawScene != null)
{
if (m_overrideOpaqueMaterial == null)
{
m_overrideOpaqueMaterial = new Material(shadowTextureRenderer.m_opaqueShadowShaderForLWRP);
}
else if (m_overrideOpaqueMaterial.shader != shadowTextureRenderer.m_opaqueShadowShaderForLWRP)
{
m_overrideOpaqueMaterial.shader = shadowTextureRenderer.m_opaqueShadowShaderForLWRP;
}
if (m_overrideTransparentMaterial == null)
{
m_overrideTransparentMaterial = new Material(shadowTextureRenderer.m_transparentShadowShaderForLWRP);
}
else if (m_overrideTransparentMaterial.shader != shadowTextureRenderer.m_transparentShadowShaderForLWRP)
{
m_overrideTransparentMaterial.shader = shadowTextureRenderer.m_transparentShadowShaderForLWRP;
}
DrawingSettings drawingSettings = new DrawingSettings(m_shaderTagIds[0], new SortingSettings(camera));
for (int i = 1; i < m_shaderTagIds.Length; ++i)
{
drawingSettings.SetShaderPassName(i, m_shaderTagIds[i]);
}
// draw opaque objects
drawingSettings.overrideMaterial = m_overrideOpaqueMaterial;
drawingSettings.overrideMaterialPassIndex = 0;
drawingSettings.enableDynamicBatching = renderingData.supportsDynamicBatching;
drawingSettings.enableInstancing = true;
drawingSettings.perObjectData = PerObjectData.None;
FilteringSettings opaqueFilteringSettings = new FilteringSettings(new RenderQueueRange(RenderQueueRange.opaque.lowerBound, 2500), drawScene.cullingMask);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref opaqueFilteringSettings);
// draw transparent objects
drawingSettings.overrideMaterial = m_overrideTransparentMaterial;
FilteringSettings transparentFilteringSettings = new FilteringSettings(new RenderQueueRange(2500, RenderQueueRange.transparent.upperBound), drawScene.cullingMask);
context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref transparentFilteringSettings);
}
DrawTargetObject drawTarget = components.drawTargetObject;
if (drawTarget != null)
{
context.ExecuteCommandBuffer(drawTarget.commandBuffer);
}
shadowTextureRenderer.ExecutePostRenderProcess(context);
}
void OnEnable()
{
DrawTargetObject component = target as DrawTargetObject;
if (component.shadowShader == null && (component.replacementShaders == null || component.replacementShaders.Length == 0))
{
component.shadowShader = FindMaterial("DynamicShadowProjector/Shadow/Opaque");
component.replacementShaders = new DrawTargetObject.ReplaceShader[2];
component.replacementShaders[0].renderType = "Transparent";
component.replacementShaders[0].shader = Shader.Find("DynamicShadowProjector/Shadow/Transparent");
component.replacementShaders[1].renderType = "TransparentCutout";
component.replacementShaders[1].shader = component.replacementShaders[0].shader;
serializedObject.Update();
EditorUtility.SetDirty(component);
}
}
// 添加阴影
public void AddShadow()
{
Transform body = _body != null ? _body.transform : transform;
_shadow = ResourceManager.Instance.GetShadowProjector();
_shadow.transform.SetParent(body);
_shadow.transform.localPosition = new Vector3(0, 2.2f, -1);
_shadow.transform.localRotation = Quaternion.Euler(45, 0, 0);
_shadow.transform.localScale = Vector3.one;
DrawTargetObject draw = _shadow.GetComponent <DrawTargetObject>();
if (draw != null)
{
draw.target = body;
}
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (m_rendered)
{
// in case of multipass VR, render pass will be called twice even if renderPassEvent == RenderPassEvent.BeforeRendering...
return;
}
CommandBuffer cmd = CommandBufferPool.Get();
cmd.SetViewProjectionMatrices(m_renderer.projectorCamera.worldToCameraMatrix, m_renderer.projectorCamera.projectionMatrix);
context.ExecuteCommandBuffer(cmd);
CommandBufferPool.Release(cmd);
DrawSceneObject drawScene = m_renderer.drawSceneObject;
if (drawScene != null)
{
ScriptableCullingParameters cullingParameters = new ScriptableCullingParameters();
if (m_renderer.projectorCamera.TryGetCullingParameters(false, out cullingParameters))
{
cullingParameters.cullingMask = (uint)drawScene.cullingMask.value;
CullingResults cullingResults = context.Cull(ref cullingParameters);
if (m_overrideOpaqueMaterial == null)
{
m_overrideOpaqueMaterial = new Material(drawScene.replacementShader);
}
else if (m_overrideOpaqueMaterial.shader != drawScene.replacementShader)
{
m_overrideOpaqueMaterial.shader = drawScene.replacementShader;
}
if (m_overrideAlphaCutoffMaterial == null)
{
m_overrideAlphaCutoffMaterial = new Material(drawScene.replacementShader);
m_overrideAlphaCutoffMaterial.EnableKeyword("_ALPHATEST_ON");
m_overrideAlphaCutoffMaterial.SetFloat("_DstBlend", 10.0f); // OneMinusSrcAlpha
}
else if (m_overrideAlphaCutoffMaterial.shader != drawScene.replacementShader)
{
m_overrideAlphaCutoffMaterial.shader = drawScene.replacementShader;
}
if (m_overrideTransparentMaterial == null)
{
m_overrideTransparentMaterial = new Material(drawScene.replacementShader);
m_overrideTransparentMaterial.EnableKeyword("_ALPHATEST_ON");
m_overrideTransparentMaterial.EnableKeyword("_ALPHABLEND_ON");
m_overrideTransparentMaterial.SetFloat("_SrcBlend", 5.0f); // SrcAlpha
m_overrideTransparentMaterial.SetFloat("_DstBlend", 10.0f); // OneMinusSrcAlpha
}
else if (m_overrideTransparentMaterial.shader != drawScene.replacementShader)
{
m_overrideTransparentMaterial.shader = drawScene.replacementShader;
}
DrawingSettings drawingSettings = new DrawingSettings(drawScene.shaderTagIds[0], new SortingSettings(m_renderer.projectorCamera));
for (int i = 1; i < drawScene.shaderTagIds.Length; ++i)
{
drawingSettings.SetShaderPassName(i, drawScene.shaderTagIds[i]);
}
// draw opaque objects
drawingSettings.overrideMaterial = m_overrideOpaqueMaterial;
drawingSettings.overrideMaterialPassIndex = 0;
drawingSettings.enableDynamicBatching = renderingData.supportsDynamicBatching;
drawingSettings.enableInstancing = true;
drawingSettings.perObjectData = PerObjectData.None;
FilteringSettings opaqueFilteringSettings = new FilteringSettings(new RenderQueueRange(RenderQueueRange.opaque.lowerBound, 2400), drawScene.cullingMask);
context.DrawRenderers(cullingResults, ref drawingSettings, ref opaqueFilteringSettings);
// draw alpha-cutoff objects
drawingSettings.overrideMaterial = m_overrideAlphaCutoffMaterial;
FilteringSettings alphacutoutFilteringSettings = new FilteringSettings(new RenderQueueRange(2400, RenderQueueRange.opaque.upperBound), drawScene.cullingMask);
context.DrawRenderers(cullingResults, ref drawingSettings, ref alphacutoutFilteringSettings);
// draw transparent objects
drawingSettings.overrideMaterial = m_overrideTransparentMaterial;
FilteringSettings transparentFilteringSettings = new FilteringSettings(new RenderQueueRange(RenderQueueRange.transparent.lowerBound, RenderQueueRange.transparent.upperBound), drawScene.cullingMask);
context.DrawRenderers(cullingResults, ref drawingSettings, ref transparentFilteringSettings);
}
}
DrawTargetObject drawTarget = m_renderer.drawTargetObject;
if (drawTarget != null)
{
context.ExecuteCommandBuffer(drawTarget.commandBuffer);
}
m_renderer.ExecutePostRenderProcess(context);
m_rendered = true;
}
void Awake()
{
if (instance != null)
{
GameObject.Destroy(this.gameObject);
return;
}
selfTrans = transform;
m_camera = ArtWrap.mainCamera;
m_shadowTextureRenderer = GetComponent <ShadowTextureRenderer>();
if (m_shadowTextureRenderer != null)
{
m_shadowTextureRenderer.camerasForViewClipTest = new Camera[] { m_camera }
}
;
//添加默认的，因为要根据默认的设置参数
m_defaultDrawObject = GetComponent <DrawTargetObject>();
m_defaultDrawObject.enabled = false;
m_drawObjects = new List <DrawTargetObject>();
m_drawObjects.Add(m_defaultDrawObject);
//设置阴影跟随平行光
SetLight();
instance = this;
}
void OnDestroy()
{
instance = null;
}
void Update()
{
if (m_followTrans != null)
{
//设置坐标偏移
m_posOff = -this.transform.forward * 20;
selfTrans.parent.position = m_followTrans.position + m_posOff;
}
for (int i = m_drawObjects.Count - 1; i >= 0; i--)
{
if (m_drawObjects[i].target == null)
{
m_drawObjects.RemoveAt(i);
return;
}
}
}
void SetLight()
{
//设置默认值
selfTrans.localPosition = Vector3.zero;
selfTrans.localRotation = Quaternion.identity;
selfTrans.parent.rotation = Quaternion.Euler(DEFAULTANGLE, 0, 0);
//根据场景平行光，设置阴影的方向
GameObject MapScene = GameObject.Find("MapScene");
if (MapScene == null)
{
return;
}
Light[] lights = MapScene.GetComponentsInChildren <Light>();
int lightCount = 0;
for (int i = 0; i < lights.Length; ++i)
{
if (lights[i].gameObject.name.Equals(LIGHTNAME))
{
lightCount++;
m_sceneLight = lights[i].gameObject;
}
}
if (lightCount > 1)
{
Debuger.LogError("场景中有多个角色平行光");
}
//设置灯光方向
if (m_sceneLight != null)
{
m_sceneLight.AddComponentIfNoExist <TargetDirection>();
}
}
void ShowObject(Transform trans, bool isShow)
{
#if USE_DRAW_POOL
//关闭影子
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (m_drawObjects[i].target == m_role.m_go.transform)
{
m_drawObjects[i].enabled = isShow;
}
}
#else
if (isShow)
{
AddDrawTarget(trans);
}
else
{
RemoveDrawTarget(trans);
}
#endif
}
void AddDrawTarget(Transform trans)
{
//如果已经添加过了，就不要再添加了
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (m_drawObjects[i].target == trans)
{
m_drawObjects[i].enabled = true;
m_drawObjects[i].target = trans;
Debuger.LogError("重复添加阴影");
return;
}
}
DrawTargetObject drawTarget = null;
#if USE_DRAW_POOL
for (int i = 0; i < m_drawObjects.Count; i++)
{
if (s_instce.m_drawObjects[i].target == null)
{
drawTarget = m_drawObjects[i];
m_drawObjects[i].enabled = true;
break;
}
}
#endif
//重新创建一个新的
if (drawTarget == null)
{
drawTarget = gameObject.AddComponent <DrawTargetObject>();
drawTarget.followTarget = false;
drawTarget.shadowShader = m_defaultDrawObject.shadowShader;
drawTarget.replacementShaders = m_defaultDrawObject.replacementShaders;
drawTarget.layerMask = m_defaultDrawObject.layerMask;
m_drawObjects.Add(drawTarget);
}
drawTarget.target = trans;
}
void SetFollow(Transform trans)
{
m_followTrans = trans;
}
void RemoveDrawTarget(Transform trans)
{
for (int i = m_drawObjects.Count - 1; i >= 0; i--)
{
if (m_drawObjects[i].target == trans)
{
#if USE_DRAW_POOL
s_instance.m_drawObjects[i].target = null;
s_instance.m_drawObjects[i].enabled = false;
s_instance.m_drawObjects[i].Clear();
#else
Object.Destroy(m_drawObjects[i]);
m_drawObjects.RemoveAt(i);
#endif
}
}
}
}
