void EnableARMode()
{
var m_actionMap = m_InputActionAsset.FindActionMap("AR", true);
m_actionMap.Enable();
// enable SimulationView
EnableSimulationViewInEditor(true);
// disable RootNode
UIStateManager.current.m_RootNode.SetActive(false);
UIStateManager.current.m_BoundingBoxRootNode.SetActive(false);
// Set AR Renderer
m_CameraData.SetRenderer((int)UniversalRenderer.ARRenderer);
m_MARSCamera.enabled = true;
// un-Pause MARSSession
UIStateManager.current.StartDetectingPlanes();
UIStateManager.current.StartDetectingPoints();
UIStateManager.current.ResumeSession();
// Enable all the culling mask layer to allow Mars to be able to render the simulation view
m_MARSCamera.GetComponent <Camera>().cullingMask = -1;
InitSimulationCameraPosition();
ChangeClippingPlane(0.01f, m_InitialFarClippingPlane * 10f);
}
void EnableARMode()
{
var m_actionMap = m_InputActionAsset.FindActionMap("AR", true);
m_actionMap.Enable();
// enable SimulationView
EnableSimulationViewInEditor(true);
// disable RootNode
m_RootSelector.GetValue().gameObject.SetActive(false);
m_ARPlacementStateDataSelector.GetValue().boundingBoxRootNode.gameObject.SetActive(false);
#if URP_AVAILABLE
// Set AR Renderer
m_CameraData.SetRenderer((int)UniversalRenderer.ARRenderer);
#endif
m_MARSCamera.enabled = true;
// un-Pause MARSSession
UIStateManager.current.StartDetectingPlanes();
UIStateManager.current.StartDetectingPoints();
UIStateManager.current.ResumeSession();
// Enable all the culling mask layer to allow Mars to be able to render the simulation view
m_MARSCamera.GetComponent <Camera>().cullingMask = -1;
InitSimulationCameraPosition();
}
void OnStateDataChanged(UIStateData stateData)
{
if (m_ToolbarsEnabled != stateData.toolbarsEnabled)
{
m_ToolbarsEnabled = stateData.toolbarsEnabled;
}
if (m_CachedNavigationMode != stateData.navigationState.navigationMode && m_ToolbarsEnabled)
{
m_CachedNavigationMode = stateData.navigationState.navigationMode;
if (m_CachedNavigationMode == NavigationMode.AR)
{
StartCoroutine(ResetInstructionUI());
}
else
{
var m_actionMap = m_InputActionAsset.FindActionMap("AR", true);
m_actionMap.Disable();
// disable SimulationView
EnableSimulationViewInEditor(false);
// enable RootNode
m_MARSCamera.enabled = false;
// return to default Renderer
m_CameraData.SetRenderer((int)UniversalRenderer.DefaultForwardRenderer);
UIStateManager.current.m_RootNode.SetActive(true);
if (UIStateManager.current.SessionReady())
{
// Pause MARSSession
UIStateManager.current.StopDetectingPlanes();
UIStateManager.current.StopDetectingPoints();
UIStateManager.current.PauseSession();
}
}
}
if (m_CachedOperationCancelled != stateData.operationCancelled && m_ToolbarsEnabled)
{
m_CachedOperationCancelled = stateData.operationCancelled;
if (m_CachedOperationCancelled == true)
{
switch (m_CachedInstructionUI)
{
case InstructionUI.ConfirmPlacement:
case InstructionUI.AimToPlaceBoundingBox:
{
m_Raycaster.ResetTransformation();
break;
}
}
StartCoroutine(AcknowledgeCancel());
}
}
}
public void SetNightFOV(bool _IsWerewolf)
{
camData.SetRenderer(0);
black.SetActive(true);
isNightTime = true;
if (_IsWerewolf)
{
viewDistance = GameManager.getInstance.wolfViewRange;
}
else
{
viewDistance = GameManager.getInstance.VillageViewRange;
}
}
protected override void PrepareCamera(Camera renderCamera)
{
base.PrepareCamera(renderCamera);
UniversalAdditionalCameraData cameraData = renderCamera.gameObject.AddComponent <UniversalAdditionalCameraData>();
cameraData.renderShadows = false;
cameraData.SetRenderer(1);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Tab))
{
scanToggle = !scanToggle;
if (scanToggle)
{
additionalMainCameraData.SetRenderer(1);
ppVol.enabled = true;
blackCam.enabled = true;
inCam.enabled = true;
}
else
{
additionalMainCameraData.SetRenderer(0);
ppVol.enabled = false;
blackCam.enabled = false;
inCam.enabled = false;
}
}
}
private void CreateReflectionCamera(Camera source)
{
GameObject go = new GameObject(source.name + "_reflection");
go.hideFlags = HideFlags.DontSave | HideFlags.HideInHierarchy;
Camera newCamera = go.AddComponent <Camera>();
newCamera.hideFlags = HideFlags.DontSave;
newCamera.CopyFrom(source);
//Always exclude water layer
newCamera.cullingMask = ~(1 << 4) & cullingMask;
//newCamera.cameraType = CameraType.Reflection; //Will cause shadow pass to execute twice?!
newCamera.depth = source.depth - 1f;
newCamera.rect = new Rect(0, 0, 1, 1);
newCamera.enabled = false;
newCamera.clearFlags = includeSkybox ? CameraClearFlags.Skybox : CameraClearFlags.Depth;
newCamera.useOcclusionCulling = false;
UniversalAdditionalCameraData data = newCamera.gameObject.AddComponent <UniversalAdditionalCameraData>();
data.requiresDepthTexture = false;
data.requiresColorTexture = false;
data.renderShadows = renderShadows;
rendererIndex = PipelineUtilities.ValidateRenderer(rendererIndex);
data.SetRenderer(rendererIndex);
#if RENDER_FEATURE
cameraLeft.cullingMask = 0;
data.SetRenderer(1);
ReflectionRenderers[newCamera] = this;
#endif
CreateRenderTexture(newCamera, source);
reflectionCameras[source] = newCamera;
}
public void DeactivateBuilderInWorldCamera()
{
Camera camera = Camera.main;
DCLBuilderOutline outliner = camera.GetComponent <DCLBuilderOutline>();
if (outliner != null)
{
outliner.enabled = false;
outliner.Deactivate();
}
UniversalAdditionalCameraData additionalCameraData = camera.transform.GetComponent <UniversalAdditionalCameraData>();
additionalCameraData.SetRenderer(0);
}
/// <summary>
/// Should the renderer index be changed at runtime, this function must be called to update any reflection cameras
/// </summary>
/// <param name="index"></param>
public void SetRendererIndex(int index)
{
index = PipelineUtilities.ValidateRenderer(index);
foreach (var kvp in reflectionCameras)
{
if (kvp.Value == null)
{
continue;
}
cameraData = kvp.Value.GetComponent <UniversalAdditionalCameraData>();
cameraData.SetRenderer(index);
}
}
public void SetVisualization(Visualization newVis)
{
// Abbruch falls nicht initialisiert
if (!_cameraData)
{
return;
}
// Renderer setzen
_cameraData.SetRenderer((int)newVis);
// Event ausloesen
if (_currVis != newVis)
{
VisualizationChanged?.Invoke(newVis);
}
// Speichern
_currVis = newVis;
}
private Camera CreateReflectionCamera()
{
GameObject go = new GameObject("Planar Reflections Camera", typeof(Camera));
UniversalAdditionalCameraData cameraData = go.AddComponent <UniversalAdditionalCameraData>();
cameraData.requiresColorOption = CameraOverrideOption.Off;
cameraData.requiresDepthOption = CameraOverrideOption.Off;
cameraData.SetRenderer(CameraRendererIndex);
Camera reflectionCamera = go.GetComponent <Camera>();
reflectionCamera.transform.SetPositionAndRotation(transform.position, transform.rotation);
reflectionCamera.depth = -5;
reflectionCamera.enabled = false;
go.hideFlags = HideFlags.HideAndDontSave;
return(reflectionCamera);
}
public void Setup()
{
m_BaseObj = new GameObject();
m_BaseCamera = m_BaseObj.AddComponent <Camera>();
m_BaseCameraData = m_BaseObj.AddComponent <UniversalAdditionalCameraData>();
m_BaseCamera.allowHDR = false;
m_BaseCameraData.SetRenderer(3); // 2D Renderer. See the list of Renderers in CommonAssets/UniversalRPAsset.
m_BaseCameraData.renderType = CameraRenderType.Base;
m_BaseCameraData.renderPostProcessing = false;
m_OverlayObj = new GameObject();
m_OverlayCamera = m_OverlayObj.AddComponent <Camera>();
m_OverlayCameraData = m_OverlayObj.AddComponent <UniversalAdditionalCameraData>();
m_OverlayCamera.allowHDR = false;
m_OverlayCameraData.SetRenderer(3); // 2D Renderer. See the list of Renderers in CommonAssets/UniversalRPAsset.
m_OverlayCameraData.renderType = CameraRenderType.Overlay;
m_OverlayCameraData.renderPostProcessing = false;
}
public void ActivateBuilderInWorldCamera()
{
Camera camera = Camera.main;
DCLBuilderOutline outliner = camera.GetComponent <DCLBuilderOutline>();
if (outliner == null)
{
outliner = camera.gameObject.AddComponent(typeof(DCLBuilderOutline)) as DCLBuilderOutline;
outliner.SetOutlineMaterial(outlinerMaterial);
}
else
{
outliner.enabled = true;
}
outliner.Activate();
UniversalAdditionalCameraData additionalCameraData = camera.transform.GetComponent <UniversalAdditionalCameraData>();
additionalCameraData.SetRenderer(builderRendererIndex);
}
private void ActivateBuilderInWorldCamera()
{
Camera camera = Camera.main;
BIWOutline outliner = camera.GetComponent <BIWOutline>();
if (outliner == null)
{
outliner = camera.gameObject.AddComponent(typeof(BIWOutline)) as BIWOutline;
outliner.SetOutlineMaterial(cameraOutlinerMaterial);
}
else
{
outliner.enabled = true;
}
outliner.Activate();
UniversalAdditionalCameraData additionalCameraData = camera.transform.GetComponent <UniversalAdditionalCameraData>();
additionalCameraData.SetRenderer(BUILDER_RENDERER_INDEX);
}
/// <summary>
/// Sets the renderer index of the related forward renderer
/// </summary>
/// <param name="camData"></param>
/// <param name="renderer"></param>
public static void AssignRendererToCamera(UniversalAdditionalCameraData camData, ScriptableRendererData renderer)
{
if (UniversalRenderPipeline.asset)
{
if (renderer)
{
//list is internal, so perform reflection workaround
ScriptableRendererData[] rendererDataList = (ScriptableRendererData[])typeof(UniversalRenderPipelineAsset).GetField(renderDataListFieldName, BindingFlags.NonPublic | BindingFlags.Instance).GetValue(UniversalRenderPipeline.asset);
for (int i = 0; i < rendererDataList.Length; i++)
{
if (rendererDataList[i] == renderer)
{
camData.SetRenderer(i);
}
}
}
}
else
{
Debug.LogError("No Universal Render Pipeline is currently active.");
}
}
// Start is called before the first frame update
void Start()
{
cameraData = GetComponent <UniversalAdditionalCameraData>();
cameraData.SetRenderer(currentRendereIndex);
}
private void SwitchCameraRenderer()
{
currentRendereIndex = (currentRendereIndex + 1) % rendererCount;
cameraData.SetRenderer(currentRendereIndex);
}
private Camera CreateCamera()
{
Camera cam = new GameObject().AddComponent <Camera>();
cam.gameObject.name = "GrassBendCamera " + GetInstanceID();
cam.transform.localEulerAngles = new Vector3(90f, 0f, 0f);
cam.gameObject.hideFlags = HideFlags.HideAndDontSave;
if (actualFollowTarget)
{
cam.gameObject.transform.position = new Vector3(actualFollowTarget.transform.position.x, actualFollowTarget.transform.position.y + renderExtends, actualFollowTarget.transform.position.z);
}
cam.orthographic = true;
cam.depth = -100f;
cam.allowHDR = false;
cam.allowMSAA = false;
cam.clearFlags = CameraClearFlags.SolidColor;
cam.cullingMask = 0;
//Neutral bend direction and zero strength/mask
cam.backgroundColor = neutralVector;
cam.useOcclusionCulling = false;
cam.allowHDR = true;
cam.allowMSAA = false;
cam.forceIntoRenderTexture = true;
#if URP
UniversalAdditionalCameraData camData = cam.gameObject.AddComponent <UniversalAdditionalCameraData>();
camData.renderShadows = false;
camData.renderPostProcessing = false;
camData.antialiasing = AntialiasingMode.None;
camData.requiresColorOption = CameraOverrideOption.Off;
camData.requiresDepthOption = CameraOverrideOption.Off;
camData.requiresColorTexture = false;
camData.requiresDepthTexture = false;
if (UniversalRenderPipeline.asset)
{
#if UNITY_EDITOR
//Only runs in editor, but will be referenced in instance from there on
if (!bendRenderer)
{
bendRenderer = GetGrassBendRenderer();
}
DrawGrassBenders.ValidatePipelineRenderers();
#endif
if (bendRenderer)
{
//Assign DrawGrassBenders renderer (list is internal, so perform reflection workaround)
ScriptableRendererData[] rendererDataList = (ScriptableRendererData[])typeof(UniversalRenderPipelineAsset).GetField("m_RendererDataList", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(UniversalRenderPipeline.asset);
for (int i = 0; i < rendererDataList.Length; i++)
{
if (rendererDataList[i] == bendRenderer)
{
camData.SetRenderer(i);
}
}
}
else
{
this.enabled = false;
}
}
else
{
Debug.LogError("[StylizedGrassRenderer] No Universal Render Pipeline is currently active.");
}
#endif
return(cam);
}
