public override void OnInspectorGUI()
{
ProjectorForLWRP projector = target as ProjectorForLWRP;
DrawDefaultInspector();
bool useStencil = EditorGUILayout.Toggle("Use Stencil Test", projector.useStencilTest);
if (useStencil != projector.useStencilTest)
{
if (useStencil)
{
if (projector.stencilPassMaterial == null)
{
Shader stencilPassShader = Shader.Find("Hidden/ProjectorForLWRP/StencilPass");
string path = AssetDatabase.GetAssetPath(stencilPassShader);
path = path.Substring(0, path.Length - 6); // remove "shader" extension
path += "mat"; // add "mat" extension
serializedObject.FindProperty("m_stencilPass").objectReferenceValue = AssetDatabase.LoadAssetAtPath(path, typeof(Material)) as Material;
}
}
else
{
serializedObject.FindProperty("m_stencilPass").objectReferenceValue = null;
}
}
serializedObject.ApplyModifiedProperties();
}
public void AddProjector(ProjectorForLWRP projector)
{
if (!m_projectors.Contains(projector))
{
m_projectors.Add(projector);
}
}
public void CopySerializedPropertiesFrom(ProjectorForLWRP src)
{
renderPassEvent = src.renderPassEvent;
renderQueueLowerBound = src.renderQueueLowerBound;
renderQueueUpperBound = src.renderQueueUpperBound;
perObjectData = src.perObjectData;
stencilPassMaterial = src.stencilPassMaterial;
}
public static void AddProjector(ProjectorForLWRP projector, Camera camera)
{
RenderProjectorPass pass;
if (!s_projectorPasses.TryGetValue(camera, out pass))
{
pass = new RenderProjectorPass(camera); pass.renderPassEvent = projector.renderPassEvent; s_projectorPasses.Add(camera, pass);
}
pass.AddProjector(projector);
}
private void OnEnable()
{
ProjectorForLWRP projector = target as ProjectorForLWRP;
Projector baseProjector = projector.GetComponent <Projector>();
m_isOrthographic = baseProjector.orthographic;
m_orthographicSize = baseProjector.orthographicSize;
m_aspect = baseProjector.aspectRatio;
m_fov = baseProjector.fieldOfView;
}
private void OnDisable()
{
// Revert the hide flags so that Projector can be visible in Inspector when ProjectorForLWRP component is removed.
// this will not make the scene dirty.
ProjectorForLWRP projector = target as ProjectorForLWRP;
if (projector != null && projector.projector != null)
{
projector.projector.hideFlags &= ~HideFlags.HideInInspector;
}
}
public static void AddProjector(ProjectorForLWRP projector, Camera camera)
{
if (s_instance == null)
{
#if UNITY_EDITOR
Debug.LogError("No ProjectorRendererFeature in the ForwardRendererData!");
#endif
return;
}
s_instance.AddProjectorInternal(projector, camera);
}
private void AddProjectorInternal(ProjectorForLWRP projector, Camera camera)
{
RenderProjectorPass pass;
if (!m_projectorPasses.TryGetValue(camera, out pass))
{
pass = new RenderProjectorPass(camera);
pass.renderPassEvent = projector.renderPassEvent;
m_projectorPasses.Add(camera, pass);
}
pass.AddProjector(projector);
}
public override void OnInspectorGUI()
{
ProjectorForLWRP projector = target as ProjectorForLWRP;
DrawDefaultInspector();
bool useStencil = EditorGUILayout.Toggle("Use Stencil Test", projector.useStencilTest);
if (useStencil)
{
if (projector.stencilPassMaterial == null)
{
Shader stencilPassShader = Shader.Find("Hidden/ProjectorForLWRP/StencilPass");
string path = AssetDatabase.GetAssetPath(stencilPassShader);
path = path.Substring(0, path.Length - 6); // remove "shader" extension
path += "mat"; // add "mat" extension
projector.stencilPassMaterial = AssetDatabase.LoadAssetAtPath(path, typeof(Material)) as Material;
}
Material projectorMaterial = projector.GetComponent <Projector>().material;
++EditorGUI.indentLevel;
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_stencilRef"));
EditorGUILayout.PropertyField(serializedObject.FindProperty("m_stencilMask"));
--EditorGUI.indentLevel;
}
else
{
projector.stencilPassMaterial = null;
}
projector.UpdateShaderTagIdList();
serializedObject.ApplyModifiedProperties();
Projector baseProjector = projector.GetComponent <Projector>();
if (m_isOrthographic != baseProjector.orthographic ||
m_orthographicSize != baseProjector.orthographicSize ||
m_aspect != baseProjector.aspectRatio ||
m_fov != baseProjector.fieldOfView ||
m_far != baseProjector.farClipPlane ||
m_near != baseProjector.nearClipPlane)
{
m_isOrthographic = baseProjector.orthographic;
m_orthographicSize = baseProjector.orthographicSize;
m_aspect = baseProjector.aspectRatio;
m_fov = baseProjector.fieldOfView;
m_far = baseProjector.farClipPlane;
m_near = baseProjector.nearClipPlane;
projector.UpdateFrustum();
}
}
public static void AddProjector(ProjectorForLWRP projector, Camera camera)
{
#if UNITY_EDITOR
// check if the current Forward Renderer has the ProjectorRendererFeature instance.
LightweightRenderPipelineAsset renderPipelineAsset = UnityEngine.Rendering.LWRP.LightweightRenderPipeline.asset;
if (renderPipelineAsset == null)
{
return;
}
UnityEditor.SerializedObject serializedObject = new UnityEditor.SerializedObject(renderPipelineAsset);
UnityEditor.SerializedProperty rendererDataProperty = serializedObject.FindProperty("m_RendererData");
UnityEngine.Rendering.LWRP.ScriptableRendererData rendererData = rendererDataProperty.objectReferenceValue as UnityEngine.Rendering.LWRP.ScriptableRendererData;
if (rendererData == null)
{
Debug.LogError("The current Lightweight Render Pipeline Asset does not have Forward Renderer Data! Please set a Forward Renderer Data which contains ProjectorRendererFeature to the current render pipeline asset.", renderPipelineAsset);
}
else
{
bool found = false;
foreach (var rendererFeature in rendererData.rendererFeatures)
{
if (rendererFeature is ProjectorRendererFeature)
{
found = true;
break;
}
}
if (!found)
{
Debug.LogError("ProjectorRendererFeature is not added to the current Forward Renderer Data.", rendererData);
}
}
#endif
if (s_projectorPasses == null)
{
#if UNITY_EDITOR
Debug.LogError("No ProjectorRendererFeature instances are created!");
#endif
return;
}
AddProjectorInternal(projector, camera);
}
public void Render(ScriptableRenderContext context, ref RenderingData renderingData)
{
CullingResults cullingResults;
if (!parentProjector.TryGetCullingResults(renderingData.cameraData.camera, out cullingResults))
{
return;
}
Material tempMaterial = material;
// The keyword must be already enabled. It does not need to be enabled here.
// EnableProjectorForLWRPKeyword(material);
parentProjector.SetupProjectorMatrix(tempMaterial);
if (useStencilTest)
{
if (m_runtimeStencilPassMaterial == null)
{
m_runtimeStencilPassMaterial = new Material(stencilPassMaterial);
}
parentProjector.WriteFrustumStencil(context, renderingData.cameraData.camera, m_runtimeStencilPassMaterial);
}
ProjectorForLWRP.SetupCullingResultsForRendering(ref renderingData, ref cullingResults, perObjectData);
DrawingSettings drawingSettings;
FilteringSettings filteringSettings;
RenderStateBlock renderStateBlock;
GetDefaultDrawSettings(ref renderingData, tempMaterial, out drawingSettings, out filteringSettings, out renderStateBlock);
context.DrawRenderers(cullingResults, ref drawingSettings, ref filteringSettings, ref renderStateBlock);
if (useStencilTest)
{
parentProjector.ClearStencil(context, m_runtimeStencilPassMaterial, m_stencilTestOptions);
}
}
public override void OnInspectorGUI()
{
ProjectorForLWRP projector = target as ProjectorForLWRP;
DrawDefaultInspector();
bool useStencil = EditorGUILayout.Toggle("Use Stencil Test", projector.useStencilTest);
if (useStencil)
{
if (m_stencilOptionProperty == null)
{
m_stencilOptionProperty = serializedObject.FindProperty("m_stencilTestOptions");
}
EditorGUI.indentLevel++;
bool clearStencil = (m_stencilOptionProperty.intValue & (int)ProjectorForLWRP.StencilTestOptions.ClearStencil) != 0;
bool preventOverwriting = (m_stencilOptionProperty.intValue & (int)ProjectorForLWRP.StencilTestOptions.PreventOverwriting) != 0;
bool newClearStencil = EditorGUILayout.Toggle("Clear stencil after draw", clearStencil);
bool newPreventOverwriting = EditorGUILayout.Toggle("Prevent overwriting", preventOverwriting);
if (clearStencil != newClearStencil)
{
if (newClearStencil)
{
m_stencilOptionProperty.intValue |= (int)ProjectorForLWRP.StencilTestOptions.ClearStencil;
}
else
{
m_stencilOptionProperty.intValue &= ~(int)ProjectorForLWRP.StencilTestOptions.ClearStencil;
}
}
if (preventOverwriting != newPreventOverwriting)
{
if (newPreventOverwriting)
{
m_stencilOptionProperty.intValue |= (int)ProjectorForLWRP.StencilTestOptions.PreventOverwriting;
}
else
{
m_stencilOptionProperty.intValue &= ~(int)ProjectorForLWRP.StencilTestOptions.PreventOverwriting;
}
}
EditorGUI.indentLevel--;
}
if (useStencil != projector.useStencilTest)
{
if (m_stencilPassProperty == null)
{
m_stencilPassProperty = serializedObject.FindProperty("m_stencilPass");
}
if (useStencil)
{
if (projector.stencilPassMaterial == null)
{
Shader stencilPassShader = Shader.Find("Hidden/ProjectorForLWRP/StencilPass");
string path = AssetDatabase.GetAssetPath(stencilPassShader);
path = path.Substring(0, path.Length - 6); // remove "shader" extension
path += "mat"; // add "mat" extension
m_stencilPassProperty.objectReferenceValue = AssetDatabase.LoadAssetAtPath(path, typeof(Material)) as Material;
}
}
else
{
m_stencilPassProperty.objectReferenceValue = null;
}
}
serializedObject.ApplyModifiedProperties();
}
void Initialize()
{
m_projectorForLWRP = GetComponent <ProjectorForLWRP>();
m_actionOnAddProjectorToRenderer = AddRenderer;
UpdateShaderTagIdList();
}
