public static Renderer2DData GetRenderer2DData()
{
UniversalRenderPipelineAsset pipelineAsset = UniversalRenderPipeline.asset;
if (pipelineAsset == null)
{
return(null);
}
// try get the default
Renderer2DData rendererData = pipelineAsset.scriptableRendererData as Renderer2DData;
if (rendererData == null)
{
foreach (Camera camera in Camera.allCameras)
{
UniversalAdditionalCameraData additionalCameraData = camera.GetComponent <UniversalAdditionalCameraData>();
ScriptableRenderer renderer = additionalCameraData?.scriptableRenderer;
Renderer2D renderer2D = renderer as Renderer2D;
if (renderer2D != null)
{
return(renderer2D.GetRenderer2DData());
}
}
}
return(rendererData);
}
void init(UniversalAdditionalCameraData additionalCameraData)
{
if (additionalCameraData == null)
{
return;
}
m_AdditionalCameraDataSO = new SerializedObject(additionalCameraData);
m_AdditionalCameraDataRenderShadowsProp = m_AdditionalCameraDataSO.FindProperty("m_RenderShadows");
m_AdditionalCameraDataRenderDepthProp = m_AdditionalCameraDataSO.FindProperty("m_RequiresDepthTextureOption");
m_AdditionalCameraDataRenderOpaqueProp = m_AdditionalCameraDataSO.FindProperty("m_RequiresOpaqueTextureOption");
m_AdditionalCameraDataRendererProp = m_AdditionalCameraDataSO.FindProperty("m_RendererIndex");
m_AdditionalCameraDataVolumeLayerMask = m_AdditionalCameraDataSO.FindProperty("m_VolumeLayerMask");
m_AdditionalCameraDataVolumeTrigger = m_AdditionalCameraDataSO.FindProperty("m_VolumeTrigger");
m_AdditionalCameraDataRenderPostProcessing = m_AdditionalCameraDataSO.FindProperty("m_RenderPostProcessing");
m_AdditionalCameraDataAntialiasing = m_AdditionalCameraDataSO.FindProperty("m_Antialiasing");
m_AdditionalCameraDataAntialiasingQuality = m_AdditionalCameraDataSO.FindProperty("m_AntialiasingQuality");
m_AdditionalCameraDataStopNaN = m_AdditionalCameraDataSO.FindProperty("m_StopNaN");
m_AdditionalCameraDataDithering = m_AdditionalCameraDataSO.FindProperty("m_Dithering");
m_AdditionalCameraClearDepth = m_AdditionalCameraDataSO.FindProperty("m_ClearDepth");
m_AdditionalCameraDataCameraTypeProp = m_AdditionalCameraDataSO.FindProperty("m_CameraType");
m_AdditionalCameraDataCameraOutputProp = m_AdditionalCameraDataSO.FindProperty("m_CameraOutput");
m_AdditionalCameraDataCameras = m_AdditionalCameraDataSO.FindProperty("m_Cameras");
}
public new void OnEnable()
{
m_UniversalRenderPipeline = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
m_CommonCameraSettingsFoldout = new SavedBool($"{target.GetType()}.CommonCameraSettingsFoldout", false);
m_EnvironmentSettingsFoldout = new SavedBool($"{target.GetType()}.EnvironmentSettingsFoldout", false);
m_OutputSettingsFoldout = new SavedBool($"{target.GetType()}.OutputSettingsFoldout", false);
m_RenderingSettingsFoldout = new SavedBool($"{target.GetType()}.RenderingSettingsFoldout", false);
m_StackSettingsFoldout = new SavedBool($"{target.GetType()}.StackSettingsFoldout", false);
m_AdditionalCameraData = camera.gameObject.GetComponent <UniversalAdditionalCameraData>();
m_ErrorIcon = EditorGUIUtility.Load("icons/console.erroricon.sml.png") as Texture2D;
validCameras.Clear();
errorCameras.Clear();
settings.OnEnable();
// Additional Camera Data
if (m_AdditionalCameraData == null)
{
m_AdditionalCameraData = camera.gameObject.AddComponent <UniversalAdditionalCameraData>();
}
init(m_AdditionalCameraData);
UpdateAnimationValues(true);
UpdateCameraTypeIntPopupData();
UpdateCameras();
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="cullingMask"></param>
/// <returns></returns>
public static Camera CreateCamera(string name, int cullingMask)
{
GameObject cameraObject = new GameObject(name);
Camera camera = cameraObject.AddComponent <Camera>();
camera.depth = 1;
camera.cullingMask = cullingMask;
camera.clearFlags = CameraClearFlags.Depth;
camera.orthographic = true;
camera.orthographicSize = DefaultCameraSize;
camera.nearClipPlane = -30;
camera.farClipPlane = 30;
#if UNITY_5_4_OR_NEWER
camera.stereoTargetEye = StereoTargetEyeMask.None;
#endif
#if UNITY_5_6_OR_NEWER
camera.allowHDR = false;
camera.allowMSAA = false;
#endif
#region 适配URP
UniversalAdditionalCameraData universalAdditionalCameraData = camera.GetUniversalAdditionalCameraData();
universalAdditionalCameraData.renderType = CameraRenderType.Overlay;
Camera.main.GetUniversalAdditionalCameraData().cameraStack.Add(camera);
DontDestroyOnLoad(cameraObject);
#endregion
cameraObject.AddComponent <StageCamera>();
return(camera);
}
private void SetPostProcessing()
{
//Post processing can be disabled entirely if there are no AA or effects enabled
UniversalAdditionalCameraData universalCameraData = CameraModeChanger.Instance.ActiveCamera.GetComponent <UniversalAdditionalCameraData>();
universalCameraData.renderPostProcessing = (antiAliasing || postEffects);
}
void Start()
{
m_camData = GetComponent <UniversalAdditionalCameraData>();
if (m_camData == null)
{
Debug.LogError("m_camData == null");
enabled = false;
return;
}
//ShaderVariantCollection svc = Resources.Load<ShaderVariantCollection>("TestSVC");
//if (svc == null)
//{
// enabled = false;
// return;
//}
//svc.WarmUp();
//Shader.WarmupAllShaders();
m_labelStyle = new GUIStyle();
m_labelStyle.fontSize = 22;
m_labelStyle.normal.textColor = Color.black;
}
void Awake()
{
UIStateManager.stateChanged += OnStateDataChanged;
UIStateManager.arStateChanged += OnARStateDataChanged;
m_MARSCamera = Camera.main.GetComponent <MARS.MARSCamera>();
#if URP_AVAILABLE
m_CameraData = Camera.main.GetComponent <UniversalAdditionalCameraData>();
#endif
m_InputActionAsset["Placement Rotate Action"].performed += OnPlacementRotateAction;
m_InputActionAsset["Placement Scale Action"].started += OnPlacementScaleActionStarted;
m_InputActionAsset["Placement Scale Action"].performed += OnPlacementScaleAction;
m_ScaleValues = Enum.GetValues(typeof(ArchitectureScale));
foreach (var obj in InstructionUIList)
{
var instructionUI = obj as IInstructionUI;
instructionUI.Initialize(this);
}
m_InitialNearClippingPlane = m_MARSCamera.GetComponent <Camera>().nearClipPlane;
m_InitialFarClippingPlane = m_MARSCamera.GetComponent <Camera>().farClipPlane;
}
void Start()
{
mainCameraURP = mainCamera.GetComponent <UniversalAdditionalCameraData>();
ppCameraURP = ppCamera.GetComponent <UniversalAdditionalCameraData>();
sniffingMode = false;
GetImportantItems();
}
void DrawPostProcessingOverlay()
{
bool hasChanged = false;
bool selectedRenderPostProcessing;
if (m_AdditionalCameraDataSO == null)
{
selectedRenderPostProcessing = false;
}
else
{
m_AdditionalCameraDataSO.Update();
selectedRenderPostProcessing = m_AdditionalCameraDataRenderPostProcessing.boolValue;
}
hasChanged |= DrawToggle(m_AdditionalCameraDataRenderPostProcessing, ref selectedRenderPostProcessing, Styles.renderPostProcessing);
if (hasChanged)
{
if (m_AdditionalCameraDataSO == null)
{
m_AdditionalCameraData = Undo.AddComponent <UniversalAdditionalCameraData>(camera.gameObject);
init(m_AdditionalCameraData);
}
m_AdditionalCameraDataRenderPostProcessing.boolValue = selectedRenderPostProcessing;
m_AdditionalCameraDataSO.ApplyModifiedProperties();
}
}
void DrawVolumes()
{
bool hasChanged = false;
LayerMask selectedVolumeLayerMask;
Transform selectedVolumeTrigger;
if (m_AdditionalCameraDataSO == null)
{
selectedVolumeLayerMask = 1; // "Default"
selectedVolumeTrigger = null;
}
else
{
m_AdditionalCameraDataSO.Update();
selectedVolumeLayerMask = m_AdditionalCameraDataVolumeLayerMask.intValue;
selectedVolumeTrigger = (Transform)m_AdditionalCameraDataVolumeTrigger.objectReferenceValue;
}
hasChanged |= DrawLayerMask(m_AdditionalCameraDataVolumeLayerMask, ref selectedVolumeLayerMask, Styles.volumeLayerMask);
hasChanged |= DrawObjectField(m_AdditionalCameraDataVolumeTrigger, ref selectedVolumeTrigger, Styles.volumeTrigger);
if (hasChanged)
{
if (m_AdditionalCameraDataSO == null)
{
m_AdditionalCameraData = Undo.AddComponent <UniversalAdditionalCameraData>(camera.gameObject);
init(m_AdditionalCameraData);
}
m_AdditionalCameraDataVolumeLayerMask.intValue = selectedVolumeLayerMask;
m_AdditionalCameraDataVolumeTrigger.objectReferenceValue = selectedVolumeTrigger;
m_AdditionalCameraDataSO.ApplyModifiedProperties();
}
}
UniversalAdditionalCameraData GetCameraData()
{
PixelPerfectCamera obj = target as PixelPerfectCamera;
UniversalAdditionalCameraData cameraData = null;
obj?.TryGetComponent(out cameraData);
return(cameraData);
}
private void Start()
{
_camera = GetComponent <Camera>();
_nearDefault = _camera.nearClipPlane;
_cameraData = GetComponent <UniversalAdditionalCameraData>();
// Controller im GameManager speichern
GameManager.Instance.CameraController = this;
}
private void Init()
{
mainCam = Camera.main;
camData = cam.GetComponent <UniversalAdditionalCameraData>();
camData.cameraOutput = CameraOutput.Texture;
cam.targetTexture = camRenderTexture;
travellers = new List <TravelEntity>();
}
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 = PipelineUtilities.GetRenderer((DrawGrassBenders.AssetName));
}
PipelineUtilities.ValidatePipelineRenderers(bendRenderer);
#endif
PipelineUtilities.AssignRendererToCamera(camData, bendRenderer);
}
else
{
Debug.LogError("[StylizedGrassRenderer] No Universal Render Pipeline is currently active.");
}
#endif
return(cam);
}
private void Start()
{
cameraToChange = GetComponent <Camera>();
cameraData = GetComponent <UniversalAdditionalCameraData>();
GameSettings.SettingsUpdated += UpdateSettings;
UpdateSettings();
}
void Awake()
{
UIStateManager.stateChanged += OnStateDataChanged;
UIStateManager.arStateChanged += OnARStateDataChanged;
m_MARSCamera = Camera.main.GetComponent <MARSCamera>();
m_CameraData = Camera.main.GetComponent <UniversalAdditionalCameraData>();
m_InputActionAsset["Placement Rotate Action"].performed += OnPlacementRotateAction;
}
protected override void PrepareCamera(Camera renderCamera)
{
base.PrepareCamera(renderCamera);
UniversalAdditionalCameraData cameraData = renderCamera.gameObject.AddComponent <UniversalAdditionalCameraData>();
cameraData.renderShadows = false;
cameraData.SetRenderer(1);
}
public new void OnEnable()
{
m_UniversalRenderPipeline = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
m_AdditionalCameraData = camera.gameObject.GetComponent <UniversalAdditionalCameraData>();
settings.OnEnable();
init(m_AdditionalCameraData);
UpdateAnimationValues(true);
}
public void RequiresDepthTexture(Camera camera, bool value)
{
UniversalAdditionalCameraData cameraData = camera.GetComponent <UniversalAdditionalCameraData>();
if (cameraData == null)
{
cameraData = camera.gameObject.AddComponent <UniversalAdditionalCameraData>();
}
cameraData.requiresDepthTexture = value;
}
public bool IsPostProcessingEnabled(Camera camera)
{
UniversalAdditionalCameraData cameraData = camera.GetComponent <UniversalAdditionalCameraData>();
if (cameraData == null)
{
return(false);
}
return(cameraData.renderPostProcessing);
}
public static void SetupRenderer(GrassColorMapRenderer renderer)
{
if (!renderer.renderCam)
{
renderer.renderCam = new GameObject().AddComponent <Camera>();
}
renderer.renderCam.name = "Grass color map renderCam";
renderer.renderCam.enabled = false;
//Camera set up
renderer.renderCam.orthographic = true;
renderer.renderCam.orthographicSize = (renderer.colorMap.bounds.size.x / 2);
renderer.renderCam.farClipPlane = renderer.colorMap.bounds.size.y + CLIP_PADDING;
renderer.renderCam.clearFlags = CameraClearFlags.Color;
renderer.renderCam.backgroundColor = Color.red;
renderer.renderCam.cullingMask = renderer.useLayers ? (int)renderer.renderLayer : -1;
//Position cam in given center of terrain(s)
renderer.renderCam.transform.position = new Vector3(
renderer.colorMap.bounds.center.x,
renderer.colorMap.bounds.center.y + renderer.colorMap.bounds.extents.y + CLIP_PADDING + (renderer.useLayers ? 0f : HEIGHT_OFFSET),
renderer.colorMap.bounds.center.z
);
renderer.renderCam.transform.localEulerAngles = new Vector3(90, 0, 0);
#if URP
UniversalAdditionalCameraData camData = renderer.renderCam.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 (!renderer.renderData)
{
renderer.renderData = PipelineUtilities.GetRenderer(("ColormapRenderer"));
}
#endif
PipelineUtilities.ValidatePipelineRenderers(renderer.renderData);
PipelineUtilities.AssignRendererToCamera(camData, renderer.renderData);
}
else
{
Debug.LogError("[StylizedGrassRenderer] No Universal Render Pipeline is currently active.");
}
#endif
}
private void InitCamera()
{
UniversalAdditionalCameraData camData = camera.gameObject.AddMissingComponent <UniversalAdditionalCameraData>();
camData.renderType = CameraRenderType.Overlay;
UniversalAdditionalCameraData mainCamData = Camera.main.gameObject.AddMissingComponent <UniversalAdditionalCameraData>();
//Debug.Log("mainCamData=" + mainCamData);
//Debug.Log("mainCamData.cameraStack=" + mainCamData.cameraStack);
mainCamData.cameraStack.Add(camera);
}
private void OnValidate()
{
if (!renderCam)
{
renderCam = GetComponent <Camera>();
}
if (!renderCamData)
{
renderCamData = GetComponent <UniversalAdditionalCameraData>();
}
}
void Start()
{
bool _Use;
m_镜头设置 = GameObject.FindObjectOfType <UniversalAdditionalCameraData> ();
_Use = 通用计算.存档_Getbool(_标记 + DrawShadows.ToString());
DrawShadows.onValueChanged.AddListener(
delegate {
SetDrawShadows(DrawShadows.isOn);
}
);
}
// Start is called before the first frame update
void Start()
{
camData = camera.gameObject.GetComponent <UniversalAdditionalCameraData>();
SetDayFOV();
mesh = new Mesh();
GetComponent <MeshFilter>().mesh = mesh;
black.SetActive(false);
isNightTime = false;
origin = Vector3.zero;
}
protected override void OnAwake()
{
Mode = ModeType.TX_THREAD;
cmdBuffer = new CommandBuffer();
camSensor = gameObject.AddComponent <UnityEngine.Camera>();
universalCamData = camSensor.GetUniversalAdditionalCameraData();
// for controlling targetDisplay
camSensor.targetDisplay = -1;
camSensor.stereoTargetEye = StereoTargetEyeMask.None;
cameraLink = transform.parent;
}
private void InjectOverlayCameras(UniversalAdditionalCameraData camData)
{
foreach (Camera overlayCam in overlayCams)
{
if (overlayCam != null)
{
if (!camData.cameraStack.Contains(overlayCam))
{
camData.cameraStack.Add(overlayCam);
}
}
}
}
public void ToggleShadows(bool state)
{
foreach (var kvp in reflectionCameras)
{
if (kvp.Value == null)
{
continue;
}
cameraData = kvp.Value.GetComponent <UniversalAdditionalCameraData>();
cameraData.renderShadows = state;
}
}
private void Start()
{
if (OverlayCamera == default)
{
return;
}
if (OverlayCamera.GetUniversalAdditionalCameraData().renderType != CameraRenderType.Overlay && !OverwriteRenderType)
{
Debug.LogWarning($"Camera component in {OverlayCamera.gameObject.name} does not seems to be Overlay Camera. Set 'Overlay' to RenderType field.");
return;
}
var originalCameraStack = new List <Camera>();
if (OverlayCamera.GetUniversalAdditionalCameraData().renderType == CameraRenderType.Base)
{
originalCameraStack = OverlayCamera.GetUniversalAdditionalCameraData().cameraStack?.ToList();
OverlayCamera.GetUniversalAdditionalCameraData().cameraStack?.Clear();
}
OverlayCamera.GetUniversalAdditionalCameraData().renderType = CameraRenderType.Overlay;
OverlayCamera.depth = priority;
TargetCameraData = FindObjectsOfType <Camera>()
.Select(x => (x.depth, data: x.GetUniversalAdditionalCameraData()))
.Where(x => x.data.renderType == CameraRenderType.Base)
.OrderByDescending(x => x.depth)
.FirstOrDefault()
.data;
if (TargetCameraData == default)
{
return;
}
var cameraStack = TargetCameraData.cameraStack.ToList();
cameraStack.Add(OverlayCamera);
if (originalCameraStack != default && originalCameraStack.Any())
{
cameraStack.AddRange(originalCameraStack);
}
TargetCameraData.cameraStack.Clear();
foreach (var c in cameraStack.OrderBy(x => x.depth))
{
TargetCameraData.cameraStack.Add(c);
}
}
void Awake()
{
camera = Camera.main;
universalAdditionalCameraData = camera.GetComponent <UniversalAdditionalCameraData>();
AntialiasingModeChange(AntialiasingMode.None); // AntialiasingMode None
Dithering(false); //Dithering Off
volume = GetComponent <Volume>();
profile = volume.profile;
effectChanger = GetComponent <EffectChanger>();
// TryGet effect profile
profile.TryGet(out bloom);
profile.TryGet(out channelMixer);
profile.TryGet(out chromaticAberration);
profile.TryGet(out colorAdjustments);
profile.TryGet(out colorCurves);
profile.TryGet(out colorLookup);
profile.TryGet(out depthOfField);
profile.TryGet(out filmGrain);
profile.TryGet(out lensDistortion);
profile.TryGet(out liftGammaGain);
profile.TryGet(out motionBlur);
profile.TryGet(out paniniProjection);
profile.TryGet(out shadowsMidtonesHighlights);
profile.TryGet(out splitToning);
profile.TryGet(out tonemapping);
profile.TryGet(out vignette);
profile.TryGet(out whiteBalance);
// All effects disabled
bloom.active =
channelMixer.active =
chromaticAberration.active =
colorAdjustments.active =
colorCurves.active =
colorLookup.active =
depthOfField.active =
filmGrain.active =
lensDistortion.active =
liftGammaGain.active =
motionBlur.active =
paniniProjection.active =
shadowsMidtonesHighlights.active =
splitToning.active =
tonemapping.active =
vignette.active =
whiteBalance.active =
false;
}
