Files
UmaViewer/Assets/Scripts/umamusume/Gallop/RenderPipeline/PostImageEffectFeature.cs
T

740 lines
30 KiB
C#

using System;
using System.Collections.Generic;
using System.Reflection;
using Gallop.ImageEffect;
using Gallop.Live;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
namespace Gallop.RenderPipeline
{
/// <summary>
/// Recovered SourceSetup -> Dof/Diffusion/Bloom/Overlay -> RadialBlur -> SimpleColorCorrection -> FinalBlit chain.
/// Other reference passes are not implemented by this feature yet.
/// </summary>
public class PostImageEffectFeature : ScriptableRendererFeature
{
private const int INVALID_NAME_ID = -2;
private const int REGISTER_PASS_SIZE = 12;
private const string SOURCE_SETUP_POOL_NAME =
"PostImageEffectFeature.SourceSetup";
private const string FINAL_BLIT_POOL_NAME =
"PostImageEffectFeature.FinalBlit";
// 只保留 DofDiffusionBloomOverlayPass 实际需要的 Pass。
private SourceSetupPass _sourceSetupPass;
private DofDiffusionBloomOverlayPass
_dofDiffusionBloomOverlayPass;
private FinalBlitPass _finalBlitPass;
private RadialBlurPass _radialBlurPass;
private SimpleColorCorrectionPass _colorCorrectionPass;
private FinalBlitPass _colorEarlyResolvePass;
private ExposureToneCurvePass _exposurePass, _toneCurvePass;
private SunShaftsPass _sunShaftsPass;
private IndirectLightShaftsPass _indirectLightShaftsPass;
private MultiCameraCompositePass _multiCameraCompositePass;
private MultiCameraFinalCompositePass _multiCameraFinalCompositePass;
private ProjectorRenderPass _projectorPass;
private RenderTextureHandle _sourceRT;
private List<ScriptableRenderPass> _registerPass;
private bool _loggedEnqueue;
private bool _loggedParameterMissing;
private bool _loggedParameterDisabled;
private bool _loggedSetupFailed;
private bool _loggedBypass;
private bool _shaderLoadRequested;
private float _nextShaderLoadAttempt;
// Missing shader resources cause Setup to fail without replacing camera color.
// Disable this switch for an unprocessed A/B baseline.
[SerializeField]
private bool _enableRendering = true;
// Unlike SetActive, this leaves the mandatory multi-camera composition passes scheduled.
public bool EnableRendering
{
get => _enableRendering;
set => _enableRendering = value;
}
// Active-camera publication alias, not storage shared by every camera.
// GallopImageEffect / MultiCamera retain their own CameraData parameters.
private static Parameter _runtimeParameter = new Parameter();
public static Parameter RuntimeParameter
{
get
{
if (_runtimeParameter == null)
_runtimeParameter = new Parameter();
return _runtimeParameter;
}
internal set => _runtimeParameter = value;
}
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
public static void ResetRuntimeParameter()
{
_runtimeParameter = new Parameter();
}
public RenderTextureHandle SourceRT
{
get { return _sourceRT; }
}
// Pure scheduling policy, shared with regression tests. URP performs the stable
// event sort; this does not change the existing DOF pass or its late camera writes.
public struct ColorChainSchedule
{
public int FirstEvent, LastEvent;
public bool EarlyResolve, FinalResolve;
}
public static ColorChainSchedule GetColorChainSchedule(bool dof, bool radial, bool color, RenderPassEvent effectEvent)
{
bool existing = dof || radial;
int first = existing ? (int)effectEvent : 550;
int last = first;
if (color) { first = System.Math.Min(first, 550); last = System.Math.Max(last, 550); }
return new ColorChainSchedule {
FirstEvent = first, LastEvent = last,
EarlyResolve = color && existing && (int)effectEvent > 550,
FinalResolve = radial || (color && (!existing || (int)effectEvent <= 550)) ||
(existing && (int)effectEvent <= 550)
};
}
public override void Create()
{
Dispose();
_loggedEnqueue = false;
_loggedParameterMissing = false;
_loggedParameterDisabled = false;
_loggedSetupFailed = false;
_loggedBypass = false;
_shaderLoadRequested = false;
_nextShaderLoadAttempt = 0f;
RenderPassEvent passEvent =
RenderPassEvent.BeforeRenderingPostProcessing;
_sourceSetupPass = new SourceSetupPass(this, passEvent);
_dofDiffusionBloomOverlayPass = new DofDiffusionBloomOverlayPass(passEvent);
_finalBlitPass = new FinalBlitPass(this, passEvent);
_radialBlurPass = new RadialBlurPass(passEvent);
_colorCorrectionPass = new SimpleColorCorrectionPass();
_colorEarlyResolvePass = new FinalBlitPass(this, passEvent, "ColorEarlyResolve");
_exposurePass = new ExposureToneCurvePass(false);
_toneCurvePass = new ExposureToneCurvePass(true);
_sunShaftsPass = new SunShaftsPass(passEvent);
_indirectLightShaftsPass = new IndirectLightShaftsPass(passEvent);
_multiCameraCompositePass = new MultiCameraCompositePass();
_multiCameraFinalCompositePass = new MultiCameraFinalCompositePass();
_projectorPass = new ProjectorRenderPass();
_registerPass = new List<ScriptableRenderPass>(REGISTER_PASS_SIZE);
_sourceRT = RenderTextureHandle.Make(new RenderTargetIdentifier(INVALID_NAME_ID), 0, 0);
Debug.Log($"[RecoveredPostEffect] Create enabled={_enableRendering} " +
$"shaderReady={ShaderManager.IsShaderBundleReady}");
// 让 Dof Pass 直接使用同一套 CameraData 参数解析逻辑。
DofDiffusionBloomOverlayPass.FeatureParameterResolver = ResolveFeatureParameter;
}
public override void AddRenderPasses( ScriptableRenderer renderer, ref RenderingData renderingData)
{
Camera camera = renderingData.cameraData.camera;
if (camera == null)
return;
var director = Gallop.Live.Director.instance;
// Native ProjectorFeature draws stage projectors after opaque geometry,
// independently of presentation-camera post-processing (including reflection/monitor views).
if (Application.isPlaying && camera.cameraType == CameraType.Game && director != null &&
_projectorPass != null && _projectorPass.Setup(director.LightProjectors, director.MirrorBallProjectors))
{
renderer.EnqueuePass(_projectorPass);
}
if (string.Equals(camera.name, "MonitorCameraCapture", StringComparison.Ordinal))
return;
// The timeline parameter is authored for the Live presentation
// cameras. Reflection/monitor cameras use different render targets
// and depth ranges; running the same multi-RT DOF/Bloom chain on
// them corrupts the reflection texture and can leak black holes or
// a white veil into the main frame.
// [REPORT §10.3-B1/§4.2] 原生按相机组逐台注册后处理(RegisterPass 走
// camera stack,覆盖演示相机组),master7 原以 camera != MainRenderCamera
// 的引用相等做门控:CameraSwitcher 切换瞬间旧相机当帧不注册、新相机
// 重走 Setup/SourceRT 重建链,切换帧丢失一次后处理输出。改为对
// Director 的演示相机组做成员判定(IsPresentationCamera),同帧内
// 组内每台相机都注册整链,消除切换窗口。非 Game 类型和
// MonitorCameraCapture 的跳过保持不变(与原生名字跳过一致)。
if (!Application.isPlaying || camera.cameraType != CameraType.Game || director == null)
return;
camera.TryGetComponent<MultiCamera>(out var multiCamera);
if (multiCamera == null && !director.IsPresentationCamera(camera)) return;
// Native composition runs even when the optional image-effect chain is disabled.
if (multiCamera != null)
{
if (_multiCameraCompositePass != null && _multiCameraCompositePass.Setup(multiCamera))
renderer.EnqueuePass(_multiCameraCompositePass);
}
else if (camera == director.MainRenderCamera && _multiCameraFinalCompositePass != null &&
_multiCameraFinalCompositePass.Setup(director.MultiCameraFinalComposite))
renderer.EnqueuePass(_multiCameraFinalCompositePass);
bool renderEnabled = _enableRendering;
if (!renderEnabled)
{
if (!_loggedBypass)
{
_loggedBypass = true;
Debug.Log("[RecoveredPostEffect] bypass enabled: camera color is preserved");
}
return;
}
// Renderer features are constructed while the pipeline is being
// deserialized, before UmaViewerMain.Start() has loaded shader.a.
// Request the bundle here as soon as a Live camera actually needs
// the recovered chain. Setup below is retried on subsequent frames
// and will create the materials after the synchronous load lands.
if (!ShaderManager.IsShaderBundleReady &&
Time.realtimeSinceStartup >= _nextShaderLoadAttempt)
{
_nextShaderLoadAttempt = Time.realtimeSinceStartup + 1f;
ShaderManager.LoadShaderBundle();
if (!_shaderLoadRequested)
{
_shaderLoadRequested = true;
Debug.Log("[RecoveredPostEffect] requested shader bundle load from render pass");
}
}
CameraData cameraData;
if (!camera.TryGetComponent(out cameraData))
cameraData = camera.gameObject.AddComponent<CameraData>();
// Bind this camera's owned state before deciding draw type.
// Live auto-disable must never leak through the active-camera alias.
var imageEffect = camera.GetComponent<GallopImageEffect>();
var cameraParameter = multiCamera != null ? multiCamera.PostEffectParameter
: imageEffect != null ? imageEffect.RenderParameter : RuntimeParameter;
cameraData.Parameter = cameraParameter;
cameraParameter.TargetCamera = camera;
cameraData.UpdateImageEffectParameter();
Parameter parameter = ResolveFeatureParameter(cameraData);
if (parameter == null)
{
if (!_loggedParameterMissing)
{
_loggedParameterMissing = true;
Debug.LogWarning($"[RecoveredPostEffect] skip camera={camera.name}: CameraData.Parameter missing");
}
return;
}
if (!parameter.IsEnable)
{
if (!_loggedParameterDisabled)
{
_loggedParameterDisabled = true;
Debug.Log($"[RecoveredPostEffect] skip camera={camera.name}: feature parameter disabled");
}
return;
}
if (_registerPass == null)
{
_registerPass = new List<ScriptableRenderPass>(REGISTER_PASS_SIZE);
}
_registerPass.Clear();
if (_sourceSetupPass == null || _dofDiffusionBloomOverlayPass == null || _finalBlitPass == null)
{
return;
}
bool dofReady = _dofDiffusionBloomOverlayPass.Setup(cameraData, this);
bool radialReady = _radialBlurPass != null && _radialBlurPass.Setup(parameter.RadialBlur, this);
bool colorReady = _colorCorrectionPass != null && _colorCorrectionPass.Setup(parameter.ColorCorrection, this);
bool exposureReady = _exposurePass != null && _exposurePass.Setup(parameter.ExposureParam, parameter.ToneCurveParam, this);
bool toneReady = _toneCurvePass != null && _toneCurvePass.Setup(parameter.ExposureParam, parameter.ToneCurveParam, this);
bool sunReady = _sunShaftsPass != null && _sunShaftsPass.Setup(parameter.SunShafts, this);
bool shaftsReady = _indirectLightShaftsPass != null && _indirectLightShaftsPass.Setup(parameter.LightShafts, this);
bool correctionReady = colorReady || exposureReady || toneReady;
if (!dofReady && !radialReady && !correctionReady && !sunReady && !shaftsReady)
{
if (!_loggedSetupFailed)
{
_loggedSetupFailed = true;
Debug.LogWarning($"[RecoveredPostEffect] setup failed camera={camera.name} " +
$"type={parameter.DofDiffuionBloomOverlay.UseDofDiffusionBloomType} " +
$"shaderReady={ShaderManager.IsShaderBundleReady}");
}
return;
}
if (!_loggedEnqueue)
{
_loggedEnqueue = true;
Debug.Log($"[RecoveredPostEffect] enqueue camera={camera.name} " +
$"type={RuntimeParameter.DofDiffuionBloomOverlay.UseDofDiffusionBloomType} " +
$"shaderReady={ShaderManager.IsShaderBundleReady}");
}
// Explicitly request URP depth for CoC; do not rely on another feature
// incidentally producing _CameraDepthTexture. Reset when leaving DOF.
_dofDiffusionBloomOverlayPass.ConfigureInput(parameter.IsUseDepthTexture
? ScriptableRenderPassInput.Depth : ScriptableRenderPassInput.None);
RenderPassEvent effectEvent = parameter.DofDiffuionBloomOverlay.RenderPassEvent;
// Color keeps its native default event550, independent of DOF's event.
var schedule = GetColorChainSchedule(dofReady, radialReady,
correctionReady || sunReady || shaftsReady, effectEvent);
_sourceSetupPass.renderPassEvent = (RenderPassEvent)schedule.FirstEvent;
_finalBlitPass.renderPassEvent = (RenderPassEvent)schedule.LastEvent;
// 同一 RenderPassEvent 下按 Enqueue 顺序执行。
_registerPass.Add(_sourceSetupPass);
if (sunReady) _registerPass.Add(_sunShaftsPass);
if (shaftsReady) _registerPass.Add(_indirectLightShaftsPass);
if (dofReady) _registerPass.Add(_dofDiffusionBloomOverlayPass);
if (radialReady)
{
_radialBlurPass.renderPassEvent = effectEvent;
_radialBlurPass.ConfigureInput(parameter.RadialBlur.IsEnabledDepth
? ScriptableRenderPassInput.Depth : ScriptableRenderPassInput.None);
_registerPass.Add(_radialBlurPass);
}
if (toneReady) _registerPass.Add(_toneCurvePass);
if (exposureReady) _registerPass.Add(_exposurePass);
if (colorReady)
{
_registerPass.Add(_colorCorrectionPass);
}
// All native event550 corrections must resolve before a late DOF draw.
if (schedule.EarlyResolve)
{
_registerPass.Add(_colorEarlyResolvePass);
}
// Radial always hands its temporary result back to this feature.
// DOF alone writes directly to camera color for events after 550.
if (schedule.FinalResolve)
{
_registerPass.Add(_finalBlitPass);
}
for (int i = 0; i < _registerPass.Count; i++)
renderer.EnqueuePass(_registerPass[i]);
// Read-only runtime evidence: this records the actual URP descriptor
// and scheduled pass count without changing the render chain.
LiveRuntimeDiagnostics.RecordRenderPass(
camera, renderingData.cameraData.cameraTargetDescriptor, parameter,
_registerPass.Count, ShaderManager.IsShaderBundleReady,
renderingData.cameraData.postProcessEnabled);
}
/// <summary>
/// 将当前源设置为相机颜色目标
/// 这替代原版SetSourceRTPass对 Dof-only 链路的作用
/// </summary>
public void ResetSourceRT( CommandBuffer cmd, ref RenderingData renderingData)
{
ScriptableRenderer renderer = renderingData.cameraData.renderer;
if (renderer == null)
return;
RTHandle cameraColorHandle = renderer.cameraColorTargetHandle;
if (cameraColorHandle == null)
return;
RenderTargetIdentifier cameraColorTarget = cameraColorHandle.nameID;
RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;
if (cmd != null && !_sourceRT.RtId.Equals(cameraColorTarget) && _sourceRT.NameId != INVALID_NAME_ID)
{
cmd.ReleaseTemporaryRT(_sourceRT.NameId);
}
_sourceRT = RenderTextureHandle.Make( cameraColorTarget, descriptor.width, descriptor.height);
}
/// <summary>
/// DofDiffusionBloomOverlayPass.Execute 在完成后调用此函数,
/// 把输出临时 RT 交回 Feature。
/// </summary>
public void SetSourceRT(RenderTextureHandle sourceHandle, CommandBuffer cmd, ref RenderingData renderingData)
{
if (_sourceRT.NameId == sourceHandle.NameId)
return;
ReleaseCurrentTemporaryRT(cmd, ref renderingData);
_sourceRT = sourceHandle;
}
private void ReleaseCurrentTemporaryRT(CommandBuffer cmd, ref RenderingData renderingData)
{
ScriptableRenderer renderer = renderingData.cameraData.renderer;
if (renderer == null)
return;
RTHandle cameraColorHandle = renderer.cameraColorTargetHandle;
if (cameraColorHandle == null)
return;
RenderTargetIdentifier cameraColorTarget = cameraColorHandle.nameID;
if (!_sourceRT.RtId.Equals(cameraColorTarget) && _sourceRT.NameId != INVALID_NAME_ID && cmd != null)
{
cmd.ReleaseTemporaryRT(_sourceRT.NameId);
}
}
protected override void Dispose(bool disposing)
{
_registerPass = null;
_radialBlurPass?.Dispose();
_radialBlurPass = null;
_colorCorrectionPass?.Dispose();
_colorCorrectionPass = null;
_colorEarlyResolvePass = null;
_exposurePass?.Dispose();
_toneCurvePass?.Dispose();
_exposurePass = _toneCurvePass = null;
_sunShaftsPass?.Dispose();
_indirectLightShaftsPass?.Dispose();
_sunShaftsPass = null;
_indirectLightShaftsPass = null;
_multiCameraCompositePass = null;
_multiCameraFinalCompositePass = null;
if (_dofDiffusionBloomOverlayPass != null)
{
_dofDiffusionBloomOverlayPass.Dispose();
_dofDiffusionBloomOverlayPass = null;
}
_sourceSetupPass = null;
_finalBlitPass = null;
base.Dispose(disposing);
}
/// <summary>
/// CameraData 原生偏移 +0x150 对应的 Parameter 解析。
/// 字段真实名称确定后,可以直接替换为明确字段访问。
/// </summary>
private static Parameter ResolveFeatureParameter(CameraData cameraData)
{
if (cameraData == null)
return null;
object instance = cameraData;
Type type = instance.GetType();
const BindingFlags flags =
BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic;
while (type != null)
{
FieldInfo[] fields = type.GetFields(flags);
for (int i = 0; i < fields.Length; i++)
{
if (typeof(Parameter)
.IsAssignableFrom(fields[i].FieldType))
{
return fields[i].GetValue(instance)
as Parameter;
}
}
PropertyInfo[] properties = type.GetProperties(flags);
for (int i = 0; i < properties.Length; i++)
{
PropertyInfo property = properties[i];
if (!property.CanRead || property.GetIndexParameters().Length != 0)
{
continue;
}
if (!typeof(Parameter)
.IsAssignableFrom(property.PropertyType))
{
continue;
}
try
{
return property.GetValue(instance, null)
as Parameter;
}
catch
{
// 继续搜索基类中的参数字段。
}
}
type = type.BaseType;
}
return null;
}
/// <summary>
/// 在 Dof Pass 前,把 Feature.SourceRT 指向 Camera Color。
/// </summary>
private sealed class SourceSetupPass : ScriptableRenderPass
{
private readonly PostImageEffectFeature _owner;
public SourceSetupPass( PostImageEffectFeature owner, RenderPassEvent passEvent)
{
_owner = owner;
renderPassEvent = passEvent;
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (_owner == null)
return;
CommandBuffer cmd =
CommandBufferPool.Get(SOURCE_SETUP_POOL_NAME);
try
{
_owner.ResetSourceRT(cmd, ref renderingData);
context.ExecuteCommandBuffer(cmd);
LiveRuntimeDiagnostics.RecordRenderExecution(renderingData.cameraData.camera,
"SourceSetup", renderPassEvent, default, _owner.SourceRT);
}
finally
{
CommandBufferPool.Release(cmd);
}
}
}
/// <summary>
/// Dof Pass 在 550 或更早执行时,只更新 Feature.SourceRT。
/// 此 Pass 将结果写回 Camera Color,并释放 Dof 临时 RT。
/// </summary>
private sealed class FinalBlitPass : ScriptableRenderPass
{
private readonly PostImageEffectFeature _owner;
private readonly string _traceStep;
public FinalBlitPass(PostImageEffectFeature owner, RenderPassEvent passEvent, string traceStep = "FinalBlit")
{
_owner = owner;
_traceStep = traceStep;
renderPassEvent = passEvent;
}
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
{
if (_owner == null)
return;
RenderTextureHandle source = _owner.SourceRT;
if (source.NameId == INVALID_NAME_ID)
return;
ScriptableRenderer renderer = renderingData.cameraData.renderer;
if (renderer == null)
return;
RTHandle cameraColorHandle = renderer.cameraColorTargetHandle;
if (cameraColorHandle == null)
return;
RenderTargetIdentifier cameraColorTarget = cameraColorHandle.nameID;
CommandBuffer cmd =
CommandBufferPool.Get(FINAL_BLIT_POOL_NAME);
try
{
if (!source.RtId.Equals(cameraColorTarget))
{
cmd.Blit(
source.RtId,
cameraColorTarget);
}
// Blit 后释放 Dof 输出临时 RT,并把 SourceRT 恢复为 Camera Color
_owner.ResetSourceRT(cmd, ref renderingData);
context.ExecuteCommandBuffer(cmd);
LiveRuntimeDiagnostics.RecordRenderExecution(renderingData.cameraData.camera,
_traceStep, renderPassEvent, source, _owner.SourceRT);
}
finally
{
CommandBufferPool.Release(cmd);
}
}
}
public class Parameter
{
private Camera _targetCamera;
private CameraData _targetCameraData;
public bool IsEnable;
// DofDiffusionBloomOverlayPass 实际使用的参数。
public DofDiffusionBloomOverlayPass.Parameter
DofDiffuionBloomOverlay;
public RadialBlurPass.Parameter RadialBlur = RadialBlurPass.Parameter.Default();
public SimpleColorCorrectionPass.Parameter ColorCorrection;
public SunShaftsPass.Parameter SunShafts = SunShaftsPass.Parameter.Default();
public IndirectLightShaftsPass.Parameter LightShafts;
// Native ToneCurve/Exposure parameter blocks consumed at event550.
public Gallop.ImageEffect.ExposureParam ExposureParam =
new Gallop.ImageEffect.ExposureParam();
public Gallop.ImageEffect.ToneCurveParam ToneCurveParam =
new Gallop.ImageEffect.ToneCurveParam();
public bool IsRequestDepthPass;
public Camera TargetCamera
{
get { return _targetCamera; }
set
{
_targetCamera = value;
DofDiffuionBloomOverlay.TargetCamera = value;
if (_targetCamera == null)
return;
if (!_targetCamera.TryGetComponent(
out _targetCameraData))
{
_targetCameraData = _targetCamera.gameObject.AddComponent<CameraData>();
InvokeCameraDataInitialize( _targetCameraData);
}
}
}
public bool IsUseDepthTexture
{
get
{
// The recovered IsDepthTexture property represents the original
// overlay/depth-request contract, not URP's complete DOF input needs.
var mode = DofDiffuionBloomOverlay.UseDofDiffusionBloomType;
return (RadialBlur.IsValid && RadialBlur.IsEnabledDepth) ||
mode == DofDiffusionBloomOverlayParam.DofDiffusionBloomType.DofBloom ||
mode == DofDiffusionBloomOverlayParam.DofDiffusionBloomType.DiffusionDofBloom ||
mode == DofDiffusionBloomOverlayParam.DofDiffusionBloomType.Dof ||
mode == DofDiffusionBloomOverlayParam.DofDiffusionBloomType.OldDof ||
mode == DofDiffusionBloomOverlayParam.DofDiffusionBloomType.OldDofFastBloom ||
DofDiffuionBloomOverlay.IsDepthTexture;
}
}
public Parameter()
{
IsEnable = true;
DofDiffuionBloomOverlay = DofDiffusionBloomOverlayPass.Parameter.Default();
IsRequestDepthPass = true;
}
public void ShallowCopyFrom(Parameter src)
{
if (src == null)
throw new ArgumentNullException(nameof(src));
ShallowCopyParameters(src);
IsRequestDepthPass = src.IsRequestDepthPass;
}
public void ShallowCopyParameters(Parameter src)
{
if (src == null)
throw new ArgumentNullException(nameof(src));
DofDiffuionBloomOverlay =
src.DofDiffuionBloomOverlay;
RadialBlur = src.RadialBlur;
ColorCorrection = src.ColorCorrection;
SunShafts = src.SunShafts;
LightShafts = src.LightShafts;
}
public void CopyFromGallopImageEffect(
GallopImageEffectParameter imageEffectParam)
{
if (imageEffectParam == null)
{
throw new ArgumentNullException( nameof(imageEffectParam));
}
DofDiffuionBloomOverlay.Setup(imageEffectParam.DofDiffusionBloomOverlayParam);
}
private static void InvokeCameraDataInitialize(
CameraData cameraData)
{
if (cameraData == null)
return;
MethodInfo[] methods =
cameraData.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
for (int i = 0; i < methods.Length; i++)
{
MethodInfo method = methods[i];
if (method.Name != "Initialize")
continue;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
continue;
Type parameterType = parameters[0].ParameterType;
if (parameterType == typeof(bool))
{
method.Invoke(cameraData, new object[] { false });
return;
}
if (parameterType == typeof(int))
{
method.Invoke(cameraData, new object[] { 0 });
return;
}
}
}
}
}
}