// Start is called before the first frame update
void Start()
{
mCamera = GetComponent <Camera>();
mScale = slider.value;
ScalableBufferManager.ResizeBuffers(mScale, mScale);
slider.onValueChanged.AddListener(OnScaleChanged);
}
public void WriteBack()
{
if (isDirty)
{
ScalableBufferManager.ResizeBuffers(widthScaleFactor, heightScaleFactor);
}
}
/// <summary>
/// Callback for any level change
/// </summary>
protected override void OnLevel()
{
float oldScaleFactor = Scale;
float scaleIncrement = (MaxBound - MinBound) / MaxLevel;
Scale = scaleIncrement * (MaxLevel - CurrentLevel) + MinBound;
// if Gfx API does not support Dynamic resolution, currentCamera.allowDynamicResolution will be false
if (IsDynamicResolutionSupported())
{
if (Scale != oldScaleFactor)
{
ScalableBufferManager.ResizeBuffers(Scale, Scale);
}
int rezWidth = (int)Mathf.Ceil(ScalableBufferManager.widthScaleFactor * Screen.currentResolution.width);
int rezHeight = (int)Mathf.Ceil(ScalableBufferManager.heightScaleFactor * Screen.currentResolution.height);
APLog.Debug(
$"Adaptive Resolution Scale: {Scale:F3} Resolution: {rezWidth}x{rezHeight} ScaleFactor: {ScalableBufferManager.widthScaleFactor:F3}x{ScalableBufferManager.heightScaleFactor:F3} Level:{CurrentLevel}/{MaxLevel}");
}
else
{
AdaptivePerformanceRenderSettings.RenderScaleMultiplier = Scale;
APLog.Debug($"Dynamic resolution is not supported. Using fallback to Render Scale Multiplier : {Scale:F3}");
// TODO: warn if unsupported render pipeline is used
//Debug.Log("You might not use a supported Render Pipeline. Currently only Universal Render Pipeline and Built-in are supported by Adaptive Resolution.");
}
}
void UpdateCamera()
{
if (m_camera)
{
ScalableBufferManager.ResizeBuffers(scale, scale);
}
}
void OnScaleChanged(float scale)
{
if (Mathf.Abs(scale - mScale) > ESP)
{
mScale = scale;
ScalableBufferManager.ResizeBuffers(mScale, mScale);
}
}
/// <summary>
/// Update the state of the dynamic resolution system.
/// </summary>
/// <param name="settings">The settings that are to be used by the dynamic resolution system.</param>
/// <param name="OnResolutionChange">An action that will be called every time the dynamic resolution system triggers a change in resolution.</param>
public void Update(GlobalDynamicResolutionSettings settings, Action OnResolutionChange = null)
{
ProcessSettings(settings);
if (!m_Enabled)
{
return;
}
if (!m_ForcingRes)
{
if (m_ScalerType == DynamicResScalePolicyType.ReturnsMinMaxLerpFactor)
{
float currLerp = m_DynamicResMethod();
float lerpFactor = Mathf.Clamp(currLerp, 0.0f, 1.0f);
m_CurrentFraction = Mathf.Lerp(m_MinScreenFraction, m_MaxScreenFraction, lerpFactor);
}
else if (m_ScalerType == DynamicResScalePolicyType.ReturnsPercentage)
{
float percentageRequested = Mathf.Max(m_DynamicResMethod(), 5.0f);
m_CurrentFraction = Mathf.Clamp(percentageRequested / 100.0f, m_MinScreenFraction, m_MaxScreenFraction);
}
}
if (m_CurrentFraction != m_PrevFraction)
{
m_PrevFraction = m_CurrentFraction;
if (!m_ForceSoftwareFallback && type == DynamicResolutionType.Hardware)
{
ScalableBufferManager.ResizeBuffers(m_CurrentFraction, m_CurrentFraction);
}
if (OnResolutionChange != null)
{
OnResolutionChange();
}
}
else
{
// Unity can change the scale factor by itself so we need to trigger the Action if that happens as well.
if (!m_ForceSoftwareFallback && type == DynamicResolutionType.Hardware)
{
if (ScalableBufferManager.widthScaleFactor != m_PrevHWScaleWidth ||
ScalableBufferManager.heightScaleFactor != m_PrevHWScaleHeight)
{
if (OnResolutionChange != null)
{
OnResolutionChange();
}
}
}
}
m_PrevHWScaleWidth = ScalableBufferManager.widthScaleFactor;
m_PrevHWScaleHeight = ScalableBufferManager.heightScaleFactor;
}
public void OnSliderChange()
{
m_sliderValue = slider.value;
m_heightScale = Mathf.Max(minResolutionHeightScale, m_sliderValue);
m_widthScale = Mathf.Max(minResolutionWidthScale, m_sliderValue);
ScalableBufferManager.ResizeBuffers(m_widthScale, m_heightScale);
}
void Update()
{
// Dynamic resolution
if (_currentResolutionScale != _resolutionScale)
{
ScalableBufferManager.ResizeBuffers(_resolutionScale, _resolutionScale);
_currentResolutionScale = _resolutionScale;
}
}
private void Start()
{
var cameras = FindObjectsOfType <Camera>();
foreach (var camera in cameras)
{
camera.allowDynamicResolution = true;
}
ScalableBufferManager.ResizeBuffers(scale, scale);
}
private bool FlushScalableBufferManagerState()
{
if (s_GlobalHwUpresActive == HardwareDynamicResIsEnabled() && s_GlobalHwFraction == m_CurrentFraction)
{
return(false);
}
s_GlobalHwUpresActive = HardwareDynamicResIsEnabled();
s_GlobalHwFraction = m_CurrentFraction;
ScalableBufferManager.ResizeBuffers(s_GlobalHwFraction, s_GlobalHwFraction);
return(true);
}
void Update()
{
if (_isUpdateScalableBuffer)
{
if (_updateScale > 1.0f)
{
_updateScale = 0.01f;
}
ScalableBufferManager.ResizeBuffers(_updateScale, _updateScale);
_updateScale += 0.01f;
}
}
private void OnDestroy()
{
--instanceCount;
if (Scale == 1.0f)
{
return;
}
APLog.Debug("Restoring dynamic resolution scale factor to 1.0");
if (IsDynamicResolutionSupported())
{
ScalableBufferManager.ResizeBuffers(1.0f, 1.0f);
}
else
{
AdaptivePerformanceRenderSettings.RenderScaleMultiplier = 1.0f;
}
}
private void Update()
{
if (!MainCamera)
{
return;
}
if (variableResolution)
{
MainCamera.allowDynamicResolution = true;
var offset = 0f;
var currentFrametime = Time.deltaTime;
var rate = 0.1f;
switch (targetFramerate)
{
case Framerate._30:
offset = currentFrametime > (1000f / 30f) ? -rate : rate;
break;
case Framerate._60:
offset = currentFrametime > (1000f / 60f) ? -rate : rate;
break;
case Framerate._120:
offset = currentFrametime > (1000f / 120f) ? -rate : rate;
break;
}
currentDynamicScale = Mathf.Clamp(currentDynamicScale + offset, minScale, 1f);
var offsetVec = new Vector2(Mathf.Lerp(1, currentDynamicScale, Mathf.Clamp01((1 - axisBias) * 2f)),
Mathf.Lerp(1, currentDynamicScale, Mathf.Clamp01(axisBias * 2f)));
ScalableBufferManager.ResizeBuffers(offsetVec.x, offsetVec.y);
}
else
{
MainCamera.allowDynamicResolution = false;
}
}
public static int ResizeBuffers_s(IntPtr l)
{
int result;
try
{
float widthScale;
LuaObject.checkType(l, 1, out widthScale);
float heightScale;
LuaObject.checkType(l, 2, out heightScale);
ScalableBufferManager.ResizeBuffers(widthScale, heightScale);
LuaObject.pushValue(l, true);
result = 1;
}
catch (Exception e)
{
result = LuaObject.error(l, e);
}
return(result);
}
private void Update()
{
#if !UNITY_EDITOR
Utility.CheckQualityLevel(); //TODO - hoping to remove one day when we have a quality level callback
#endif
if (!MainCamera)
{
return;
}
if (variableResolution)
{
MainCamera.allowDynamicResolution = true;
var offset = 0f;
var currentFrametime = Time.deltaTime;
const float rate = 0.1f;
offset = targetFramerate switch
{
Framerate._30 => currentFrametime > (1000f / 30f) ? -rate : rate,
Framerate._60 => currentFrametime > (1000f / 60f) ? -rate : rate,
Framerate._120 => currentFrametime > (1000f / 120f) ? -rate : rate,
_ => offset
};
currentDynamicScale = Mathf.Clamp(currentDynamicScale + offset, minScale, 1f);
var offsetVec = new Vector2(Mathf.Lerp(1, currentDynamicScale, Mathf.Clamp01((1 - axisBias) * 2f)),
Mathf.Lerp(1, currentDynamicScale, Mathf.Clamp01(axisBias * 2f)));
ScalableBufferManager.ResizeBuffers(offsetVec.x, offsetVec.y);
}
else
{
MainCamera.allowDynamicResolution = false;
}
}
// Update is called once per frame
private void Update()
{
float oldWidthScale = m_WidthScale;
float oldHeightScale = m_HeightScale;
if (Input.GetKeyDown(KeyCode.A))
{
m_WidthScale = Mathf.Max(m_ResolutionWidthScaleMin, m_WidthScale - m_ResolutionWidthScaleIncrement);
m_HeightScale = Mathf.Max(m_ResolutionHeightScaleMin, m_HeightScale - m_ResolutionHeightScaleIncrement);
}
if (Input.GetKeyDown(KeyCode.B))
{
m_WidthScale = Mathf.Min(m_ResolutionWidthScaleMax, m_WidthScale + m_ResolutionWidthScaleIncrement);
m_HeightScale = Mathf.Min(m_ResolutionHeightScaleMax, m_HeightScale + m_ResolutionHeightScaleIncrement);
}
if (oldWidthScale != m_WidthScale || oldHeightScale != m_HeightScale)
{
ScalableBufferManager.ResizeBuffers(m_WidthScale, m_HeightScale);
}
DetermineResolution();
int width = (int)Mathf.Ceil(ScalableBufferManager.widthScaleFactor * Screen.currentResolution.width);
int height = (int)Mathf.Ceil(ScalableBufferManager.heightScaleFactor * Screen.currentResolution.height);
m_TextScreen.text = string.Format("Scale : {0:F3}x{1:F3}\nResolution : {2}x{3}\n", m_WidthScale, m_HeightScale, width, height);
m_TextScreen.text = string.Format("Scale: {0:F3}x{1:F3}\nResolution: {2}x{3}\nScaleFactor: {4:F3}x{5:F3}\nGPU: {6:F3} CPU: {7:F3}",
m_WidthScale,
m_HeightScale,
width,
height,
ScalableBufferManager.widthScaleFactor,
ScalableBufferManager.heightScaleFactor,
m_FrameTimeGPU,
m_FrameTimeCPU);
}
// Update is called once per frame
void Update()
{
float newScale = (4f - SaveSystem.SaveObject.SettingsData.ResolutionScaling) / 4.0f;
if (currentScale != newScale)
{
currentScale = newScale;
ScalableBufferManager.ResizeBuffers(newScale, newScale);
}
switch (SaveSystem.SaveObject.SettingsData.AntiAliasing)
{
case 0:
layer.antialiasingMode = PostProcessLayer.Antialiasing.None;
break;
case 1:
layer.antialiasingMode = PostProcessLayer.Antialiasing.FastApproximateAntialiasing;
break;
case 2:
layer.antialiasingMode = PostProcessLayer.Antialiasing.TemporalAntialiasing;
break;
default:
break;
}
if (SaveSystem.SaveObject.SettingsData.AntiAliasing != 0 || SaveSystem.SaveObject.SettingsData.LensBlur != 0 || SaveSystem.SaveObject.SettingsData.AmbientOcclusion != 0 || SaveSystem.SaveObject.SettingsData.MotionBlur != 0 || SaveSystem.SaveObject.SettingsData.ChromaticAberration != 0)
{
layer.enabled = true;
}
else
{
layer.enabled = false;
}
}
void OnDisable()
{
// Reset buffer scale. This persists enter/exit play mode.
ScalableBufferManager.ResizeBuffers(1, 1);
}
//註解：說明
//按鈕如何和程式溝通
//需要方法（函式、功能）-一堆有功能的程式、演算法
//語法：
//修飾詞 類型 方法名稱 () {}
//私人 private（預設）- 不可被按鈕器呼叫
//公開 public - 可被按鈕器呼叫
//void 無類型
void StarGame()
{
print("開始遊戲"); //輸出（訊息）- 文字要加雙引號，儀表板 Console
ScalableBufferManager.LoadScene("關卡1") //場景管理.載入場景("名稱")
//ScalableBufferManager.LoadScene(1) //場景管理.載入場景(編號)
}
private void ChangeResolution(float val)
{
val = Mathf.Clamp(val, 0.01f, 1.0f);
ScalableBufferManager.ResizeBuffers(val, val);
}
public void OnValueChangeHeight(float value)
{
heightScale = value;
ScalableBufferManager.ResizeBuffers(widthScale, heightScale);
}
// ResizeBufferしてRenderTextureの更新
void ResizeBuffers(float scale)
{
ScalableBufferManager.ResizeBuffers(scale, scale);
Blit();
}
private void OnDestroy()
{
ScalableBufferManager.ResizeBuffers(1, 1);
}
