Files
UmaViewer/Assets/Scripts/umamusume/Gallop/DereScript/Cutt/LiveTimelineControl.cs
T
2023-01-20 07:13:54 +08:00

5670 lines
299 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text.RegularExpressions;
using UnityEngine;
namespace Cutt
{
public class LiveTimelineControl : MonoBehaviour
{
public struct FindTimelineConfig
{
public enum KeyType
{
KeyDirect,
CurrentFrame
}
public KeyType keyType;
public ILiveTimelineKeyDataList posKeys;
public ILiveTimelineKeyDataList lookAtKeys;
public LiveTimelineKey curKey;
public LiveTimelineKey nextKey;
public int extraCameraIndex;
}
private class ProjectorWork
{
public int lineHash;
public int startFrame = -1;
public float progressTime;
}
public static class Drawing
{
private static Texture2D aaLineTex;
private static Texture2D lineTex;
private static Material blitMaterial;
private static Material blendMaterial;
private static Rect lineRect;
public static void DrawLine(Vector2 pointA, Vector2 pointB, Color color, float width, bool antiAlias)
{
if (!lineTex)
{
Initialize();
}
float num = pointB.x - pointA.x;
float num2 = pointB.y - pointA.y;
float num3 = Mathf.Sqrt(num * num + num2 * num2);
if (!(num3 < 0.001f))
{
Texture2D texture;
Material mat;
if (antiAlias)
{
width *= 3f;
texture = aaLineTex;
mat = blendMaterial;
}
else
{
texture = lineTex;
mat = blitMaterial;
}
float num4 = width * num2 / num3;
float num5 = width * num / num3;
Matrix4x4 identity = Matrix4x4.identity;
identity.m00 = num;
identity.m01 = 0f - num4;
identity.m03 = pointA.x + 0.5f * num4;
identity.m10 = num2;
identity.m11 = num5;
identity.m13 = pointA.y - 0.5f * num5;
GL.PushMatrix();
GL.MultMatrix(identity);
Graphics.DrawTexture(lineRect, texture, lineRect, 0, 0, 0, 0, color, mat);
GL.PopMatrix();
}
}
public static void DrawBezierLine(Vector2 start, Vector2 startTangent, Vector2 end, Vector2 endTangent, Color color, float width, bool antiAlias, int segments)
{
Vector2 pointA = CubeBezier(start, startTangent, end, endTangent, 0f);
for (int i = 1; i < segments; i++)
{
Vector2 vector = CubeBezier(start, startTangent, end, endTangent, (float)i / (float)segments);
DrawLine(pointA, vector, color, width, antiAlias);
pointA = vector;
}
}
private static Vector2 CubeBezier(Vector2 s, Vector2 st, Vector2 e, Vector2 et, float t)
{
float num = 1f - t;
return num * num * num * s + 3f * num * num * t * st + 3f * num * t * t * et + t * t * t * e;
}
static Drawing()
{
aaLineTex = null;
lineTex = null;
blitMaterial = null;
blendMaterial = null;
lineRect = new Rect(0f, 0f, 1f, 1f);
Initialize();
}
private static void Initialize()
{
if (lineTex == null)
{
lineTex = new Texture2D(1, 1, TextureFormat.ARGB32, mipChain: false);
lineTex.SetPixel(0, 1, Color.white);
lineTex.Apply();
}
if (aaLineTex == null)
{
aaLineTex = new Texture2D(1, 3, TextureFormat.ARGB32, mipChain: false);
aaLineTex.SetPixel(0, 0, new Color(1f, 1f, 1f, 0f));
aaLineTex.SetPixel(0, 1, Color.white);
aaLineTex.SetPixel(0, 2, new Color(1f, 1f, 1f, 0f));
aaLineTex.Apply();
}
blitMaterial = (Material)typeof(GUI).GetMethod("get_blitMaterial", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
blendMaterial = (Material)typeof(GUI).GetMethod("get_blendMaterial", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, null);
}
}
private const int BG_COLOR3_COLOR_NUM = 10;
private const float DefaultCameraAspectRatio = 1.77777779f;
public LiveTimelineData data;
private bool isDataLoaded;
public const int kTargetFps = 60;
public const float kTargetFpsF = 60f;
public const float kFrameToSec = 0.0166666675f;
public Transform cameraPositionLocatorsRoot;
public Transform cameraLookAtLocatorsRoot;
public Transform[] characterStandPosLocators = new Transform[liveCharaPositionMax];
private int _numLaserParts = 5;
private Vector3[] _arrLaserPosition = new Vector3[5];
private Vector3[] _arrLaserRotation = new Vector3[5];
private Vector3[] _arrLaserScale = new Vector3[5];
private bool _isNowAlterUpdate;
private float _currentLiveTime;
private float _oldLiveTime;
private int _currentFrame;
private int _oldFrame;
private float _deltaTime;
private float _deltaTimeRatio;
private bool _isEnablePostEffect = true;
private Vector3 _cameraLayerOffset = Vector3.zero;
private Vector3 _extraCameraLayerOffset = Vector3.zero;
private bool _isExtraCameraLayer;
private const float kCameraLayerOffsetMinCharaHeight = 127f;
private const float kCameraLayerOffsetMaxCharaHeight = 182f;
private const float kCameraLayerOffsetBaseDiff = 55f;
private Dictionary<int, bool>[] _ignoreLaserHashDic;
private float _facialNoiseLimitTime = 0.5f;
private float[] _facialNoiseLimitTimeArray = new float[14];
private int[] _facialNoiseFrameArray = new int[14];
private TimelinePlayerMode _playMode = TimelinePlayerMode.Default;
private BgColor3UpdateInfo _bgColor3UpdateInfo;
public float _baseCameraAspectRatio = DefaultCameraAspectRatio;
public bool _limitFovForWidth;
private bool _isUnloadAssetWorkSheet = true;
private string _animationClipLoadDir;
private int _activeSheetIndex = -1;
private bool _isActiveSheetIndexAlt;
private float _chrMotNoiseBaseBias;
private float _chrMotNoiseRange = 0.07f;
private float _chrMotNoiseFrequency = 10f;
private float[] _charaMotNoiseTimeArray = new float[liveCharaPositionMax];
private Vector3[] _arrMobCyalume3DLookAtPosition = new Vector3[11];
private Vector3[] _arrMobCyalume3DPosition = new Vector3[11];
private const int PartsMotionNum = 4;
private Vector3[] _heightMotionOffsetRate = new Vector3[4];
private LiveTimelineKeyCharaIKData.IKPart[] _heightMotionOffsetTargetPart = new LiveTimelineKeyCharaIKData.IKPart[4];
private CacheCamera[] _cameraArray = new CacheCamera[3];
private LiveTimelineCamera[] _cameraScriptArray = new LiveTimelineCamera[3];
private Dictionary<string, Transform> _cameraPositionLocatorDict;
private Dictionary<string, Transform> _cameraLookAtLocatorDict;
private ILiveTimelineCharactorLocator[] _liveCharactorLocators = new ILiveTimelineCharactorLocator[liveCharaPositionMax];
private static int _liveCharaPositionMax = -1;
public const int liveCharaPositionEditorDefault = 5;
private Vector3 _liveStageCenterPos = Vector3.zero;
private LiveTimelineEventPublisher _eventPublisher;
private LiveTimelineMotionSequence[] _motionSequenceArray = new LiveTimelineMotionSequence[liveCharaPositionMax];
private static Func<LiveTimelineKeyCameraPositionData, LiveTimelineControl, FindTimelineConfig, Vector3> fnGetCameraPosValue = GetCameraPosValue;
private static Func<LiveTimelineKeyCameraLookAtData, LiveTimelineControl, Vector3, FindTimelineConfig, Vector3> fnGetCameraLookAtValue = GetCameraLookAtValue;
private int lastTriggeredEventFrame = -1;
private ProjectorWork[] _projectorWorks;
private int[] _formationOffsetStartFrameArray = new int[liveCharaPositionMax];
private LiveTimelineKeyFormationOffsetData[] _formationOffsetLateUpdateKey = new LiveTimelineKeyFormationOffsetData[liveCharaPositionMax * 2];
private bool _drawDeltaTimeGraph;
private const int kDeltaTimeArrayLength = 300;
private float[] _deltaTimeArrayForGraph = new float[kDeltaTimeArrayLength];
private int _headIndexOfDeltaTimeArray;
private float graphXMargin = 200f;
private float graphYMargin;
private float graphWidth;
private float graphHeight = 50f;
private LiveCharaPositionFlag _enviromentShadowCharacterPositionFlag = (LiveCharaPositionFlag)(-1);
private bool _enviromentSoftShadow;
private int _colorCorrectionCameraIndex = -1;
private SweatLocatorUpdateInfo _sweatLocatorUpdateInfo = new SweatLocatorUpdateInfo(5);
private List<int> _sweatLocatorRandomIndex = new List<int>();
private CacheCamera _crossFadeCameraCache;
private CacheCamera[] _arrMonitorCameraCache;
private float[] _arrMonitorCameraRoll;
private static Func<LiveTimelineKeyCameraPositionData, LiveTimelineControl, FindTimelineConfig, Vector3> fnGetMonitorCameraPositionValue = GetMonitorCameraPositionValue;
private static Func<LiveTimelineKeyCameraLookAtData, LiveTimelineControl, Vector3, FindTimelineConfig, Vector3> fnGetMonitorCameraLookAtValue = GetMonitorCameraLookAtValue;
private CacheCamera[] _multiCameraCache;
private MultiCamera[] _multiCamera;
private MultiCameraManager _multiCameraManager;
private bool _isMultiCameraEnable;
private static Func<LiveTimelineKeyCameraPositionData, LiveTimelineControl, FindTimelineConfig, Vector3> fnGetMultiCameraPositionValueFunc = GetMultiCameraPositionValue;
private static Func<LiveTimelineKeyCameraLookAtData, LiveTimelineControl, Vector3, FindTimelineConfig, Vector3> fnGetMultiCameraLookAtValueFunc = GetMultiCameraLookAtValue;
public Vector3 cameraLayerOffset => _cameraLayerOffset;
public float facialNoiseLimitTime
{
get
{
return _facialNoiseLimitTime;
}
set
{
float num = _facialNoiseLimitTime;
_facialNoiseLimitTime = value;
if (_facialNoiseLimitTime != num)
{
InitFacialNoise();
}
}
}
public TimelinePlayerMode playMode
{
set
{
_playMode = value;
}
}
private float kChrMotNoiseCurveRate => (float)Math.PI * 2f / _chrMotNoiseFrequency;
private static bool availableFindKeyCache => true;
public float currentLiveTime
{
get
{
return _currentLiveTime;
}
private set
{
_currentLiveTime = value;
}
}
public bool isEnablePostEffect
{
get
{
return _isEnablePostEffect;
}
set
{
_isEnablePostEffect = value;
}
}
public CacheCamera[] cameraArray
{
get
{
return _cameraArray;
}
private set
{
_cameraArray = value;
}
}
private LiveTimelineCamera[] cameraScriptArray => _cameraScriptArray;
private Dictionary<string, Transform> cameraPositionLocatorDict
{
get
{
if (_cameraPositionLocatorDict == null)
{
_cameraPositionLocatorDict = new Dictionary<string, Transform>();
if (cameraPositionLocatorsRoot != null)
{
Transform[] componentsInChildren = cameraPositionLocatorsRoot.GetComponentsInChildren<Transform>();
foreach (Transform transform in componentsInChildren)
{
_cameraPositionLocatorDict[transform.name] = transform;
}
}
}
return _cameraPositionLocatorDict;
}
}
private Dictionary<string, Transform> cameraLookAtLocatorDict
{
get
{
if (_cameraLookAtLocatorDict == null)
{
_cameraLookAtLocatorDict = new Dictionary<string, Transform>();
if (cameraLookAtLocatorsRoot != null)
{
Transform[] componentsInChildren = cameraLookAtLocatorsRoot.GetComponentsInChildren<Transform>();
foreach (Transform transform in componentsInChildren)
{
_cameraLookAtLocatorDict[transform.name] = transform;
}
}
}
return _cameraLookAtLocatorDict;
}
}
public ILiveTimelineCharactorLocator[] liveCharactorLocators => _liveCharactorLocators;
public static int liveCharaPositionMax
{
get
{
if (_liveCharaPositionMax < 0)
{
_liveCharaPositionMax = Enum.GetValues(typeof(LiveCharaPosition)).Length;
}
return _liveCharaPositionMax;
}
}
public Vector3 liveStageCenterPos
{
get
{
return _liveStageCenterPos;
}
set
{
_liveStageCenterPos = value;
}
}
public LiveTimelineEventPublisher eventPublisher
{
get
{
if (_eventPublisher == null)
{
_eventPublisher = new LiveTimelineEventPublisher();
}
return _eventPublisher;
}
}
public event Action OnStartUpdate;
public event Action OnPreUpdateAllTimeline;
public event Action OnPostUpdateAllTimeline;
public event CameraPosUpdateInfoDelegate OnUpdateCameraPos;
public event BgColor1UpdateInfoDelegate OnUpdateBgColor1;
public event BgColor2UpdateInfoDelegate OnUpdateBgColor2;
public event BgColor3UpdateInfoDelegate OnUpdateBgColor3;
public event VolumeLightUpdateInfoDelegate OnUpdateVolumeLight;
public event HdrBloomUpdateInfoDelegate OnUpdateHdrBloom;
public event MonitorControlUpdateInfoDelegate OnUpdateMonitorControl;
public event Action<int> OnUpdateCameraSwitcher;
public event Action<LiveTimelineKeyRipSyncData, float> OnUpdateLipSync;
public event PostEffectUpdateInfoDelegate OnUpdatePostEffect;
public event ScreenOverlayUpdateInfoDelegate OnUpdatePostFilm;
public event ScreenOverlayUpdateInfoDelegate OnUpdatePostFilm2;
public event ProjectorUpdateInfoDelegate OnUpdateProjector;
public event AnimationUpdateInfoDelegate OnUpdateAnimation;
public event TextureAnimationUpdateInfoDelegate OnUpdateTextureAnimation;
public event TransformUpdateInfoDelegate OnUpdateTransform;
public event RendererUpdateInfoDelegate OnUpdateRenderer;
public event ObjectUpdateInfoDelegate OnUpdateObject;
public event GazingObjectUpdateInfoDelegate OnUpdateGazingObject;
public event ScreenFadeUpdateInfoDelegate OnUpdateScreenFade;
public event PropsUpdateInfoDelegate OnUpdateProps;
public event PropsAttachUpdateInfoDelegate OnUpdatePropsAttach;
public event Action<FacialDataUpdateInfo, float, LiveCharaPosition> OnUpdateFacial;
public event ParticleUpdateInfoDelegate OnUpdateParticle;
public event ParticleGroupUpdateInfoDelegate OnUpdateParticleGroup;
public event LaserUpdateInfoDelegate OnUpdateLaser;
public event EffectUpdateInfoDelegate OnUpdateEffect;
public event FormationOffsetUpdateInfoDelegate OnUpdateFormationOffset;
public event EnvironmentCharacterShadowDelegate OnEnvironmentCharacterShadow;
public event EnvironmentMirrorDelegate OnEnvironmentMirror;
public event EnvironmentGlobalLightDelegate OnEnvironmentGlobalLight;
public event GlobalFogDelegate OnGlobalFog;
public event TiltShiftDelegate OnUpdateTiltShift;
public event LightShuftDelegate OnLightShuft;
public event ColorCorrectionDelegate OnColorCorrection;
public event SweatLocatorUpdateInfoDelegate OnUpdateSweatLocator;
public event LensFlareUpdateInfoDelegate OnUpdateLensFlare;
public event A2UConfigUpdateInfoDelegate OnUpdateA2UConfig;
public event A2UUpdateInfoDelegate OnUpdateA2U;
public event MonitorCameraUpdateDelegate OnUpdateMonitorCamera;
public event GlassUpdateInfoDelegate OnUpdateGlass;
public event ShaderControlUpdateInfoDelegate OnUpdateShaderControl;
public event CySpringUpdateInfoDelegate OnUpdateCySpring;
public event CharaIKUpdateInfoDelegate OnUpdateIK;
public event CharaFootLightUpdateInfoDelegate OnUpdateCharaFootLight;
public event StageGazeControlUpdateInfoDelegate OnUpdateStageGazeControl;
public event MobCyalumeUpdateInfoDelegate OnUpdateMobCyalume;
public event MobCyalume3DUpdateInfoDelegate OnUpdateMobCyalume3D;
public event CrossFadeCameraUpdateInfoDelegate OnUpdateCrossFadeCamera;
public event MultiCameraUpdateInfoDelegate OnUpdateMultiCamera;
public event CharaHeightMotionUpdateInfoDelegate OnCharaHeightMotionUpdateInfo;
public event CharaWindUpdateInfoDelegate OnCharaWindUpdate;
public event DressChangeUpdateInfoDelegate OnUpdateDressChange;
public Vector3 GetExtraCameraLayerOffset(Quaternion worldRotation)
{
if (!_isExtraCameraLayer)
{
return _cameraLayerOffset;
}
return worldRotation * _extraCameraLayerOffset;
}
public void SetUnloadAssetWorkSheet(bool b)
{
_isUnloadAssetWorkSheet = b;
}
public void SetActiveSheetIndex(int index, bool isAlt = false)
{
_activeSheetIndex = index;
_activeSheetIndex = index;
_isActiveSheetIndexAlt = isAlt;
}
public CacheCamera GetCamera(int index)
{
if (index < 0 || index >= _cameraArray.Length)
{
return null;
}
return _cameraArray[index];
}
public LiveTimelineCamera GetCameraScript(int index)
{
if (index < 0 || index >= _cameraScriptArray.Length)
{
return null;
}
return _cameraScriptArray[index];
}
public Vector3 GetCameraPos(int index)
{
return GetCamera(index)?.cacheTransform.position ?? Vector3.zero;
}
public Transform FindPositionLocator(string name)
{
if (cameraPositionLocatorsRoot == null || string.IsNullOrEmpty(name))
{
return null;
}
if (!cameraPositionLocatorDict.TryGetValue(name, out var value))
{
return null;
}
return value;
}
public Transform FindLookAtLocator(string name)
{
if (cameraLookAtLocatorsRoot == null || string.IsNullOrEmpty(name))
{
return null;
}
if (!cameraLookAtLocatorDict.TryGetValue(name, out var value))
{
return null;
}
return value;
}
public bool SetCharactorParentLocator(int id, Transform parentTransform)
{
if (_liveCharactorLocators.Length <= id)
{
return false;
}
if (_liveCharactorLocators[id] == null)
{
return false;
}
_liveCharactorLocators[id].liveParentTransform = parentTransform;
return true;
}
public void SetCharactorLocator(LiveCharaPosition position, ILiveTimelineCharactorLocator locator)
{
if (locator == null)
{
liveCharactorLocators[(int)position] = null;
}
else
{
locator.liveCharaStandingPosition = position;
liveCharactorLocators[(int)position] = locator;
}
InitCharaMotionSequence(position);
if (locator != null)
{
if ((int)position < characterStandPosLocators.Length && characterStandPosLocators[(int)position] != null && locator.liveRootTransform != null)
{
locator.liveRootTransform.position = characterStandPosLocators[(int)position].position;
locator.liveCharaInitialPosition = characterStandPosLocators[(int)position].position;
}
float num = locator.liveCharaHeightValue - kCameraLayerOffsetMinCharaHeight;
locator.liveCharaHeightRatio = num / kCameraLayerOffsetBaseDiff;
if (Mathf.Abs(locator.liveCharaHeightRatio) < 0.001f)
{
locator.liveCharaHeightRatio = 0f;
}
}
}
public void ChangeCharacterLocator(LiveCharaPosition position, ILiveTimelineCharactorLocator locator)
{
if (locator == null)
{
liveCharactorLocators[(int)position] = null;
}
else
{
locator.liveCharaStandingPosition = position;
liveCharactorLocators[(int)position] = locator;
}
ChangeMotionTarget(position);
}
public void SetTimelineCamera(Camera cam, int index)
{
if (index < _cameraArray.Length)
{
if (_cameraArray[index] == null)
{
_cameraArray[index] = new CacheCamera(cam);
}
else
{
_cameraArray[index].Set(cam);
}
LiveTimelineCamera liveTimelineCamera = cam.gameObject.GetComponent<LiveTimelineCamera>();
if (liveTimelineCamera == null)
{
liveTimelineCamera = cam.gameObject.AddComponent<LiveTimelineCamera>();
}
_cameraScriptArray[index] = liveTimelineCamera;
if (liveTimelineCamera != null)
{
liveTimelineCamera.AlterAwake();
}
}
}
public void InitCharaMotionSequence(LiveCharaPosition position)
{
if (data == null)
{
return;
}
if (liveCharactorLocators[(int)position] == null)
{
return;
}
List<LiveTimelineCharaMotSeqData> charaMotSeqList = data.GetWorkSheetList()[0].charaMotSeqList;
List<LiveTimelineCharaOverrideMotSeqData> charaMotOverwriteList = data.GetWorkSheetList()[0].charaMotOverwriteList;
LiveTimelineCharaMotSeqData liveTimelineCharaMotSeqData = null;
LiveTimelineCharaOverrideMotSeqData liveTimelineCharaOverrideMotSeqData = null;
List<LiveTimelineCharaHeightMotSeqData> charaHeightMotList = data.GetWorkSheetList()[0].charaHeightMotList;
LiveTimelineCharaHeightMotSeqData liveTimelineCharaHeightMotSeqData = null;
if ((int)position < data.characterSettings.motionSequenceIndices.Length)
{
int num = data.characterSettings.motionSequenceIndices[(int)position];
if (num >= 0 && num < charaMotSeqList.Count)
{
liveTimelineCharaMotSeqData = charaMotSeqList[num];
}
}
if ((int)position < data.characterSettings.motionOverwriteIndices.Length)
{
int num2 = data.characterSettings.motionOverwriteIndices[(int)position];
if (num2 >= 0 && num2 < charaMotOverwriteList.Count)
{
liveTimelineCharaOverrideMotSeqData = charaMotOverwriteList[num2];
}
}
foreach (LiveTimelineCharaHeightMotSeqData item in charaHeightMotList)
{
if (item.charaPosition == position)
{
liveTimelineCharaHeightMotSeqData = item;
break;
}
}
if (liveTimelineCharaMotSeqData != null && liveCharactorLocators[(int)position] is ILiveTimelineMSQTarget)
{
if (_motionSequenceArray[(int)position] == null)
{
_motionSequenceArray[(int)position] = new LiveTimelineMotionSequence();
}
ILiveTimelineMSQTarget liveTimelineMSQTarget = liveCharactorLocators[(int)position] as ILiveTimelineMSQTarget;
LiveTimelineMotionSequence.Context context = default(LiveTimelineMotionSequence.Context);
context.motionKeys = liveTimelineCharaMotSeqData.keys;
context.overwriteMotionKeys = liveTimelineCharaOverrideMotSeqData?.keys;
context.heightMotionKeys = liveTimelineCharaHeightMotSeqData?.keys;
context.timelineControl = this;
if (liveTimelineMSQTarget.spareTarget != null)
{
ILiveTimelineMSQTarget[] spareTarget = liveTimelineMSQTarget.spareTarget;
for (int i = 0; i < spareTarget.Length; i++)
{
ILiveTimelineMSQTarget liveTimelineMSQTarget2 = (context.target = spareTarget[i]);
_motionSequenceArray[(int)position].Initialize(ref context);
_motionSequenceArray[(int)position].AlterUpdate(0f,60f);
}
}
context.target = liveTimelineMSQTarget;
_motionSequenceArray[(int)position].Initialize(ref context);
}
else
{
_motionSequenceArray[(int)position] = null;
}
}
public void ChangeMotionTarget(LiveCharaPosition position)
{
if (liveCharactorLocators[(int)position] != null)
{
ILiveTimelineMSQTarget liveTimelineMSQTarget = liveCharactorLocators[(int)position] as ILiveTimelineMSQTarget;
if (liveTimelineMSQTarget != null && _motionSequenceArray[(int)position] != null)
{
_motionSequenceArray[(int)position].ChangeTarget(liveTimelineMSQTarget);
}
else
{
_motionSequenceArray[(int)position] = null;
}
}
}
private void Awake()
{
currentLiveTime = 0f;
_bgColor3UpdateInfo.colorArray = new Color[BG_COLOR3_COLOR_NUM];
for (int i = 0; i < _bgColor3UpdateInfo.colorArray.Length; i++)
{
_bgColor3UpdateInfo.colorArray[i] = default(Color);
}
}
private void OnDestroy()
{
Terminate();
}
private void Start()
{
}
public void Initialize(string charaMotionPath = null)
{
if (charaMotionPath == null)
{
_animationClipLoadDir = "3D/Chara/Motion/Legacy/";
}
else
{
_animationClipLoadDir = Regex.Replace(charaMotionPath, "[^/]+$", "");
}
if (LoadData() == null)
{
return;
}
eventPublisher.BeginPublish();
InitFacialNoise();
InitCharaMotionNoise();
InitFormationOffsetWork();
CreateIgnoreLaserHashDic();
eventPublisher.Subscribe(LiveTimelineEventID.CameraHandShake, delegate (LiveTimelineKeyEventData.EventData eventData)
{
for (int i = 0; i < _cameraScriptArray.Length; i++)
{
LiveTimelineCamera liveTimelineCamera = _cameraScriptArray[i];
if (!(liveTimelineCamera == null))
{
CuttEventParam_CameraHandShake parameter = eventData.GetParameter<CuttEventParam_CameraHandShake>();
if (parameter != null)
{
liveTimelineCamera.applyNoise = parameter.isEnable;
if (parameter.isOverwrite)
{
liveTimelineCamera.positionAmount = parameter.positionAmount;
liveTimelineCamera.rotationAmount = parameter.rotationAmount;
liveTimelineCamera.positionComponents = (Vector3)parameter.positionComponents;
liveTimelineCamera.rotationComponents = (Vector3)parameter.rotationComponents;
}
}
}
}
});
}
private void Terminate()
{
eventPublisher.EndPublish();
UnloadData();
}
public LiveTimelineData LoadData()
{
if (!isDataLoaded && data != null)
{
data.OnLoad(this);
isDataLoaded = true;
}
return data;
}
private void UnloadData()
{
if (!(data == null))
{
if (_isUnloadAssetWorkSheet)
{
data.UnloadSheets();
Resources.UnloadAsset(data);
}
data = null;
isDataLoaded = false;
}
}
public AnimationClip LoadAnimationClip(LiveTimelineKeyCharaMotionData key)
{
if (key.clip != null && key.clip.name != key.motionName)
{
key.clip = null;
}
if (key.clip != null)
{
//�L�������[�V������FPS���w��
key.clip.frameRate = Application.targetFrameRate;
return key.clip;
}
if (string.IsNullOrEmpty(key.motionName))
{
return null;
}
string text = GetAnimationClipLoadDir() + key.motionName;
/*
if (Application.isEditor && !Application.isPlaying)
{
return Resources.Load<AnimationClip>(text);
}
*/
//�L�������[�V������FPS���w��
AnimationClip clip = (AnimationClip)ResourcesManager.instance.LoadObject(text);
clip.frameRate = Application.targetFrameRate;
return clip;
}
public string GetAnimationClipLoadDir()
{
return _animationClipLoadDir;
}
/// <summary>
/// ���p�N�Ƀm�C�Y���ڂ���
/// </summary>
private void InitFacialNoise()
{
float[] array = new float[14]
{
_facialNoiseLimitTime * -1f,
_facialNoiseLimitTime * -0.857f,
_facialNoiseLimitTime * -0.714f,
_facialNoiseLimitTime * -0.571f,
_facialNoiseLimitTime * -0.428f,
_facialNoiseLimitTime * -0.285f,
_facialNoiseLimitTime * -0.142f,
_facialNoiseLimitTime * 0.142f,
_facialNoiseLimitTime * 0.285f,
_facialNoiseLimitTime * 0.428f,
_facialNoiseLimitTime * 0.571f,
_facialNoiseLimitTime * 0.714f,
_facialNoiseLimitTime * 0.857f,
_facialNoiseLimitTime * 1f
};
int num = array.Length;
for (int i = 0; i < _facialNoiseLimitTimeArray.Length; i++)
{
int num2 = num - i - 1;
int num3 = ((num2 != 0) ? UnityEngine.Random.Range(0, num2) : 0);
_facialNoiseLimitTimeArray[i] = array[num3];
array[num3] = array[num2];
}
}
private float GetFacialNoiseCurrentTime(int index)
{
return currentLiveTime + _facialNoiseLimitTimeArray[index];
}
/// <summary>
/// �L�����̃��[�V�����Ƀm�C�Y���ڂ���
/// </summary>
public void InitCharaMotionNoise()
{
float[] array = new float[14]
{
0f, 0.142f, 0.285f, 0.428f, 0.571f, 0.714f, 0.857f, 1f, 0.2f, 0.3f,
0.4f, 0.6f, 0.8f, 1f
};
int num = array.Length;
for (int i = 0; i < liveCharaPositionMax - 1; i++)
{
int num2 = num - i - 1;
int num3 = ((num2 != 0) ? UnityEngine.Random.Range(0, num2) : 0);
_charaMotNoiseTimeArray[i + 1] = _chrMotNoiseFrequency * array[num3];
array[num3] = array[num2];
}
}
public void StartUpdate()
{
if (this.OnStartUpdate != null)
{
this.OnStartUpdate();
}
AlterUpdate(0f);
}
public void AlterUpdate(float liveTime)
{
if (data == null)
{
return;
}
_isNowAlterUpdate = true;
if (this.OnPreUpdateAllTimeline != null)
{
this.OnPreUpdateAllTimeline();
}
_oldLiveTime = currentLiveTime;
currentLiveTime = liveTime;
_currentFrame = Mathf.RoundToInt(currentLiveTime * 60f);
_oldFrame = Mathf.RoundToInt(_oldLiveTime * 60f);
_deltaTime = currentLiveTime - _oldLiveTime;
_deltaTimeRatio = _deltaTime / 0.0166666675f;
for (int i = 0; i < _facialNoiseLimitTimeArray.Length; i++)
{
float facialNoiseCurrentTime = GetFacialNoiseCurrentTime(i);
_facialNoiseFrameArray[i] = Mathf.RoundToInt(facialNoiseCurrentTime * 60f);
}
if (_drawDeltaTimeGraph)
{
UpdateDeltaTimeGraph();
EnqueueDeltaTimeForGraph(_deltaTime);
}
int count = data.GetWorkSheetList().Count;
for (int j = 0; j < count; j++)
{
LiveTimelineWorkSheet workSheet = data.GetWorkSheet(j);
if (workSheet.IsEnable())
{
AlterUpdate_Event(workSheet, _currentFrame, _oldFrame);
AlterUpdate_ShaderControl(workSheet, _currentFrame);
if (j == 0)
{
AlterUpdate_CharaHeightMotion(workSheet, _currentFrame);
AlterUpdate_CharaMotionSequence(workSheet, _currentFrame);
}
AlterUpdate_LipSync(workSheet, _currentFrame);
if ((_activeSheetIndex != -1 && _isActiveSheetIndexAlt && data.switchSheetTargetTimelineSettings.Get(LiveTimelineSwitchSheetTargetTimelineSetting.Timeline.Facial)) ? (_activeSheetIndex == j) : (j == 0))
{
AlterUpdate_FacialData(workSheet, _currentFrame);
}
if (j == 0)
{
AlterUpdate_CharaWind(workSheet, _currentFrame);
}
AlterUpdate_BgColor1(workSheet, _currentFrame);
AlterUpdate_BgColor2(workSheet, _currentFrame);
AlterUpdate_BgColor3(workSheet, _currentFrame);
AlterUpdate_VolumeLight(workSheet, _currentFrame);
AlterUpdate_LightShuft(workSheet, _currentFrame);
AlterUpdate_HdrBloom(workSheet, _currentFrame);
AlterUpdate_ColorCorrection(workSheet, _currentFrame);
AlterUpdate_MonitorControl(workSheet, _currentFrame);
AlterUpdate_Projector(workSheet, _currentFrame);
AlterUpdate_AnimationControl(workSheet, _currentFrame);
AlterUpdate_TextureAnimationControl(workSheet, _currentFrame);
AlterUpdate_TransformControl(workSheet, _currentFrame);
AlterUpdate_RendererControl(workSheet, _currentFrame);
AlterUpdate_ObjectControl(workSheet, _currentFrame);
AlterUpdate_GazingObjectControl(workSheet, _currentFrame);
AlterUpdate_StageGazeControl(workSheet, _currentFrame);
if (_activeSheetIndex == -1 || _activeSheetIndex == j)
{
AlterUpdate_FormationOffset(workSheet, _currentFrame);
}
AlterUpdate_PropsControl(workSheet, _currentFrame);
if (!_isActiveSheetIndexAlt || _activeSheetIndex == -1 || _activeSheetIndex == j)
{
AlterUpdate_PropsAttachControl(workSheet, _currentFrame);
}
AlterUpdate_Particle(workSheet, _currentFrame);
AlterUpdate_ParticleGroup(workSheet, _currentFrame);
AlterUpdate_Laser(workSheet, _currentFrame, j);
AlterUpdate_Effect(workSheet, _currentFrame);
AlterUpdate_Glass(workSheet, _currentFrame);
AlterUpdate_Environment(workSheet, _currentFrame);
AlterUpdate_GlobalLight(workSheet, _currentFrame);
AlterUpdate_GlobalFog(workSheet, _currentFrame);
AlterUpdate_TiltShift(workSheet, _currentFrame);
AlterUpdate_SweatLocator(workSheet, _currentFrame);
AlterUpdate_LensFlare(workSheet, _currentFrame);
AlterUpdate_A2UConfig(workSheet, _currentFrame);
AlterUpdate_A2U(workSheet, _currentFrame);
AlterUpdate_IK(workSheet, _currentFrame);
AlterUpdate_MobCyalume(workSheet, _currentFrame);
AlterUpdate_MobCyalume3D(workSheet, _currentFrame);
AlterUpdate_CameraSwitcher(workSheet, _currentFrame);
AlterUpdate_DressChange(workSheet, _currentFrame);
}
}
if (this.OnPostUpdateAllTimeline != null)
{
this.OnPostUpdateAllTimeline();
}
_isNowAlterUpdate = false;
}
public void AlterLateUpdate()
{
if (data == null)
{
return;
}
_isMultiCameraEnable = false;
_isNowAlterUpdate = true;
int count = data.GetWorkSheetList().Count;
for (int i = 0; i < count; i++)
{
LiveTimelineWorkSheet workSheet = data.GetWorkSheet(i);
if (workSheet.IsEnable())
{
Vector3 outLookAt = Vector3.zero;
if (_activeSheetIndex == -1 || _activeSheetIndex == i)
{
AlterLateUpdate_FormationOffset(workSheet, _currentFrame);
AlterUpdate_CameraLayer(workSheet, _currentFrame, ref _cameraLayerOffset, ref _extraCameraLayerOffset);
AlterUpdate_CharaFootLight(workSheet, _currentFrame);
AlterUpdate_CameraPos(workSheet, _currentFrame, i);
AlterUpdate_CameraLookAt(workSheet, _currentFrame, ref outLookAt);
AlterUpdate_CameraFov(workSheet, _currentFrame);
AlterUpdate_CameraRoll(workSheet, _currentFrame);
}
if (i == 0)
{
AlterUpdate_CrossFadeCamera(workSheet, _currentFrame);
AlterUpdate_MultiCamera(workSheet, _currentFrame);
}
AlterUpdate_MonitorCamera(workSheet, _currentFrame);
if (isEnablePostEffect && (_activeSheetIndex == -1 || _activeSheetIndex == i))
{
AlterUpdate_PostEffect(workSheet, _currentFrame, outLookAt);
}
AlterUpdate_PostFilm(workSheet.postFilmKeys, _currentFrame, this.OnUpdatePostFilm);
AlterUpdate_PostFilm(workSheet.postFilm2Keys, _currentFrame, this.OnUpdatePostFilm2);
AlterUpdate_ScreenFade(workSheet.screenFadeKeys, _currentFrame);
}
}
for (int j = 0; j < _cameraScriptArray.Length; j++)
{
if (_cameraScriptArray[j] != null)
{
_cameraScriptArray[j].AlterUpdate(currentLiveTime);
}
}
if (this.OnUpdateMultiCamera != null)
{
MultiCameraUpdateInfo updateInfo = default(MultiCameraUpdateInfo);
updateInfo.isEnable = _isMultiCameraEnable;
this.OnUpdateMultiCamera(ref updateInfo);
}
_isNowAlterUpdate = false;
}
private static float LerpWithoutClamp(float a, float b, float t)
{
return a + (b - a) * t;
}
private static Vector2 LerpWithoutClamp(Vector2 a, Vector2 b, float t)
{
return new Vector2(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
}
private static Vector3 LerpWithoutClamp(Vector3 a, Vector3 b, float t)
{
return new Vector3(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
}
private static Vector4 LerpWithoutClamp(Vector4 a, Vector4 b, float t)
{
return new Vector4(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t, a.w + (b.w - a.w) * t);
}
private static Color LerpWithoutClamp(Color a, Color b, float t)
{
return new Color(a.r + (b.r - a.r) * t, a.g + (b.g - a.g) * t, a.b + (b.b - a.b) * t, a.a + (b.a - a.a) * t);
}
public static void FindTimelineKey(out LiveTimelineKey curKey, out LiveTimelineKey nextKey, ILiveTimelineKeyDataList keys, int curFrame)
{
FindKeyResult findKeyResult = keys.FindKeyCached(curFrame, availableFindKeyCache);
curKey = findKeyResult.key;
if (curKey != null)
{
nextKey = keys.At(findKeyResult.index + 1);
}
else
{
nextKey = null;
}
}
public static void FindTimelineKeyCurrent(out LiveTimelineKey curKey, ILiveTimelineKeyDataList keys, int curFrame)
{
LiveTimelineKey nextKey;
FindTimelineKey(out curKey, out nextKey, keys, curFrame);
}
public static void FindTimelineKeyTrigger(out LiveTimelineKey triggeredKey, ILiveTimelineKeyDataList keys, int curFrame, int oldFrame)
{
triggeredKey = null;
LiveTimelineKey liveTimelineKey = null;
liveTimelineKey = keys.FindKeyCached(curFrame, availableFindKeyCache).key;
if (liveTimelineKey != null && oldFrame <= liveTimelineKey.frame && liveTimelineKey.frame <= curFrame)
{
triggeredKey = liveTimelineKey;
}
}
public static void FindTimelineKeyPrevious(out LiveTimelineKey previousKey, ILiveTimelineKeyDataList keys, int curFrame)
{
previousKey = null;
FindKeyResult findKeyResult = keys.FindKeyCached(curFrame, availableFindKeyCache);
if (findKeyResult.key != null)
{
previousKey = keys.At(findKeyResult.index - 1);
}
}
public static void FindTimelineKeyNext(out LiveTimelineKey nextKey, ILiveTimelineKeyDataList keys, int curFrame)
{
nextKey = null;
LiveTimelineKey curKey;
FindTimelineKey(out curKey, out nextKey, keys, curFrame);
}
private static float LinearInterpolateKeyframes(LiveTimelineKey from, LiveTimelineKey to, float curFrame)
{
int num = to.frame - from.frame;
return Mathf.Clamp01((curFrame - (float)from.frame) / (float)num);
}
private static float CurveInterpolateKeyframes(LiveTimelineKey from, LiveTimelineKey to, float curFrame)
{
LiveTimelineKeyWithInterpolate liveTimelineKeyWithInterpolate = from as LiveTimelineKeyWithInterpolate;
LiveTimelineKeyWithInterpolate liveTimelineKeyWithInterpolate2 = to as LiveTimelineKeyWithInterpolate;
if (liveTimelineKeyWithInterpolate == null)
{
return 0f;
}
if (liveTimelineKeyWithInterpolate2 == null)
{
return 0f;
}
int num = to.frame - from.frame;
float time = Mathf.Clamp01((curFrame - (float)from.frame) / (float)num);
return liveTimelineKeyWithInterpolate2.curve.Evaluate(time);
}
private static float EaseInterpolateKeyframes(LiveTimelineKey from, LiveTimelineKey to, float curFrame)
{
LiveTimelineKeyWithInterpolate liveTimelineKeyWithInterpolate = from as LiveTimelineKeyWithInterpolate;
LiveTimelineKeyWithInterpolate liveTimelineKeyWithInterpolate2 = to as LiveTimelineKeyWithInterpolate;
if (liveTimelineKeyWithInterpolate == null)
{
return 0f;
}
if (liveTimelineKeyWithInterpolate2 == null)
{
return 0f;
}
int num = to.frame - from.frame;
return LiveTimelineEasing.GetValue(liveTimelineKeyWithInterpolate2.easingType, curFrame - (float)from.frame, 0f, 1f, (float)num);
}
public float GetCharacterHeight(LiveCharaPosition position)
{
return liveCharactorLocators[(int)position].liveCharaHeightValue;
}
public Vector3 GetPositionWithCharacters(LiveCharaPositionFlag posFlags, LiveCameraLookAtCharaParts parts, Vector3 cameraOffset)
{
Vector3 retPos = Vector3.zero;
Vector3 tmpPos = Vector3.zero;
if (posFlags == (LiveCharaPositionFlag)0)
{
retPos = liveStageCenterPos;
tmpPos = liveStageCenterPos;
}
else
{
int num = 0;
switch (parts)
{
case LiveCameraLookAtCharaParts.Face:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaHeadPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.Waist:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaWaistPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.LeftHandWrist:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaLeftHandWristPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.LeftHandAttach:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaLeftHandAttachPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.RightHandWrist:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaRightHandWristPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.RightHandAttach:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaRightHandAttachPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.Chest:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaChestPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.Foot:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaFootPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.ConstHeightFace:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaConstHeightHeadPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.ConstHeightWaist:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaConstHeightWaistPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.ConstHeightChest:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaConstHeightChestPosition;
retPos += cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.AxisLockedFace:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaHeadPosition;
tmpPos += liveCharactorLocators[i].liveCharaConstHeightHeadPosition;
Vector3 vector3 = cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
retPos += vector3;
tmpPos += vector3;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.AxisLockedChest:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaChestPosition;
tmpPos += liveCharactorLocators[i].liveCharaConstHeightChestPosition;
Vector3 vector2 = cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
retPos += vector2;
tmpPos += vector2;
num++;
}
}
break;
}
case LiveCameraLookAtCharaParts.AxisLockedWaist:
{
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (posFlags.hasFlag((LiveCharaPosition)i) && liveCharactorLocators[i] != null)
{
retPos += liveCharactorLocators[i].liveCharaWaistPosition;
tmpPos += liveCharactorLocators[i].liveCharaConstHeightWaistPosition;
Vector3 vector = cameraOffset * liveCharactorLocators[i].liveCharaHeightRatio;
retPos += vector;
tmpPos += vector;
num++;
}
}
break;
}
}
bool flag = num > 1;
if (flag)
{
retPos /= (float)num;
}
if ((uint)(parts - 11) <= 2u)
{
if (flag)
{
tmpPos /= (float)num;
}
retPos.y = tmpPos.y;
}
}
return retPos;
}
public Vector3 GetPositionWithCharacters(LiveCharaPositionFlag posFlags, LiveCameraLookAtCharaParts parts)
{
return GetPositionWithCharacters(posFlags, parts, _cameraLayerOffset);
}
public static float CalculateInterpolationValue(LiveTimelineKey curKey, LiveTimelineKeyWithInterpolate nextKey, int frame)
{
float result = 0f;
switch (nextKey.interpolateType)
{
case LiveCameraInterpolateType.Linear:
result = LinearInterpolateKeyframes(curKey, nextKey, frame);
break;
case LiveCameraInterpolateType.Curve:
result = CurveInterpolateKeyframes(curKey, nextKey, frame);
break;
case LiveCameraInterpolateType.Ease:
result = EaseInterpolateKeyframes(curKey, nextKey, frame);
break;
}
return result;
}
private void AlterUpdate_CameraPos(LiveTimelineWorkSheet sheet, int currentFrame, int sheetIndex)
{
if (sheet.cameraPosKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.cameraPosKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
if (camera == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.cameraPosKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCameraPositionData liveTimelineKeyCameraPositionData = curKey as LiveTimelineKeyCameraPositionData;
camera.camera.nearClipPlane = liveTimelineKeyCameraPositionData.nearClip;
camera.camera.farClipPlane = liveTimelineKeyCameraPositionData.farClip;
if (CalculateCameraPos(out var pos, sheet, curKey, nextKey, currentFrame))
{
camera.cacheTransform.position = pos;
int num = liveTimelineKeyCameraPositionData.GetCullingMask();
if (num == 0)
{
num = LiveTimelineKeyCameraPositionData.GetDefaultCullingMask();
}
camera.camera.cullingMask = num;
if (this.OnUpdateCameraPos != null)
{
CameraPosUpdateInfo updateInfo = default(CameraPosUpdateInfo);
updateInfo.outlineZOffset = liveTimelineKeyCameraPositionData.outlineZOffset;
updateInfo.characterLODMask = (int)liveTimelineKeyCameraPositionData.characterLODMask;
this.OnUpdateCameraPos(ref updateInfo);
}
}
}
private static Vector3 GetCameraPosValue(LiveTimelineKeyCameraPositionData keyData, LiveTimelineControl timelineControl, FindTimelineConfig config)
{
return keyData.GetValue(timelineControl);
}
public bool CalculateCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, int currentFrame)
{
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
config.posKeys = sheet.cameraPosKeys;
config.lookAtKeys = null;
config.extraCameraIndex = 0;
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
return CalculateCameraPos(out pos, sheet, currentFrame, camera, ref config, ref fnGetCameraPosValue);
}
public bool CalculateCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, LiveTimelineKey curKey, LiveTimelineKey nextKey, int currentFrame)
{
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = curKey;
config.nextKey = nextKey;
config.keyType = FindTimelineConfig.KeyType.KeyDirect;
config.posKeys = sheet.cameraPosKeys;
config.lookAtKeys = null;
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
config.extraCameraIndex = 0;
return CalculateCameraPos(out pos, sheet, currentFrame, camera, ref config, ref fnGetCameraPosValue);
}
public bool CalculateCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, int currentFrame, CacheCamera targetCamera, ref FindTimelineConfig config, ref Func<LiveTimelineKeyCameraPositionData, LiveTimelineControl, FindTimelineConfig, Vector3> getFunc)
{
pos = Vector3.zero;
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
if (config.posKeys == null)
{
return false;
}
if (config.keyType == FindTimelineConfig.KeyType.CurrentFrame)
{
FindTimelineKey(out curKey, out nextKey, config.posKeys, currentFrame);
}
else
{
curKey = config.curKey;
nextKey = config.nextKey;
}
if (curKey == null)
{
return false;
}
LiveTimelineKeyCameraPositionData liveTimelineKeyCameraPositionData = curKey as LiveTimelineKeyCameraPositionData;
LiveTimelineKeyCameraPositionData liveTimelineKeyCameraPositionData2 = nextKey as LiveTimelineKeyCameraPositionData;
if (liveTimelineKeyCameraPositionData2 != null && liveTimelineKeyCameraPositionData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraPositionData, liveTimelineKeyCameraPositionData2, currentFrame);
int bezierPointCount = liveTimelineKeyCameraPositionData2.GetBezierPointCount();
if (bezierPointCount == 0)
{
pos = LerpWithoutClamp(getFunc(liveTimelineKeyCameraPositionData, this, config), getFunc(liveTimelineKeyCameraPositionData2, this, config), t);
}
else if (liveTimelineKeyCameraPositionData2.necessaryToUseNewBezierCalcMethod)
{
BezierCalcWork.cameraPos.Set(getFunc(liveTimelineKeyCameraPositionData, this, config), getFunc(liveTimelineKeyCameraPositionData2, this, config), bezierPointCount);
BezierCalcWork.cameraPos.UpdatePoints(liveTimelineKeyCameraPositionData2, this);
BezierCalcWork.cameraPos.Calc(bezierPointCount, t, out pos);
}
else
{
Vector3 end = getFunc(liveTimelineKeyCameraPositionData2, this, config);
Vector3 cp = liveTimelineKeyCameraPositionData2.GetBezierPoint(0, this);
Vector3 cp2 = liveTimelineKeyCameraPositionData2.GetBezierPoint(1, this);
Vector3 cp3 = liveTimelineKeyCameraPositionData2.GetBezierPoint(2, this);
switch (liveTimelineKeyCameraPositionData2.GetBezierPointCount())
{
default:
pos = LerpWithoutClamp(getFunc(liveTimelineKeyCameraPositionData, this, config), getFunc(liveTimelineKeyCameraPositionData2, this, config), t);
break;
case 1:
{
Vector3 start3 = getFunc(liveTimelineKeyCameraPositionData, this, config);
BezierUtil.Calc(ref start3, ref end, ref cp, t, out pos);
break;
}
case 2:
{
Vector3 start2 = getFunc(liveTimelineKeyCameraPositionData, this, config);
BezierUtil.Calc(ref start2, ref end, ref cp, ref cp2, t, out pos);
break;
}
case 3:
{
Vector3 start = getFunc(liveTimelineKeyCameraPositionData, this, config);
BezierUtil.Calc(ref start, ref end, ref cp, ref cp2, ref cp3, t, out pos);
break;
}
}
}
}
else
{
pos = getFunc(liveTimelineKeyCameraPositionData, this, config);
}
if (_isNowAlterUpdate && liveTimelineKeyCameraPositionData.attribute.hasFlag(LiveTimelineKeyAttribute.CameraDelayEnable) && (_oldFrame >= liveTimelineKeyCameraPositionData.frame || currentFrame < liveTimelineKeyCameraPositionData.frame || liveTimelineKeyCameraPositionData.attribute.hasFlag(LiveTimelineKeyAttribute.CameraDelayInherit)))
{
if (targetCamera == null)
{
return false;
}
float t2 = liveTimelineKeyCameraPositionData.traceSpeed * _deltaTimeRatio;
pos = Vector3.Slerp(targetCamera.cacheTransform.position, pos, t2);
}
return true;
}
private void AlterUpdate_CameraLookAt(LiveTimelineWorkSheet sheet, int currentFrame, ref Vector3 outLookAt)
{
if (!sheet.cameraLookAtKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && sheet.cameraLookAtKeys.EnablePlayModeTimeline(_playMode))
{
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
if (camera != null && CalculateCameraLookAt(out var lookAtPos, sheet, currentFrame))
{
camera.cacheTransform.LookAt(lookAtPos, Vector3.up);
outLookAt = lookAtPos;
}
}
}
private static Vector3 GetCameraLookAtValue(LiveTimelineKeyCameraLookAtData keyData, LiveTimelineControl timelineControl, Vector3 camPos, FindTimelineConfig config)
{
return keyData.GetValue(timelineControl, camPos);
}
public bool CalculateCameraLookAt(out Vector3 lookAtPos, LiveTimelineWorkSheet sheet, int currentFrame)
{
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
config.posKeys = sheet.cameraPosKeys;
config.lookAtKeys = sheet.cameraLookAtKeys;
config.extraCameraIndex = 0;
return CalculateCameraLookAt(out lookAtPos, sheet, currentFrame, camera, ref config, ref fnGetCameraLookAtValue, ref fnGetCameraPosValue);
}
private bool CalculateCameraLookAt(out Vector3 lookAtPos, LiveTimelineWorkSheet sheet, int currentFrame, CacheCamera targetCamera, ref FindTimelineConfig config, ref Func<LiveTimelineKeyCameraLookAtData, LiveTimelineControl, Vector3, FindTimelineConfig, Vector3> getLookAtValueFunc, ref Func<LiveTimelineKeyCameraPositionData, LiveTimelineControl, FindTimelineConfig, Vector3> getPosValueFunc)
{
lookAtPos = Vector3.zero;
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
if (camera == null || config.lookAtKeys == null || config.posKeys == null)
{
return false;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, config.lookAtKeys, currentFrame);
if (curKey == null)
{
return false;
}
Vector3 position = camera.cacheTransform.position;
LiveTimelineKeyCameraLookAtData liveTimelineKeyCameraLookAtData = curKey as LiveTimelineKeyCameraLookAtData;
LiveTimelineKeyCameraLookAtData liveTimelineKeyCameraLookAtData2 = nextKey as LiveTimelineKeyCameraLookAtData;
if (liveTimelineKeyCameraLookAtData2 != null && liveTimelineKeyCameraLookAtData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraLookAtData, liveTimelineKeyCameraLookAtData2, currentFrame);
int bezierPointCount = liveTimelineKeyCameraLookAtData2.GetBezierPointCount();
if (bezierPointCount == 0)
{
lookAtPos = LerpWithoutClamp(getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config), getLookAtValueFunc(liveTimelineKeyCameraLookAtData2, this, position, config), t);
}
else if (liveTimelineKeyCameraLookAtData2.necessaryToUseNewBezierCalcMethod)
{
Vector3 zero = Vector3.zero;
BezierCalcWork.cameraLookAt.Set(getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config), getLookAtValueFunc(liveTimelineKeyCameraLookAtData2, this, zero, config), bezierPointCount);
BezierCalcWork.cameraLookAt.UpdatePoints(liveTimelineKeyCameraLookAtData2, this, zero);
BezierCalcWork.cameraLookAt.Calc(bezierPointCount, t, out lookAtPos);
}
else
{
Vector3 zero2 = Vector3.zero;
Vector3 end = getLookAtValueFunc(liveTimelineKeyCameraLookAtData2, this, zero2, config);
Vector3 cp = liveTimelineKeyCameraLookAtData2.GetBezierPoint(0, this, zero2);
Vector3 cp2 = liveTimelineKeyCameraLookAtData2.GetBezierPoint(1, this, zero2);
Vector3 cp3 = liveTimelineKeyCameraLookAtData2.GetBezierPoint(2, this, zero2);
switch (liveTimelineKeyCameraLookAtData2.GetBezierPointCount())
{
default:
lookAtPos = LerpWithoutClamp(getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config), getLookAtValueFunc(liveTimelineKeyCameraLookAtData2, this, position, config), t);
break;
case 1:
{
Vector3 start3 = getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config);
BezierUtil.Calc(ref start3, ref end, ref cp, t, out lookAtPos);
break;
}
case 2:
{
Vector3 start2 = getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config);
BezierUtil.Calc(ref start2, ref end, ref cp, ref cp2, t, out lookAtPos);
break;
}
case 3:
{
Vector3 start = getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config);
BezierUtil.Calc(ref start, ref end, ref cp, ref cp2, ref cp3, t, out lookAtPos);
break;
}
}
}
}
else
{
lookAtPos = getLookAtValueFunc(liveTimelineKeyCameraLookAtData, this, position, config);
}
if (_isNowAlterUpdate && liveTimelineKeyCameraLookAtData.attribute.hasFlag(LiveTimelineKeyAttribute.CameraDelayEnable) && (_oldFrame >= liveTimelineKeyCameraLookAtData.frame || currentFrame < liveTimelineKeyCameraLookAtData.frame || liveTimelineKeyCameraLookAtData.attribute.hasFlag(LiveTimelineKeyAttribute.CameraDelayInherit)))
{
Vector3 b = lookAtPos - camera.cacheTransform.position;
float magnitude = b.magnitude;
if (magnitude >= float.Epsilon)
{
b /= magnitude;
float t2 = liveTimelineKeyCameraLookAtData.traceSpeed * _deltaTimeRatio;
lookAtPos = position + Vector3.Slerp(camera.cacheTransform.forward, b, t2) * magnitude;
}
}
return true;
}
private void AlterUpdate_CameraFov(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (sheet.cameraFovKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.cameraFovKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
if (camera == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.cameraFovKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCameraFovData liveTimelineKeyCameraFovData = curKey as LiveTimelineKeyCameraFovData;
LiveTimelineKeyCameraFovData liveTimelineKeyCameraFovData2 = nextKey as LiveTimelineKeyCameraFovData;
float num = 80f;
if (liveTimelineKeyCameraFovData2 != null && liveTimelineKeyCameraFovData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraFovData, liveTimelineKeyCameraFovData2, currentFrame);
num = LerpWithoutClamp(liveTimelineKeyCameraFovData.fov, liveTimelineKeyCameraFovData2.fov, t);
}
else if (liveTimelineKeyCameraFovData.fovType == LiveCameraFovType.Direct)
{
num = liveTimelineKeyCameraFovData.fov;
}
if (_limitFovForWidth)
{
float num2 = (float)camera.camera.pixelWidth / (float)camera.camera.pixelHeight;
if (num2 > _baseCameraAspectRatio)
{
float num3 = num2 / _baseCameraAspectRatio;
num /= num3;
}
}
camera.camera.fieldOfView = num;
}
private void AlterUpdate_CameraRoll(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (sheet.cameraRollKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.cameraRollKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
CacheCamera camera = GetCamera(sheet.targetCameraIndex);
if (camera == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.cameraRollKeys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyCameraRollData liveTimelineKeyCameraRollData = curKey as LiveTimelineKeyCameraRollData;
LiveTimelineKeyCameraRollData liveTimelineKeyCameraRollData2 = nextKey as LiveTimelineKeyCameraRollData;
float num = 80f;
if (liveTimelineKeyCameraRollData2 != null && liveTimelineKeyCameraRollData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraRollData, liveTimelineKeyCameraRollData2, currentFrame);
num = LerpWithoutClamp(liveTimelineKeyCameraRollData.degree, liveTimelineKeyCameraRollData2.degree, t);
}
else
{
num = liveTimelineKeyCameraRollData.degree;
}
camera.cacheTransform.Rotate(0f, 0f, num);
}
}
private void AlterUpdate_CharaMotionSequence(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_motionSequenceArray == null)
{
return;
}
bool flag = true;
LiveTimelineKeyCharaMotionNoiseData liveTimelineKeyCharaMotionNoiseData = sheet.charaMotionNoiseKeys.FindKeyCached(currentFrame, availableFindKeyCache).key as LiveTimelineKeyCharaMotionNoiseData;
if (liveTimelineKeyCharaMotionNoiseData != null)
{
flag = !liveTimelineKeyCharaMotionNoiseData.IsNoiseDisable();
}
LiveTimelineKeyCharaCySpring liveTimelineKeyCharaCySpring = sheet.charaCySpringKeys.FindKeyCached(currentFrame, availableFindKeyCache).key as LiveTimelineKeyCharaCySpring;
bool flag2 = false;
if (liveTimelineKeyCharaCySpring != null && !liveTimelineKeyCharaCySpring._isExecute)
{
flag2 = true;
liveTimelineKeyCharaCySpring._isExecute = true;
}
if (this.OnUpdateCySpring == null)
{
flag2 = false;
}
float num = (float)currentFrame * 0.0166666675f;
CySpringUpdateInfo updateInfo = default(CySpringUpdateInfo);
for (int i = 0; i < liveCharaPositionMax; i++)
{
if (_motionSequenceArray[i] != null)
{
float num2 = num;
if (i > 0 && flag)
{
_charaMotNoiseTimeArray[i] += _deltaTime;
num2 += _chrMotNoiseBaseBias;
float f = _charaMotNoiseTimeArray[i] * kChrMotNoiseCurveRate;
num2 += _chrMotNoiseRange * Mathf.Cos(f);
}
if (num2 < 0f)
{
num2 = 0f;
}
_motionSequenceArray[i].AlterUpdate(num2, 60f);
}
if (flag2)
{
updateInfo.position = (LiveCharaPosition)i;
updateInfo.resetCySpring = liveTimelineKeyCharaCySpring.IsResetCharaFlag((LiveCharaPosition)i);
if (liveTimelineKeyCharaCySpring.IsOverrideParameterCharaFlag((LiveCharaPosition)i))
{
updateInfo.overrideParameter = true;
updateInfo.overrideParameterAllBone = liveTimelineKeyCharaCySpring._overrideAllBone[i];
updateInfo.overrideType = liveTimelineKeyCharaCySpring._overrideParameterType[i];
updateInfo.overrideParameterAcc = liveTimelineKeyCharaCySpring._overrideAccBone[i];
updateInfo.overrideParameterAccSitffness = liveTimelineKeyCharaCySpring._overrideAccStiffness[i];
updateInfo.overrideParameterFurisode = liveTimelineKeyCharaCySpring._overrideFurisodeBone[i];
updateInfo.overrideParameterFurisodeStiffness = liveTimelineKeyCharaCySpring._overrideFurisodeStiffness[i];
}
else
{
updateInfo.overrideParameter = false;
updateInfo.overrideParameterAllBone = true;
updateInfo.overrideParameterAcc = false;
updateInfo.overrideParameterAccSitffness = 0f;
updateInfo.overrideParameterFurisode = false;
updateInfo.overrideParameterFurisodeStiffness = 0f;
updateInfo.overrideType = LiveTimelineKeyCharaCySpring.ParameterType.Reset;
}
this.OnUpdateCySpring(ref updateInfo);
}
}
}
private void SetCharaIKUpdateInfo(out CharaIKUpdateInfo.PartUpdateInfo partUpdateInfo, LiveCharaPosition position, int index, LiveTimelineWorkSheet sheet, LiveTimelineKeyCharaIKData curData, float blendRate)
{
if (curData.enableIk[index])
{
partUpdateInfo.blendRate = blendRate;
partUpdateInfo.targetPosition = Vector3.zero;
partUpdateInfo.targetPositionType = StageTwoBoneIK.TargetType.Transform;
}
else
{
partUpdateInfo.blendRate = 0f;
partUpdateInfo.targetPosition = Vector3.zero;
partUpdateInfo.targetPositionType = StageTwoBoneIK.TargetType.Position;
}
}
private void AlterUpdate_IK(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateIK == null)
{
return;
}
LiveTimelineKeyCharaIKDataList[] iKKeyListArray = sheet.charaIkSet.GetIKKeyListArray();
int num = 0;
LiveTimelineKeyCharaIKDataList[] array = iKKeyListArray;
CharaIKUpdateInfo updateInfo = default(CharaIKUpdateInfo);
foreach (LiveTimelineKeyCharaIKDataList liveTimelineKeyCharaIKDataList in array)
{
if (liveTimelineKeyCharaIKDataList.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
updateInfo = default(CharaIKUpdateInfo);
updateInfo.position = (LiveCharaPosition)num;
this.OnUpdateIK(ref updateInfo);
num++;
}
else
{
if (liveCharactorLocators[num] == null)
{
continue;
}
if (!liveTimelineKeyCharaIKDataList.EnablePlayModeTimeline(_playMode))
{
num++;
continue;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, liveTimelineKeyCharaIKDataList, currentFrame);
if (curKey == null)
{
num++;
continue;
}
LiveTimelineKeyCharaIKData liveTimelineKeyCharaIKData = curKey as LiveTimelineKeyCharaIKData;
LiveTimelineKeyCharaIKData liveTimelineKeyCharaIKData2 = nextKey as LiveTimelineKeyCharaIKData;
LiveCharaPosition position = (updateInfo.position = (LiveCharaPosition)num);
if (liveTimelineKeyCharaIKData2 != null && liveTimelineKeyCharaIKData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCharaIKData, liveTimelineKeyCharaIKData2, currentFrame);
float blendRate = LerpWithoutClamp(liveTimelineKeyCharaIKData.blendRate[0], liveTimelineKeyCharaIKData2.blendRate[0], t);
SetCharaIKUpdateInfo(out updateInfo.leg_Left, position, 0, sheet, liveTimelineKeyCharaIKData, blendRate);
blendRate = LerpWithoutClamp(liveTimelineKeyCharaIKData.blendRate[1], liveTimelineKeyCharaIKData2.blendRate[1], t);
SetCharaIKUpdateInfo(out updateInfo.leg_Right, position, 1, sheet, liveTimelineKeyCharaIKData, blendRate);
blendRate = LerpWithoutClamp(liveTimelineKeyCharaIKData.blendRate[2], liveTimelineKeyCharaIKData2.blendRate[2], t);
SetCharaIKUpdateInfo(out updateInfo.arm_Left, position, 2, sheet, liveTimelineKeyCharaIKData, blendRate);
blendRate = LerpWithoutClamp(liveTimelineKeyCharaIKData.blendRate[3], liveTimelineKeyCharaIKData2.blendRate[3], t);
SetCharaIKUpdateInfo(out updateInfo.arm_Right, position, 3, sheet, liveTimelineKeyCharaIKData, blendRate);
}
else
{
SetCharaIKUpdateInfo(out updateInfo.leg_Left, position, 0, sheet, liveTimelineKeyCharaIKData, liveTimelineKeyCharaIKData.blendRate[0]);
SetCharaIKUpdateInfo(out updateInfo.leg_Right, position, 1, sheet, liveTimelineKeyCharaIKData, liveTimelineKeyCharaIKData.blendRate[1]);
SetCharaIKUpdateInfo(out updateInfo.arm_Left, position, 2, sheet, liveTimelineKeyCharaIKData, liveTimelineKeyCharaIKData.blendRate[2]);
SetCharaIKUpdateInfo(out updateInfo.arm_Right, position, 3, sheet, liveTimelineKeyCharaIKData, liveTimelineKeyCharaIKData.blendRate[3]);
}
this.OnUpdateIK(ref updateInfo);
num++;
}
}
}
private void AlterUpdate_CharaFootLight(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateCharaFootLight == null)
{
return;
}
CharaFootLightUpdateInfo updateInfo = default(CharaFootLightUpdateInfo);
if (sheet.charaFootLightKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
for (int i = 0; i < 15; i++)
{
updateInfo.position = (LiveCharaPosition)i;
updateInfo.hightMax = 1f;
updateInfo.lightColor = Color.black;
updateInfo.alphaBlend = false;
updateInfo.inverseAlpha = false;
this.OnUpdateCharaFootLight(ref updateInfo);
}
return;
}
FindTimelineKey(out var curKey, out var nextKey, sheet.charaFootLightKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCharaFootLightData liveTimelineKeyCharaFootLightData = curKey as LiveTimelineKeyCharaFootLightData;
LiveTimelineKeyCharaFootLightData liveTimelineKeyCharaFootLightData2 = nextKey as LiveTimelineKeyCharaFootLightData;
if (liveTimelineKeyCharaFootLightData2 != null && liveTimelineKeyCharaFootLightData2.interpolateType != 0)
{
for (int j = 0; j < 15; j++)
{
updateInfo.position = (LiveCharaPosition)j;
if (liveTimelineKeyCharaFootLightData.positionFlag.hasFlag((LiveCharaPosition)j))
{
float t = CalculateInterpolationValue(liveTimelineKeyCharaFootLightData, liveTimelineKeyCharaFootLightData2, currentFrame);
updateInfo.hightMax = LerpWithoutClamp(liveTimelineKeyCharaFootLightData.hightMax[j], liveTimelineKeyCharaFootLightData2.hightMax[j], t);
updateInfo.lightColor = LerpWithoutClamp(liveTimelineKeyCharaFootLightData.lightColor[j], liveTimelineKeyCharaFootLightData2.lightColor[j], t);
updateInfo.alphaBlend = liveTimelineKeyCharaFootLightData.alphaBlend[j];
updateInfo.inverseAlpha = liveTimelineKeyCharaFootLightData.inverseAlpha[j];
}
else
{
updateInfo.hightMax = 1f;
updateInfo.lightColor.r = 0f;
updateInfo.lightColor.g = 0f;
updateInfo.lightColor.b = 0f;
updateInfo.lightColor.a = 1f;
updateInfo.alphaBlend = false;
updateInfo.inverseAlpha = false;
}
this.OnUpdateCharaFootLight(ref updateInfo);
}
return;
}
for (int k = 0; k < 15; k++)
{
updateInfo.position = (LiveCharaPosition)k;
if (liveTimelineKeyCharaFootLightData.positionFlag.hasFlag((LiveCharaPosition)k))
{
updateInfo.hightMax = liveTimelineKeyCharaFootLightData.hightMax[k];
updateInfo.alphaBlend = liveTimelineKeyCharaFootLightData.alphaBlend[k];
updateInfo.inverseAlpha = liveTimelineKeyCharaFootLightData.inverseAlpha[k];
updateInfo.lightColor = liveTimelineKeyCharaFootLightData.lightColor[k];
}
else
{
updateInfo.hightMax = 1f;
updateInfo.lightColor.r = 0f;
updateInfo.lightColor.g = 0f;
updateInfo.lightColor.b = 0f;
updateInfo.lightColor.a = 1f;
updateInfo.alphaBlend = false;
updateInfo.inverseAlpha = false;
}
this.OnUpdateCharaFootLight(ref updateInfo);
}
}
private void AlterUpdate_StageGazeControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateStageGazeControl == null)
{
return;
}
int count = sheet.stageGazeList.Count;
StageGazeControlUpdateInfo updateInfo = default(StageGazeControlUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineStageGazeData liveTimelineStageGazeData = sheet.stageGazeList[i];
LiveTimelineKeyStageGazeDataList keys = liveTimelineStageGazeData.keys;
if (!keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && keys.EnablePlayModeTimeline(_playMode))
{
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey == null)
{
break;
}
LiveTimelineKeyStageGazeData liveTimelineKeyStageGazeData = curKey as LiveTimelineKeyStageGazeData;
LiveTimelineKeyStageGazeData liveTimelineKeyStageGazeData2 = nextKey as LiveTimelineKeyStageGazeData;
updateInfo.isEnable = liveTimelineKeyStageGazeData.isEnable;
updateInfo.groupNo = liveTimelineStageGazeData.groupNo;
if (liveTimelineKeyStageGazeData2 != null && liveTimelineKeyStageGazeData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyStageGazeData, liveTimelineKeyStageGazeData2, currentFrame);
updateInfo.targetPosition = LerpWithoutClamp(liveTimelineKeyStageGazeData.targetPosition, liveTimelineKeyStageGazeData2.targetPosition, t);
}
else
{
updateInfo.targetPosition = liveTimelineKeyStageGazeData.targetPosition;
}
this.OnUpdateStageGazeControl(ref updateInfo);
}
}
}
private void AlterUpdate_MobCyalume(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateMobCyalume == null)
{
return;
}
MobCyalumeUpdateInfo updateInfo = default(MobCyalumeUpdateInfo);
int num = Math.Min(sheet.mobCyalumeDataList.Count, 11);
for (int i = 0; i < num; i++)
{
updateInfo.groupNo = i;
LiveTimelineKeyMobCyalumeDataList keys = sheet.mobCyalumeDataList[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
updateInfo.translate = Vector3.zero;
updateInfo.rotate = Vector3.zero;
updateInfo.scale = Vector3.one;
updateInfo.isVisibleMob = true;
updateInfo.isVisibleCyalume = true;
this.OnUpdateMobCyalume(ref updateInfo);
continue;
}
FindTimelineKey(out var curKey, out var nextKey, keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyMobCyalumeData liveTimelineKeyMobCyalumeData = curKey as LiveTimelineKeyMobCyalumeData;
LiveTimelineKeyMobCyalumeData liveTimelineKeyMobCyalumeData2 = nextKey as LiveTimelineKeyMobCyalumeData;
updateInfo.isVisibleMob = liveTimelineKeyMobCyalumeData.isMobVisible;
updateInfo.isVisibleCyalume = liveTimelineKeyMobCyalumeData.isCyalumeVisible;
if (liveTimelineKeyMobCyalumeData2 != null && liveTimelineKeyMobCyalumeData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMobCyalumeData, liveTimelineKeyMobCyalumeData2, currentFrame);
updateInfo.translate = LerpWithoutClamp(liveTimelineKeyMobCyalumeData.translate, liveTimelineKeyMobCyalumeData2.translate, t);
updateInfo.rotate = LerpWithoutClamp(liveTimelineKeyMobCyalumeData.rotate, liveTimelineKeyMobCyalumeData2.rotate, t);
updateInfo.scale = LerpWithoutClamp(liveTimelineKeyMobCyalumeData.scale, liveTimelineKeyMobCyalumeData2.scale, t);
}
else
{
updateInfo.translate = liveTimelineKeyMobCyalumeData.translate;
updateInfo.rotate = liveTimelineKeyMobCyalumeData.rotate;
updateInfo.scale = liveTimelineKeyMobCyalumeData.scale;
}
this.OnUpdateMobCyalume(ref updateInfo);
}
}
}
private void AlterUpdate_MobCyalume3D(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateMobCyalume3D == null)
{
return;
}
MobCyalume3DUpdateInfo updateInfo = default(MobCyalume3DUpdateInfo);
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.mobCyalume3DRootKeys, currentFrame);
if (curKey == null)
{
updateInfo.rootTranslate = Vector3.zero;
updateInfo.rootRotate = Vector3.zero;
updateInfo.rootScale = Vector3.one;
updateInfo.isVisibleMob = true;
updateInfo.isVisibleCyalume = true;
updateInfo.isEnableMotionMultiSample = false;
updateInfo.motionTimeOffset = 0f;
updateInfo.motionTimeInterval = 1f;
updateInfo.waveMode = LiveMobCyalume3DWaveMode.None;
updateInfo.waveBasePosition = Vector3.zero;
updateInfo.waveWidth = 5f;
updateInfo.waveHeight = 1f;
updateInfo.waveRoughness = 0f;
updateInfo.waveProgress = 0f;
updateInfo.waveColorBasePower = 1f;
updateInfo.waveColorGainPower = 0f;
}
else
{
LiveTimelineKeyMobCyalume3DRootData liveTimelineKeyMobCyalume3DRootData = curKey as LiveTimelineKeyMobCyalume3DRootData;
LiveTimelineKeyMobCyalume3DRootData liveTimelineKeyMobCyalume3DRootData2 = nextKey as LiveTimelineKeyMobCyalume3DRootData;
if (liveTimelineKeyMobCyalume3DRootData2 != null && liveTimelineKeyMobCyalume3DRootData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMobCyalume3DRootData, liveTimelineKeyMobCyalume3DRootData2, currentFrame);
updateInfo.rootTranslate = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.translate, liveTimelineKeyMobCyalume3DRootData2.translate, t);
updateInfo.rootRotate = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.rotate, liveTimelineKeyMobCyalume3DRootData2.rotate, t);
updateInfo.rootScale = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.scale, liveTimelineKeyMobCyalume3DRootData2.scale, t);
updateInfo.motionTimeOffset = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.motionTimeOffset, liveTimelineKeyMobCyalume3DRootData2.motionTimeOffset, t);
updateInfo.motionTimeInterval = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.motionTimeInterval, liveTimelineKeyMobCyalume3DRootData2.motionTimeInterval, t);
updateInfo.waveBasePosition = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveBasePosition, liveTimelineKeyMobCyalume3DRootData2.waveBasePosition, t);
updateInfo.waveWidth = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveWidth, liveTimelineKeyMobCyalume3DRootData2.waveWidth, t);
updateInfo.waveHeight = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveHeight, liveTimelineKeyMobCyalume3DRootData2.waveHeight, t);
updateInfo.waveRoughness = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveRoughness, liveTimelineKeyMobCyalume3DRootData2.waveRoughness, t);
updateInfo.waveProgress = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveProgress, liveTimelineKeyMobCyalume3DRootData2.waveProgress, t);
updateInfo.waveColorBasePower = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveColorBasePower, liveTimelineKeyMobCyalume3DRootData2.waveColorBasePower, t);
updateInfo.waveColorGainPower = LerpWithoutClamp(liveTimelineKeyMobCyalume3DRootData.waveColorGainPower, liveTimelineKeyMobCyalume3DRootData2.waveColorGainPower, t);
}
else
{
updateInfo.rootTranslate = liveTimelineKeyMobCyalume3DRootData.translate;
updateInfo.rootRotate = liveTimelineKeyMobCyalume3DRootData.rotate;
updateInfo.rootScale = liveTimelineKeyMobCyalume3DRootData.scale;
updateInfo.motionTimeOffset = liveTimelineKeyMobCyalume3DRootData.motionTimeOffset;
updateInfo.motionTimeInterval = liveTimelineKeyMobCyalume3DRootData.motionTimeInterval;
updateInfo.waveBasePosition = liveTimelineKeyMobCyalume3DRootData.waveBasePosition;
updateInfo.waveWidth = liveTimelineKeyMobCyalume3DRootData.waveWidth;
updateInfo.waveHeight = liveTimelineKeyMobCyalume3DRootData.waveHeight;
updateInfo.waveRoughness = liveTimelineKeyMobCyalume3DRootData.waveRoughness;
updateInfo.waveProgress = liveTimelineKeyMobCyalume3DRootData.waveProgress;
updateInfo.waveColorBasePower = liveTimelineKeyMobCyalume3DRootData.waveColorBasePower;
updateInfo.waveColorGainPower = liveTimelineKeyMobCyalume3DRootData.waveColorGainPower;
}
updateInfo.isVisibleMob = liveTimelineKeyMobCyalume3DRootData.isVisibleMob;
updateInfo.isVisibleCyalume = liveTimelineKeyMobCyalume3DRootData.isVisibleCyalume;
updateInfo.isEnableMotionMultiSample = liveTimelineKeyMobCyalume3DRootData.isEnableMotionMultiSample;
updateInfo.waveMode = liveTimelineKeyMobCyalume3DRootData.waveMode;
}
LiveTimelineKey curKey2 = null;
LiveTimelineKey nextKey2 = null;
FindTimelineKey(out curKey2, out nextKey2, sheet.mobCyalume3DLightingKeys, currentFrame);
if (curKey2 == null)
{
updateInfo.gradiation = 0.05f;
updateInfo.rimlight = 6f;
updateInfo.blendRange = 20f;
}
else
{
LiveTimelineKeyMobCyalume3DLightingData liveTimelineKeyMobCyalume3DLightingData = curKey2 as LiveTimelineKeyMobCyalume3DLightingData;
LiveTimelineKeyMobCyalume3DLightingData liveTimelineKeyMobCyalume3DLightingData2 = nextKey2 as LiveTimelineKeyMobCyalume3DLightingData;
if (liveTimelineKeyMobCyalume3DLightingData2 != null && liveTimelineKeyMobCyalume3DLightingData2.interpolateType != 0)
{
float t2 = CalculateInterpolationValue(liveTimelineKeyMobCyalume3DLightingData, liveTimelineKeyMobCyalume3DLightingData2, currentFrame);
updateInfo.gradiation = LerpWithoutClamp(liveTimelineKeyMobCyalume3DLightingData.gradiation, liveTimelineKeyMobCyalume3DLightingData2.gradiation, t2);
updateInfo.rimlight = LerpWithoutClamp(liveTimelineKeyMobCyalume3DLightingData.rimlight, liveTimelineKeyMobCyalume3DLightingData2.rimlight, t2);
updateInfo.blendRange = LerpWithoutClamp(liveTimelineKeyMobCyalume3DLightingData.blendRange, liveTimelineKeyMobCyalume3DLightingData2.blendRange, t2);
}
else
{
updateInfo.gradiation = liveTimelineKeyMobCyalume3DLightingData.gradiation;
updateInfo.rimlight = liveTimelineKeyMobCyalume3DLightingData.rimlight;
updateInfo.blendRange = liveTimelineKeyMobCyalume3DLightingData.blendRange;
}
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int num = -1;
LiveTimelineKeyMobCyalume3DColorDataList mobCyalume3DColorKeys = sheet.mobCyalume3DColorKeys;
FindKeyResult findKeyResult = mobCyalume3DColorKeys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
num = findKeyResult.index;
liveTimelineKey2 = mobCyalume3DColorKeys.At(num + 1);
}
else
{
liveTimelineKey2 = null;
}
if (liveTimelineKey == null)
{
updateInfo.paletteScrollSection = 0f;
}
else
{
int frame = liveTimelineKey.frame;
int num2 = liveTimelineKey2?.frame ?? frame;
bool num3 = liveTimelineKey2?.IsInterpolateKey() ?? false;
float num4 = 0f;
num4 = ((num3 || (frame != num2 && frame + 120 > num2)) ? ((float)num + (float)(currentFrame - frame) / (float)(num2 - frame) - 0.5f) : ((currentFrame < frame + 60) ? ((float)num + (float)(currentFrame - frame) / 120f - 0.5f) : ((frame == num2 || num2 - 60 >= currentFrame) ? ((float)num) : ((float)(num + 1) - (float)(num2 - currentFrame) / 120f - 0.5f))));
if (num4 < 0f)
{
num4 = 0f;
}
updateInfo.paletteScrollSection = num4;
}
LiveTimelineKey curKey3 = null;
LiveTimelineKey nextKey3 = null;
FindTimelineKey(out curKey3, out nextKey3, sheet.mobCyalume3DBloomKeys, currentFrame);
if (curKey3 == null)
{
updateInfo.horizontalOffset = 2.4f;
updateInfo.verticalOffset = 0.6f;
updateInfo.threshold = 1f;
updateInfo.growPower = 1.4f;
}
else
{
LiveTimelineKeyMobCyalume3DBloomData liveTimelineKeyMobCyalume3DBloomData = curKey3 as LiveTimelineKeyMobCyalume3DBloomData;
LiveTimelineKeyMobCyalume3DBloomData liveTimelineKeyMobCyalume3DBloomData2 = nextKey3 as LiveTimelineKeyMobCyalume3DBloomData;
if (liveTimelineKeyMobCyalume3DBloomData2 != null && liveTimelineKeyMobCyalume3DBloomData2.interpolateType != 0)
{
float t3 = CalculateInterpolationValue(liveTimelineKeyMobCyalume3DBloomData, liveTimelineKeyMobCyalume3DBloomData2, currentFrame);
updateInfo.horizontalOffset = LerpWithoutClamp(liveTimelineKeyMobCyalume3DBloomData.horizontalOffset, liveTimelineKeyMobCyalume3DBloomData2.horizontalOffset, t3);
updateInfo.verticalOffset = LerpWithoutClamp(liveTimelineKeyMobCyalume3DBloomData.verticalOffset, liveTimelineKeyMobCyalume3DBloomData2.verticalOffset, t3);
updateInfo.threshold = LerpWithoutClamp(liveTimelineKeyMobCyalume3DBloomData.threshold, liveTimelineKeyMobCyalume3DBloomData2.threshold, t3);
updateInfo.growPower = LerpWithoutClamp(liveTimelineKeyMobCyalume3DBloomData.growPower, liveTimelineKeyMobCyalume3DBloomData2.growPower, t3);
}
else
{
updateInfo.horizontalOffset = liveTimelineKeyMobCyalume3DBloomData.horizontalOffset;
updateInfo.verticalOffset = liveTimelineKeyMobCyalume3DBloomData.verticalOffset;
updateInfo.threshold = liveTimelineKeyMobCyalume3DBloomData.threshold;
updateInfo.growPower = liveTimelineKeyMobCyalume3DBloomData.growPower;
}
}
LiveTimelineKey curKey4 = null;
LiveTimelineKey nextKey4 = null;
FindTimelineKey(out curKey4, out nextKey4, sheet.mobCyalume3DLookAtModeKeys, currentFrame);
if (curKey4 == null)
{
updateInfo.lookAtMode = LiveMobCyalume3DLookAtMode.Locator;
}
else
{
LiveTimelineKeyMobCyalume3DLookAtModeData liveTimelineKeyMobCyalume3DLookAtModeData = curKey4 as LiveTimelineKeyMobCyalume3DLookAtModeData;
updateInfo.lookAtMode = liveTimelineKeyMobCyalume3DLookAtModeData.lookAtMode;
}
int num5 = (updateInfo.lookAtPositionCount = Math.Min(sheet.mobCyalume3DLookAtPositionDataList.Count, 11));
updateInfo.lookAtPositionList = _arrMobCyalume3DLookAtPosition;
for (int i = 0; i < num5; i++)
{
LiveTimelineKeyMobCyalume3DLookAtPositionDataList keys = sheet.mobCyalume3DLookAtPositionDataList[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
updateInfo.lookAtPositionList[i] = Vector3.zero;
continue;
}
FindTimelineKey(out var curKey5, out var nextKey5, keys, currentFrame);
if (curKey5 != null)
{
LiveTimelineKeyMobCyalume3DLookAtPositionData liveTimelineKeyMobCyalume3DLookAtPositionData = curKey5 as LiveTimelineKeyMobCyalume3DLookAtPositionData;
LiveTimelineKeyMobCyalume3DLookAtPositionData liveTimelineKeyMobCyalume3DLookAtPositionData2 = nextKey5 as LiveTimelineKeyMobCyalume3DLookAtPositionData;
if (liveTimelineKeyMobCyalume3DLookAtPositionData2 != null && liveTimelineKeyMobCyalume3DLookAtPositionData2.interpolateType != 0)
{
float t4 = CalculateInterpolationValue(liveTimelineKeyMobCyalume3DLookAtPositionData, liveTimelineKeyMobCyalume3DLookAtPositionData2, currentFrame);
updateInfo.lookAtPositionList[i] = LerpWithoutClamp(liveTimelineKeyMobCyalume3DLookAtPositionData.translate, liveTimelineKeyMobCyalume3DLookAtPositionData2.translate, t4);
}
else
{
updateInfo.lookAtPositionList[i] = liveTimelineKeyMobCyalume3DLookAtPositionData.translate;
}
}
}
num5 = (updateInfo.positionCount = Math.Min(sheet.mobCyalume3DPositionDataList.Count, 11));
updateInfo.positionList = _arrMobCyalume3DPosition;
for (int j = 0; j < num5; j++)
{
LiveTimelineKeyMobCyalume3DPositionDataList keys2 = sheet.mobCyalume3DPositionDataList[j].keys;
if (keys2.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
updateInfo.positionList[j] = Vector3.zero;
continue;
}
FindTimelineKey(out var curKey6, out var nextKey6, keys2, currentFrame);
if (curKey6 != null)
{
LiveTimelineKeyMobCyalume3DPositionData liveTimelineKeyMobCyalume3DPositionData = curKey6 as LiveTimelineKeyMobCyalume3DPositionData;
LiveTimelineKeyMobCyalume3DPositionData liveTimelineKeyMobCyalume3DPositionData2 = nextKey6 as LiveTimelineKeyMobCyalume3DPositionData;
if (liveTimelineKeyMobCyalume3DPositionData2 != null && liveTimelineKeyMobCyalume3DPositionData2.interpolateType != 0)
{
float t5 = CalculateInterpolationValue(liveTimelineKeyMobCyalume3DPositionData, liveTimelineKeyMobCyalume3DPositionData2, currentFrame);
updateInfo.positionList[j] = LerpWithoutClamp(liveTimelineKeyMobCyalume3DPositionData.translate, liveTimelineKeyMobCyalume3DPositionData2.translate, t5);
}
else
{
updateInfo.positionList[j] = liveTimelineKeyMobCyalume3DPositionData.translate;
}
}
}
this.OnUpdateMobCyalume3D(ref updateInfo);
}
private void AlterUpdate_Event(LiveTimelineWorkSheet sheet, int currentFrame, int oldFrame)
{
if (sheet.eventKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.eventKeys.EnablePlayModeTimeline(_playMode) || currentFrame <= oldFrame)
{
return;
}
LiveTimelineKey triggeredKey = null;
FindTimelineKeyTrigger(out triggeredKey, sheet.eventKeys, currentFrame, oldFrame);
if (triggeredKey != null && triggeredKey.attribute.hasFlag(LiveTimelineKeyAttribute.Disable))
{
triggeredKey = null;
}
if (triggeredKey == null)
{
return;
}
if (oldFrame <= lastTriggeredEventFrame && lastTriggeredEventFrame <= currentFrame)
{
lastTriggeredEventFrame = -1;
return;
}
LiveTimelineKeyEventData liveTimelineKeyEventData = triggeredKey as LiveTimelineKeyEventData;
if (liveTimelineKeyEventData != null)
{
lastTriggeredEventFrame = triggeredKey.frame;
eventPublisher.FireEvent(liveTimelineKeyEventData);
}
}
private void AlterUpdate_BgColor1(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateBgColor1 == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
BgColor1UpdateInfo updateInfo = default(BgColor1UpdateInfo);
for (int i = 0; i < sheet.bgColor1List.Count; i++)
{
LiveTimelineBgColor1Data liveTimelineBgColor1Data = sheet.bgColor1List[i];
if (liveTimelineBgColor1Data.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineBgColor1Data.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineBgColor1Data.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyBgColor1Data liveTimelineKeyBgColor1Data = curKey as LiveTimelineKeyBgColor1Data;
LiveTimelineKeyBgColor1Data liveTimelineKeyBgColor1Data2 = nextKey as LiveTimelineKeyBgColor1Data;
if (liveTimelineKeyBgColor1Data2 != null && liveTimelineKeyBgColor1Data2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyBgColor1Data, liveTimelineKeyBgColor1Data2, currentFrame);
updateInfo.color = LerpWithoutClamp(liveTimelineKeyBgColor1Data.color, liveTimelineKeyBgColor1Data2.color, t);
updateInfo.value = LerpWithoutClamp(liveTimelineKeyBgColor1Data.f32, liveTimelineKeyBgColor1Data2.f32, t);
}
else
{
updateInfo.color = liveTimelineKeyBgColor1Data.color;
updateInfo.value = liveTimelineKeyBgColor1Data.f32;
}
updateInfo.data = liveTimelineBgColor1Data;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyBgColor1Data.frame) * 0.0166666675f;
updateInfo.flags = liveTimelineKeyBgColor1Data.flags;
this.OnUpdateBgColor1(ref updateInfo);
}
}
}
private void AlterUpdate_BgColor2(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateBgColor2 == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
BgColor2UpdateInfo updateInfo = default(BgColor2UpdateInfo);
for (int i = 0; i < sheet.bgColor2List.Count; i++)
{
LiveTimelineBgColor2Data liveTimelineBgColor2Data = sheet.bgColor2List[i];
if (liveTimelineBgColor2Data.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineBgColor2Data.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineBgColor2Data.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyBgColor2Data liveTimelineKeyBgColor2Data = curKey as LiveTimelineKeyBgColor2Data;
LiveTimelineKeyBgColor2Data liveTimelineKeyBgColor2Data2 = nextKey as LiveTimelineKeyBgColor2Data;
if (liveTimelineKeyBgColor2Data2 != null && liveTimelineKeyBgColor2Data2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyBgColor2Data, liveTimelineKeyBgColor2Data2, currentFrame);
updateInfo.color1 = LerpWithoutClamp(liveTimelineKeyBgColor2Data.color1, liveTimelineKeyBgColor2Data2.color1, t);
updateInfo.color2 = LerpWithoutClamp(liveTimelineKeyBgColor2Data.color2, liveTimelineKeyBgColor2Data2.color2, t);
updateInfo.value = LerpWithoutClamp(liveTimelineKeyBgColor2Data.f32, liveTimelineKeyBgColor2Data2.f32, t);
updateInfo.enableManualAngle = liveTimelineKeyBgColor2Data.manualAngle;
updateInfo.manualRotation = Quaternion.Lerp(liveTimelineKeyBgColor2Data.manualRotation, liveTimelineKeyBgColor2Data2.manualRotation, t);
}
else
{
updateInfo.color1 = liveTimelineKeyBgColor2Data.color1;
updateInfo.color2 = liveTimelineKeyBgColor2Data.color2;
updateInfo.value = liveTimelineKeyBgColor2Data.f32;
updateInfo.enableManualAngle = liveTimelineKeyBgColor2Data.manualAngle;
updateInfo.manualRotation = liveTimelineKeyBgColor2Data.manualRotation;
}
updateInfo.data = liveTimelineBgColor2Data;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyBgColor2Data.frame) * 0.0166666675f;
updateInfo.rndValueIdx = liveTimelineKeyBgColor2Data.RandomTableIndex();
updateInfo.groupIndex = liveTimelineBgColor2Data.groupNo;
this.OnUpdateBgColor2(ref updateInfo);
}
}
}
private void AlterUpdate_BgColor3(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateBgColor3 == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
for (int i = 0; i < sheet.bgColor3List.Count; i++)
{
LiveTimelineBgColor3Data liveTimelineBgColor3Data = sheet.bgColor3List[i];
if (liveTimelineBgColor3Data.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineBgColor3Data.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineBgColor3Data.keys, currentFrame);
if (curKey == null)
{
continue;
}
LiveTimelineKeyBgColor3Data liveTimelineKeyBgColor3Data = curKey as LiveTimelineKeyBgColor3Data;
LiveTimelineKeyBgColor3Data liveTimelineKeyBgColor3Data2 = nextKey as LiveTimelineKeyBgColor3Data;
if (liveTimelineKeyBgColor3Data2 != null && liveTimelineKeyBgColor3Data2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyBgColor3Data, liveTimelineKeyBgColor3Data2, currentFrame);
for (int j = 0; j < _bgColor3UpdateInfo.colorArray.Length; j++)
{
_bgColor3UpdateInfo.colorArray[j] = LerpWithoutClamp(liveTimelineKeyBgColor3Data._colorArray[j], liveTimelineKeyBgColor3Data2._colorArray[j], t);
}
}
else
{
for (int k = 0; k < _bgColor3UpdateInfo.colorArray.Length; k++)
{
_bgColor3UpdateInfo.colorArray[k] = liveTimelineKeyBgColor3Data._colorArray[k];
}
}
_bgColor3UpdateInfo.data = liveTimelineBgColor3Data;
_bgColor3UpdateInfo.progressTime = (float)(currentFrame - liveTimelineKeyBgColor3Data.frame) * 0.0166666675f;
this.OnUpdateBgColor3(ref _bgColor3UpdateInfo);
}
}
/// <summary>
/// VolumeLight(Sunshuft)�pAlterUpdate
/// </summary>
private void AlterUpdate_VolumeLight(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateVolumeLight == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
float num = 0.0166666675f;
VolumeLightUpdateInfo updateInfo = default(VolumeLightUpdateInfo);
for (int i = 0; i < sheet.VolumeLightKeys.Count; i++)
{
LiveTimelineVolumeLightData liveTimelineVolumeLightData = sheet.VolumeLightKeys[i];
if (liveTimelineVolumeLightData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineVolumeLightData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyVolumeLightData liveTimelineKeyVolumeLightData = curKey as LiveTimelineKeyVolumeLightData;
LiveTimelineKeyVolumeLightData liveTimelineKeyVolumeLightData2 = nextKey as LiveTimelineKeyVolumeLightData;
if (liveTimelineKeyVolumeLightData2 != null && liveTimelineKeyVolumeLightData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyVolumeLightData, liveTimelineKeyVolumeLightData2, currentFrame);
updateInfo.sunPosition = LerpWithoutClamp(liveTimelineKeyVolumeLightData.sunPosition, liveTimelineKeyVolumeLightData2.sunPosition, t);
updateInfo.color1 = LerpWithoutClamp(liveTimelineKeyVolumeLightData.color1, liveTimelineKeyVolumeLightData2.color1, t);
updateInfo.power = LerpWithoutClamp(liveTimelineKeyVolumeLightData.power, liveTimelineKeyVolumeLightData2.power, t);
updateInfo.blurRadius = LerpWithoutClamp(liveTimelineKeyVolumeLightData.blurRadius, liveTimelineKeyVolumeLightData2.blurRadius, t);
}
else
{
updateInfo.sunPosition = liveTimelineKeyVolumeLightData.sunPosition;
updateInfo.color1 = liveTimelineKeyVolumeLightData.color1;
updateInfo.power = liveTimelineKeyVolumeLightData.power;
updateInfo.blurRadius = liveTimelineKeyVolumeLightData.blurRadius;
}
updateInfo.enable = liveTimelineKeyVolumeLightData.enable;
updateInfo.komorebi = liveTimelineKeyVolumeLightData.komorebi;
updateInfo.isEnabledBorderClear = liveTimelineKeyVolumeLightData.isEnabledBorderClear;
updateInfo.data = liveTimelineVolumeLightData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyVolumeLightData.frame) * num;
this.OnUpdateVolumeLight(ref updateInfo);
}
}
}
/// <summary>
/// HdrBloom�pAlterUpdate
/// </summary>
private void AlterUpdate_HdrBloom(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateHdrBloom == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
float num = 0.0166666675f;
HdrBloomUpdateInfo updateInfo = default(HdrBloomUpdateInfo);
for (int i = 0; i < sheet.HdrBloomKeys.Count; i++)
{
LiveTimelineHdrBloomData liveTimelineHdrBloomData = sheet.HdrBloomKeys[i];
if (liveTimelineHdrBloomData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineHdrBloomData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyHdrBloomData liveTimelineKeyHdrBloomData = curKey as LiveTimelineKeyHdrBloomData;
LiveTimelineKeyHdrBloomData liveTimelineKeyHdrBloomData2 = nextKey as LiveTimelineKeyHdrBloomData;
if (liveTimelineKeyHdrBloomData2 != null && liveTimelineKeyHdrBloomData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyHdrBloomData, liveTimelineKeyHdrBloomData2, currentFrame);
updateInfo.intensity = LerpWithoutClamp(liveTimelineKeyHdrBloomData.intensity, liveTimelineKeyHdrBloomData2.intensity, t);
updateInfo.blurSpread = LerpWithoutClamp(liveTimelineKeyHdrBloomData.blurSpread, liveTimelineKeyHdrBloomData2.blurSpread, t);
}
else
{
updateInfo.intensity = liveTimelineKeyHdrBloomData.intensity;
updateInfo.blurSpread = liveTimelineKeyHdrBloomData.blurSpread;
}
updateInfo.enable = liveTimelineKeyHdrBloomData.enable;
updateInfo.data = liveTimelineHdrBloomData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyHdrBloomData.frame) * num;
this.OnUpdateHdrBloom(ref updateInfo);
}
}
}
private void AlterUpdate_MonitorControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateMonitorControl == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
MonitorControlUpdateInfo updateInfo = default(MonitorControlUpdateInfo);
for (int i = 0; i < sheet.monitorControlList.Count; i++)
{
LiveTimelineMonitorControlData liveTimelineMonitorControlData = sheet.monitorControlList[i];
if (liveTimelineMonitorControlData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineMonitorControlData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineMonitorControlData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyMonitorControlData liveTimelineKeyMonitorControlData = curKey as LiveTimelineKeyMonitorControlData;
LiveTimelineKeyMonitorControlData liveTimelineKeyMonitorControlData2 = nextKey as LiveTimelineKeyMonitorControlData;
if (liveTimelineKeyMonitorControlData2 != null && liveTimelineKeyMonitorControlData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMonitorControlData, liveTimelineKeyMonitorControlData2, currentFrame);
updateInfo.pos = LerpWithoutClamp(liveTimelineKeyMonitorControlData.position, liveTimelineKeyMonitorControlData2.position, t);
updateInfo.size = LerpWithoutClamp(liveTimelineKeyMonitorControlData.size, liveTimelineKeyMonitorControlData2.size, t);
updateInfo.speed = LerpWithoutClamp(liveTimelineKeyMonitorControlData.speed, liveTimelineKeyMonitorControlData2.speed, t);
updateInfo.blendFactor = LerpWithoutClamp(liveTimelineKeyMonitorControlData.blendFactor, liveTimelineKeyMonitorControlData2.blendFactor, t);
updateInfo.colorPower = LerpWithoutClamp(liveTimelineKeyMonitorControlData.colorPower, liveTimelineKeyMonitorControlData2.colorPower, t);
}
else
{
updateInfo.pos = liveTimelineKeyMonitorControlData.position;
updateInfo.size = liveTimelineKeyMonitorControlData.size;
updateInfo.speed = liveTimelineKeyMonitorControlData.speed;
updateInfo.blendFactor = liveTimelineKeyMonitorControlData.blendFactor;
updateInfo.colorPower = liveTimelineKeyMonitorControlData.colorPower;
}
updateInfo.multiFlag = liveTimelineKeyMonitorControlData.attribute.hasFlag((LiveTimelineKeyAttribute)65536);
updateInfo.dispID = liveTimelineKeyMonitorControlData.dispID;
updateInfo.subDispID = liveTimelineKeyMonitorControlData.subDispID;
updateInfo.reversePlayFlag = liveTimelineKeyMonitorControlData.attribute.hasFlag((LiveTimelineKeyAttribute)131072);
updateInfo.inputSource = liveTimelineKeyMonitorControlData.inputSource;
updateInfo.data = liveTimelineMonitorControlData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyMonitorControlData.frame) * 0.0166666675f;
updateInfo.textureLabel = liveTimelineKeyMonitorControlData.outputTextureLabel;
updateInfo.playStartOffsetFrame = liveTimelineKeyMonitorControlData.playStartOffsetFrame;
this.OnUpdateMonitorControl(ref updateInfo);
}
}
}
private void AlterUpdate_AnimationControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateAnimation == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
AnimationUpdateInfo updateInfo = default(AnimationUpdateInfo);
for (int i = 0; i < sheet.animationList.Count; i++)
{
LiveTimelineAnimationData liveTimelineAnimationData = sheet.animationList[i];
if (liveTimelineAnimationData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineAnimationData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineAnimationData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyAnimationData liveTimelineKeyAnimationData = curKey as LiveTimelineKeyAnimationData;
LiveTimelineKeyAnimationData liveTimelineKeyAnimationData2 = nextKey as LiveTimelineKeyAnimationData;
if (liveTimelineKeyAnimationData2 != null && liveTimelineKeyAnimationData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyAnimationData, liveTimelineKeyAnimationData2, currentFrame);
updateInfo.speed = LerpWithoutClamp(liveTimelineKeyAnimationData.speed, liveTimelineKeyAnimationData2.speed, t);
}
else
{
updateInfo.speed = liveTimelineKeyAnimationData.speed;
}
updateInfo.animationID = liveTimelineKeyAnimationData.animationID;
updateInfo.wrapMode = liveTimelineKeyAnimationData.wrapMode;
updateInfo.speed = liveTimelineKeyAnimationData.speed;
updateInfo.offsetTime = liveTimelineKeyAnimationData.offsetTime;
updateInfo.data = liveTimelineAnimationData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyAnimationData.frame) * 0.0166666675f;
this.OnUpdateAnimation(ref updateInfo);
}
}
}
private void AlterUpdate_TextureAnimationControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateTextureAnimation == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
TextureAnimationUpdateInfo updateInfo = default(TextureAnimationUpdateInfo);
for (int i = 0; i < sheet.textureAnimationList.Count; i++)
{
LiveTimelineTextureAnimationData liveTimelineTextureAnimationData = sheet.textureAnimationList[i];
if (liveTimelineTextureAnimationData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineTextureAnimationData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineTextureAnimationData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyTextureAnimationData liveTimelineKeyTextureAnimationData = curKey as LiveTimelineKeyTextureAnimationData;
LiveTimelineKeyTextureAnimationData liveTimelineKeyTextureAnimationData2 = nextKey as LiveTimelineKeyTextureAnimationData;
if (liveTimelineKeyTextureAnimationData2 != null && liveTimelineKeyTextureAnimationData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyTextureAnimationData, liveTimelineKeyTextureAnimationData2, currentFrame);
updateInfo.scrollSpeed = LerpWithoutClamp(liveTimelineKeyTextureAnimationData.scrollSpeed, liveTimelineKeyTextureAnimationData2.scrollSpeed, t);
updateInfo.scrollInterval = LerpWithoutClamp(liveTimelineKeyTextureAnimationData.scrollInterval, liveTimelineKeyTextureAnimationData2.scrollInterval, t);
}
else
{
updateInfo.scrollSpeed = liveTimelineKeyTextureAnimationData.scrollSpeed;
updateInfo.scrollInterval = liveTimelineKeyTextureAnimationData.scrollInterval;
}
updateInfo.textureName = liveTimelineKeyTextureAnimationData.textureName;
updateInfo.textureNameEmpty = liveTimelineKeyTextureAnimationData.textureNameEmpty;
updateInfo.offset = liveTimelineKeyTextureAnimationData.offset;
updateInfo.tiling = liveTimelineKeyTextureAnimationData.tiling;
updateInfo.textureID = liveTimelineKeyTextureAnimationData.textureID;
updateInfo.data = liveTimelineTextureAnimationData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyTextureAnimationData.frame) * 0.0166666675f;
this.OnUpdateTextureAnimation(ref updateInfo);
}
}
}
private void AlterUpdate_TransformControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateTransform == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
TransformUpdateInfo updateInfo = default(TransformUpdateInfo);
for (int i = 0; i < sheet.transformList.Count; i++)
{
LiveTimelineTransformData liveTimelineTransformData = sheet.transformList[i];
if (liveTimelineTransformData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineTransformData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineTransformData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyTransformData liveTimelineKeyTransformData = curKey as LiveTimelineKeyTransformData;
LiveTimelineKeyTransformData liveTimelineKeyTransformData2 = nextKey as LiveTimelineKeyTransformData;
Vector3 euler;
if (liveTimelineKeyTransformData2 != null && liveTimelineKeyTransformData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyTransformData, liveTimelineKeyTransformData2, currentFrame);
updateInfo.updateData.position = LerpWithoutClamp(liveTimelineKeyTransformData.position, liveTimelineKeyTransformData2.position, t);
updateInfo.updateData.scale = LerpWithoutClamp(liveTimelineKeyTransformData.scale, liveTimelineKeyTransformData2.scale, t);
euler = LerpWithoutClamp(liveTimelineKeyTransformData.rotate, liveTimelineKeyTransformData2.rotate, t);
}
else
{
updateInfo.updateData.position = liveTimelineKeyTransformData.position;
updateInfo.updateData.scale = liveTimelineKeyTransformData.scale;
euler = liveTimelineKeyTransformData.rotate;
}
updateInfo.updateData.rotation = Quaternion.Euler(euler);
updateInfo.data = liveTimelineTransformData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyTransformData.frame) * 0.0166666675f;
this.OnUpdateTransform(ref updateInfo);
}
}
}
private void AlterUpdate_RendererControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateRenderer == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
RendererUpdateInfo updateInfo = default(RendererUpdateInfo);
for (int i = 0; i < sheet.rendererList.Count; i++)
{
LiveTimelineRendererData liveTimelineRendererData = sheet.rendererList[i];
if (!liveTimelineRendererData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && liveTimelineRendererData.keys.EnablePlayModeTimeline(_playMode))
{
FindTimelineKey(out curKey, out nextKey, liveTimelineRendererData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyRendererData liveTimelineKeyRendererData = curKey as LiveTimelineKeyRendererData;
updateInfo.renderEnable = liveTimelineKeyRendererData.renderEnable;
updateInfo.data = liveTimelineRendererData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyRendererData.frame) * 0.0166666675f;
this.OnUpdateRenderer(ref updateInfo);
}
}
}
}
private void AlterUpdate_ObjectControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateObject == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
ObjectUpdateInfo updateInfo = default(ObjectUpdateInfo);
for (int i = 0; i < sheet.objectList.Count; i++)
{
LiveTimelineObjectData liveTimelineObjectData = sheet.objectList[i];
if (liveTimelineObjectData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineObjectData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineObjectData.keys, currentFrame);
if (curKey == null)
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineObjectData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyObjectData liveTimelineKeyObjectData = curKey as LiveTimelineKeyObjectData;
LiveTimelineKeyObjectData liveTimelineKeyObjectData2 = nextKey as LiveTimelineKeyObjectData;
Vector3 euler;
if (liveTimelineKeyObjectData2 != null && liveTimelineKeyObjectData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyObjectData, liveTimelineKeyObjectData2, currentFrame);
updateInfo.updateData.position = LerpWithoutClamp(liveTimelineKeyObjectData.position, liveTimelineKeyObjectData2.position, t);
updateInfo.updateData.scale = LerpWithoutClamp(liveTimelineKeyObjectData.scale, liveTimelineKeyObjectData2.scale, t);
euler = LerpWithoutClamp(liveTimelineKeyObjectData.rotate, liveTimelineKeyObjectData2.rotate, t);
updateInfo.color = LerpWithoutClamp(liveTimelineKeyObjectData.color, liveTimelineKeyObjectData2.color, t);
}
else
{
updateInfo.updateData.position = liveTimelineKeyObjectData.position;
updateInfo.updateData.scale = liveTimelineKeyObjectData.scale;
updateInfo.colorEnable = liveTimelineKeyObjectData.colorEnable;
euler = liveTimelineKeyObjectData.rotate;
updateInfo.color = liveTimelineKeyObjectData.color;
}
updateInfo.renderEnable = liveTimelineKeyObjectData.renderEnable;
updateInfo.data = liveTimelineObjectData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyObjectData.frame) * 0.0166666675f;
updateInfo.updateData.rotation = Quaternion.Euler(euler);
updateInfo.reflectionEnable = liveTimelineKeyObjectData.reflectionEnable;
updateInfo.colorEnable = liveTimelineKeyObjectData.colorEnable;
this.OnUpdateObject(ref updateInfo);
}
}
}
private void AlterUpdate_GazingObjectControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateGazingObject == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
GazingObjectUpdateInfo updateInfo = default(GazingObjectUpdateInfo);
for (int i = 0; i < sheet.gazingObjectList.Count; i++)
{
LiveTimelineGazingObjectData liveTimelineGazingObjectData = sheet.gazingObjectList[i];
if (liveTimelineGazingObjectData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineGazingObjectData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineGazingObjectData.keys, currentFrame);
if (curKey == null)
{
continue;
}
LiveTimelineKeyGazingObjectData liveTimelineKeyGazingObjectData = curKey as LiveTimelineKeyGazingObjectData;
LiveTimelineKeyGazingObjectData liveTimelineKeyGazingObjectData2 = nextKey as LiveTimelineKeyGazingObjectData;
if (liveTimelineKeyGazingObjectData.lookAtCharaFlags != 0)
{
if (liveTimelineKeyGazingObjectData2 != null && liveTimelineKeyGazingObjectData2.interpolateType != 0 && liveTimelineKeyGazingObjectData2.lookAtCharaFlags != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyGazingObjectData, liveTimelineKeyGazingObjectData2, currentFrame);
updateInfo.lookAtPos = Vector3.LerpUnclamped(GetPositionWithCharacters(liveTimelineKeyGazingObjectData.lookAtCharaFlags, liveTimelineKeyGazingObjectData.lookAtCharaParts, Vector3.zero), GetPositionWithCharacters(liveTimelineKeyGazingObjectData2.lookAtCharaFlags, liveTimelineKeyGazingObjectData2.lookAtCharaParts, Vector3.zero), t) + Vector3.LerpUnclamped(liveTimelineKeyGazingObjectData.lookAtOffset, liveTimelineKeyGazingObjectData2.lookAtOffset, t);
}
else
{
updateInfo.lookAtPos = GetPositionWithCharacters(liveTimelineKeyGazingObjectData.lookAtCharaFlags, liveTimelineKeyGazingObjectData.lookAtCharaParts, Vector3.zero) + liveTimelineKeyGazingObjectData.lookAtOffset;
}
updateInfo.data = liveTimelineGazingObjectData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyGazingObjectData.frame) * 0.0166666675f;
this.OnUpdateGazingObject(ref updateInfo);
}
}
}
private void SetupCharaHeightMotionParameter(LiveTimelineKeyCharaHeightMotionData curData, LiveCharaPosition charaPosition, float blendRate, float targetBlendRate, LiveTimelineMotionSequence motionSequence, out CharaHeightMotionUpdateInfo updateInfo)
{
float characterHeight = GetCharacterHeight(charaPosition);
float num;
switch (curData.blendType)
{
default:
num = (characterHeight - kCameraLayerOffsetMinCharaHeight) / kCameraLayerOffsetBaseDiff * blendRate;
updateInfo.offsetRate.x = (characterHeight - kCameraLayerOffsetMinCharaHeight) / kCameraLayerOffsetBaseDiff * blendRate;
updateInfo.offsetRate.y = 0f;
updateInfo.offsetRate.z = 0f;
updateInfo.offsetRateExtend = null;
updateInfo.offsetPositionEffectorExtend = null;
updateInfo.extendNum = 0;
break;
case LiveTimelineKeyCharaHeightMotionData.BlendType.Self:
num = (characterHeight - kCameraLayerOffsetMinCharaHeight) / kCameraLayerOffsetBaseDiff * blendRate;
updateInfo.offsetRate = Vector3.zero;
updateInfo.offsetRateExtend = null;
updateInfo.offsetPositionEffectorExtend = null;
updateInfo.extendNum = 0;
break;
case LiveTimelineKeyCharaHeightMotionData.BlendType.Target:
{
num = (GetCharacterHeight(curData.targetPosition) - characterHeight) / kCameraLayerOffsetBaseDiff * blendRate;
float x = (characterHeight - kCameraLayerOffsetMinCharaHeight) / kCameraLayerOffsetBaseDiff * blendRate;
updateInfo.offsetRate.x = x;
updateInfo.offsetRate.y = 0f;
updateInfo.offsetRate.z = 0f;
if (num < 0f)
{
num = 0f;
}
updateInfo.offsetRateExtend = null;
updateInfo.offsetPositionEffectorExtend = null;
updateInfo.extendNum = 0;
break;
}
case LiveTimelineKeyCharaHeightMotionData.BlendType.TargetParts:
{
float characterHeight2 = GetCharacterHeight(curData.targetPosition);
float characterHeight3 = GetCharacterHeight(curData.target2Position);
characterHeight2 = Mathf.Max(0f, (characterHeight2 - characterHeight) / kCameraLayerOffsetBaseDiff) * blendRate;
characterHeight3 = Mathf.Max(0f, (characterHeight3 - characterHeight) / kCameraLayerOffsetBaseDiff) * blendRate;
num = Mathf.Lerp(characterHeight2, characterHeight3, targetBlendRate);
updateInfo.offsetRate = Vector3.zero;
updateInfo.offsetRateExtend = _heightMotionOffsetRate;
updateInfo.offsetPositionEffectorExtend = _heightMotionOffsetTargetPart;
updateInfo.extendNum = 0;
if (curData.partsMotion == null)
{
break;
}
int num2 = curData.partsMotion.Length;
if (num2 > 4)
{
num2 = 4;
}
updateInfo.extendNum = num2;
for (int i = 0; i < num2; i++)
{
float num3 = (characterHeight - kCameraLayerOffsetMinCharaHeight) / kCameraLayerOffsetBaseDiff * blendRate;
float characterHeight4 = GetCharacterHeight(curData.partsMotion[i].targetPosition);
_heightMotionOffsetRate[i].y = num3;
float rate;
if (characterHeight4 > characterHeight)
{
_heightMotionOffsetRate[i].x = 0f;
_heightMotionOffsetRate[i].z = 0f;
rate = (characterHeight4 - characterHeight) / kCameraLayerOffsetBaseDiff * blendRate;
}
else
{
_heightMotionOffsetRate[i].x = num3;
_heightMotionOffsetRate[i].z = (characterHeight - characterHeight4) / kCameraLayerOffsetBaseDiff * blendRate;
rate = 0f;
}
_heightMotionOffsetTargetPart[i] = curData.partsMotion[i].positionOffset;
motionSequence.SetHeightMotionBlend(i + 1, rate);
}
break;
}
}
motionSequence.SetHeightMotionKey(curData);
motionSequence.SetHeightMotionBlend(0, num);
updateInfo.selfPosition = charaPosition;
updateInfo.blendType = curData.blendType;
updateInfo.offsetPositionEffector = curData.positionOffset;
}
private void AlterUpdate_CharaHeightMotion(LiveTimelineWorkSheet sheet, int currentFrame)
{
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
for (int i = 0; i < sheet.charaHeightMotList.Count; i++)
{
LiveTimelineCharaHeightMotSeqData liveTimelineCharaHeightMotSeqData = sheet.charaHeightMotList[i];
int charaPosition = (int)liveTimelineCharaHeightMotSeqData.charaPosition;
LiveTimelineMotionSequence liveTimelineMotionSequence = _motionSequenceArray[charaPosition];
if (liveTimelineMotionSequence == null)
{
continue;
}
if (liveTimelineCharaHeightMotSeqData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
liveTimelineMotionSequence.SetHeightMotionKey(null);
continue;
}
if (!liveTimelineCharaHeightMotSeqData.keys.EnablePlayModeTimeline(_playMode))
{
liveTimelineMotionSequence.SetHeightMotionKey(null);
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineCharaHeightMotSeqData.keys, currentFrame);
if (curKey == null)
{
liveTimelineMotionSequence.SetHeightMotionKey(null);
continue;
}
LiveTimelineKeyCharaHeightMotionData liveTimelineKeyCharaHeightMotionData = curKey as LiveTimelineKeyCharaHeightMotionData;
LiveTimelineKeyCharaHeightMotionData liveTimelineKeyCharaHeightMotionData2 = nextKey as LiveTimelineKeyCharaHeightMotionData;
float num = (float)curKey.frame * 0.0166666675f;
if ((float)currentFrame * 0.0166666675f > num + liveTimelineKeyCharaHeightMotionData.playLength)
{
liveTimelineMotionSequence.SetHeightMotionKey(null);
continue;
}
float blendRate;
float targetBlendRate;
if (liveTimelineKeyCharaHeightMotionData2 != null && liveTimelineKeyCharaHeightMotionData2.interpolate)
{
float t = LinearInterpolateKeyframes(liveTimelineKeyCharaHeightMotionData, liveTimelineKeyCharaHeightMotionData2, currentFrame);
blendRate = LerpWithoutClamp(liveTimelineKeyCharaHeightMotionData.blendRate, liveTimelineKeyCharaHeightMotionData2.blendRate, t);
targetBlendRate = LerpWithoutClamp(liveTimelineKeyCharaHeightMotionData.targetBlendRate, liveTimelineKeyCharaHeightMotionData2.targetBlendRate, t);
}
else
{
blendRate = liveTimelineKeyCharaHeightMotionData.blendRate;
targetBlendRate = liveTimelineKeyCharaHeightMotionData.targetBlendRate;
}
SetupCharaHeightMotionParameter(liveTimelineKeyCharaHeightMotionData, liveTimelineCharaHeightMotSeqData.charaPosition, blendRate, targetBlendRate, liveTimelineMotionSequence, out var updateInfo);
this.OnCharaHeightMotionUpdateInfo(ref updateInfo);
}
}
private void AlterUpdate_PropsControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateProps == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
PropsUpdateInfo updateInfo = default(PropsUpdateInfo);
updateInfo.currentTime = (float)currentFrame * 0.0166666675f;
for (int i = 0; i < sheet.propsList.Count; i++)
{
LiveTimelinePropsData liveTimelinePropsData = sheet.propsList[i];
if (liveTimelinePropsData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelinePropsData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelinePropsData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyPropsData liveTimelineKeyPropsData = curKey as LiveTimelineKeyPropsData;
LiveTimelineKeyPropsData liveTimelineKeyPropsData2 = nextKey as LiveTimelineKeyPropsData;
if (liveTimelineKeyPropsData2 != null && liveTimelineKeyPropsData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyPropsData, liveTimelineKeyPropsData2, currentFrame);
updateInfo.color = LerpWithoutClamp(liveTimelineKeyPropsData.color, liveTimelineKeyPropsData2.color, t);
updateInfo.colorPower = LerpWithoutClamp(liveTimelineKeyPropsData.colorPower, liveTimelineKeyPropsData2.colorPower, t);
updateInfo.rootColor = LerpWithoutClamp(liveTimelineKeyPropsData.rootColor, liveTimelineKeyPropsData2.rootColor, t);
updateInfo.tipColor = LerpWithoutClamp(liveTimelineKeyPropsData.tipColor, liveTimelineKeyPropsData2.tipColor, t);
updateInfo.lightPosition = LerpWithoutClamp(liveTimelineKeyPropsData.lightPos, liveTimelineKeyPropsData2.lightPos, t);
updateInfo.specularPower = LerpWithoutClamp(liveTimelineKeyPropsData.specularPower, liveTimelineKeyPropsData2.specularPower, t);
updateInfo.specularColor = LerpWithoutClamp(liveTimelineKeyPropsData.specularColor, liveTimelineKeyPropsData2.specularColor, t);
updateInfo.luminousColor = LerpWithoutClamp(liveTimelineKeyPropsData.luminousColor, liveTimelineKeyPropsData2.luminousColor, t);
}
else
{
updateInfo.color = liveTimelineKeyPropsData.color;
updateInfo.colorPower = liveTimelineKeyPropsData.colorPower;
updateInfo.rootColor = liveTimelineKeyPropsData.rootColor;
updateInfo.tipColor = liveTimelineKeyPropsData.tipColor;
updateInfo.lightPosition = liveTimelineKeyPropsData.lightPos;
updateInfo.specularPower = liveTimelineKeyPropsData.specularPower;
updateInfo.specularColor = liveTimelineKeyPropsData.specularColor;
updateInfo.luminousColor = liveTimelineKeyPropsData.luminousColor;
}
updateInfo.data = liveTimelinePropsData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyPropsData.frame) * 0.0166666675f;
updateInfo.renderEnable = liveTimelineKeyPropsData.rendererEnable;
updateInfo.settingFlags = liveTimelineKeyPropsData.settingFlags;
updateInfo.propsID = liveTimelineKeyPropsData.propsID;
updateInfo.drawAfterImage = liveTimelineKeyPropsData.IsDrawAfterImage();
updateInfo.useLocalAxis = liveTimelineKeyPropsData.IsUseLocalAxis();
this.OnUpdateProps(ref updateInfo);
}
}
}
private void AlterUpdate_PropsAttachControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdatePropsAttach == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
PropsAttachUpdateInfo updateInfo = default(PropsAttachUpdateInfo);
for (int i = 0; i < sheet.propsAttachList.Count; i++)
{
LiveTimelinePropsAttachData liveTimelinePropsAttachData = sheet.propsAttachList[i];
if (liveTimelinePropsAttachData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelinePropsAttachData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelinePropsAttachData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyPropsAttachData liveTimelineKeyPropsAttachData = curKey as LiveTimelineKeyPropsAttachData;
LiveTimelineKeyPropsAttachData liveTimelineKeyPropsAttachData2 = nextKey as LiveTimelineKeyPropsAttachData;
if (liveTimelineKeyPropsAttachData2 != null && liveTimelineKeyPropsAttachData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyPropsAttachData, liveTimelineKeyPropsAttachData2, currentFrame);
updateInfo.offsetPosition = LerpWithoutClamp(liveTimelineKeyPropsAttachData.offsetPosition, liveTimelineKeyPropsAttachData2.offsetPosition, t);
updateInfo.rotation = LerpWithoutClamp(liveTimelineKeyPropsAttachData.rotation, liveTimelineKeyPropsAttachData2.rotation, t);
}
else
{
updateInfo.offsetPosition = liveTimelineKeyPropsAttachData.offsetPosition;
updateInfo.rotation = liveTimelineKeyPropsAttachData.rotation;
}
updateInfo.data = liveTimelinePropsAttachData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyPropsAttachData.frame) * 0.0166666675f;
updateInfo.settingFlags = liveTimelineKeyPropsAttachData.settingFlags;
updateInfo.attachJointHash = liveTimelineKeyPropsAttachData.attachJointHash;
updateInfo.propsID = liveTimelineKeyPropsAttachData.propsID;
updateInfo.animationId = liveTimelineKeyPropsAttachData.animationId;
updateInfo.animationSpeed = liveTimelineKeyPropsAttachData.animationSpeed;
updateInfo.animationOffset = liveTimelineKeyPropsAttachData.animationOffset;
updateInfo.changeAnimation = false;
if (liveTimelinePropsAttachData.updatedKeyFrame != liveTimelineKeyPropsAttachData.frame && liveTimelineKeyPropsAttachData.isAnimationChange)
{
updateInfo.changeAnimation = true;
}
liveTimelinePropsAttachData.updatedKeyFrame = liveTimelineKeyPropsAttachData.frame;
this.OnUpdatePropsAttach(ref updateInfo);
}
}
}
private void AlterUpdate_CameraSwitcher(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (sheet.cameraSwitcherKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.cameraSwitcherKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
FindTimelineKeyCurrent(out curKey, sheet.cameraSwitcherKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCameraSwitcherData liveTimelineKeyCameraSwitcherData = curKey as LiveTimelineKeyCameraSwitcherData;
if (this.OnUpdateCameraSwitcher != null)
{
this.OnUpdateCameraSwitcher(liveTimelineKeyCameraSwitcherData.cameraIndex);
}
else
{
if (liveTimelineKeyCameraSwitcherData.cameraIndex >= cameraArray.Length)
{
return;
}
for (int i = 0; i < cameraArray.Length; i++)
{
if (cameraArray[i] == null)
{
continue;
}
if (i == liveTimelineKeyCameraSwitcherData.cameraIndex)
{
if (!cameraArray[i].camera.enabled)
{
cameraArray[i].camera.enabled = true;
cameraScriptArray[i].enabled = true;
}
}
else if (cameraArray[i].camera.enabled)
{
cameraArray[i].camera.enabled = false;
cameraScriptArray[i].enabled = false;
}
}
}
}
private void AlterUpdate_LipSync(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (!sheet.ripSyncKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && sheet.ripSyncKeys.EnablePlayModeTimeline(_playMode) && this.OnUpdateLipSync != null)
{
LiveTimelineKey curKey = null;
FindTimelineKeyCurrent(out curKey, sheet.ripSyncKeys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyRipSyncData arg = curKey as LiveTimelineKeyRipSyncData;
this.OnUpdateLipSync(arg, currentLiveTime);
}
}
}
/// <summary>
/// PostEffect�pAlterUpdate
/// </summary>
private void AlterUpdate_PostEffect(LiveTimelineWorkSheet sheet, int currentFrame, Vector3 cameraLookAt)
{
if (sheet.postEffectKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.postEffectKeys.EnablePlayModeTimeline(_playMode) || this.OnUpdatePostEffect == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.postEffectKeys, currentFrame);
if (curKey == null)
{
return;
}
PostEffectUpdateInfo updateInfo = default(PostEffectUpdateInfo);
LiveTimelineKeyPostEffectData liveTimelineKeyPostEffectData = curKey as LiveTimelineKeyPostEffectData;
LiveTimelineKeyPostEffectData liveTimelineKeyPostEffectData2 = nextKey as LiveTimelineKeyPostEffectData;
updateInfo.dofBlurType = liveTimelineKeyPostEffectData.dofBlurType;
updateInfo.dofQuality = liveTimelineKeyPostEffectData.dofQuality;
updateInfo.isUseFocalPoint = liveTimelineKeyPostEffectData.IsUseFocalPoint();
if (liveTimelineKeyPostEffectData2 != null && liveTimelineKeyPostEffectData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyPostEffectData, liveTimelineKeyPostEffectData2, currentFrame);
updateInfo.forcalSize = LerpWithoutClamp(liveTimelineKeyPostEffectData.forcalSize, liveTimelineKeyPostEffectData2.forcalSize, t);
updateInfo.blurSpread = LerpWithoutClamp(liveTimelineKeyPostEffectData.blurSpread, liveTimelineKeyPostEffectData2.blurSpread, t);
updateInfo.bloomDofWeight = LerpWithoutClamp(liveTimelineKeyPostEffectData.bloomDofWeight, liveTimelineKeyPostEffectData2.bloomDofWeight, t);
updateInfo.threshold = LerpWithoutClamp(liveTimelineKeyPostEffectData.threshold, liveTimelineKeyPostEffectData2.threshold, t);
updateInfo.intensity = LerpWithoutClamp(liveTimelineKeyPostEffectData.intensity, liveTimelineKeyPostEffectData2.intensity, t);
if (liveTimelineKeyPostEffectData.IsUseLookAt() && liveTimelineKeyPostEffectData2.IsUseLookAt())
{
updateInfo.forcalPosition = cameraLookAt;
}
else
{
updateInfo.forcalPosition = LerpWithoutClamp(liveTimelineKeyPostEffectData.IsUseLookAt() ? cameraLookAt : GetPositionWithCharacters(liveTimelineKeyPostEffectData.charactor, LiveCameraLookAtCharaParts.Face), liveTimelineKeyPostEffectData2.IsUseLookAt() ? cameraLookAt : GetPositionWithCharacters(liveTimelineKeyPostEffectData2.charactor, LiveCameraLookAtCharaParts.Face), t);
}
updateInfo.dofForegroundSize = LerpWithoutClamp(liveTimelineKeyPostEffectData.dofForegroundSize, liveTimelineKeyPostEffectData2.dofForegroundSize, t);
updateInfo.dofFocalPoint = LerpWithoutClamp(liveTimelineKeyPostEffectData.dofFocalPoint, liveTimelineKeyPostEffectData2.dofFocalPoint, t);
updateInfo.filterIntensity = LerpWithoutClamp(liveTimelineKeyPostEffectData.dofMVFilterIntensity, liveTimelineKeyPostEffectData2.dofMVFilterIntensity, t);
float num = LerpWithoutClamp(liveTimelineKeyPostEffectData.dofMVFilterSpd, liveTimelineKeyPostEffectData2.dofMVFilterSpd, t);
updateInfo.filterTime = (float)(currentFrame - liveTimelineKeyPostEffectData.frame) * 0.0166666675f * num;
}
else
{
updateInfo.forcalSize = liveTimelineKeyPostEffectData.forcalSize;
updateInfo.blurSpread = liveTimelineKeyPostEffectData.blurSpread;
updateInfo.bloomDofWeight = liveTimelineKeyPostEffectData.bloomDofWeight;
updateInfo.threshold = liveTimelineKeyPostEffectData.threshold;
updateInfo.intensity = liveTimelineKeyPostEffectData.intensity;
updateInfo.forcalPosition = (liveTimelineKeyPostEffectData.IsUseLookAt() ? cameraLookAt : GetPositionWithCharacters(liveTimelineKeyPostEffectData.charactor, LiveCameraLookAtCharaParts.Face));
updateInfo.dofForegroundSize = liveTimelineKeyPostEffectData.dofForegroundSize;
updateInfo.dofFocalPoint = liveTimelineKeyPostEffectData.dofFocalPoint;
updateInfo.dofMVFilterType = liveTimelineKeyPostEffectData.dofMVFilterType;
updateInfo.filterResId = liveTimelineKeyPostEffectData.dofMVFilterResId;
updateInfo.filterIntensity = liveTimelineKeyPostEffectData.dofMVFilterIntensity;
updateInfo.filterTime = (float)(currentFrame - liveTimelineKeyPostEffectData.frame) * 0.0166666675f * liveTimelineKeyPostEffectData.dofMVFilterSpd;
updateInfo.disableDOFBlur = liveTimelineKeyPostEffectData.IsDisableDOFBlur();
}
this.OnUpdatePostEffect(ref updateInfo);
}
/// <summary>
/// PostFilm�pAlterUpdate
/// </summary>
private void AlterUpdate_PostFilm(LiveTimelineKeyPostFilmDataList postFilmKeys, int currentFrame, ScreenOverlayUpdateInfoDelegate fnUpdatePostFilm)
{
if (fnUpdatePostFilm == null || postFilmKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !postFilmKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, postFilmKeys, currentFrame);
if (curKey == null)
{
return;
}
PostFilmUpdateInfo updateInfo = default(PostFilmUpdateInfo);
LiveTimelineKeyPostFilmData liveTimelineKeyPostFilmData = curKey as LiveTimelineKeyPostFilmData;
LiveTimelineKeyPostFilmData liveTimelineKeyPostFilmData2 = nextKey as LiveTimelineKeyPostFilmData;
if (liveTimelineKeyPostFilmData2 != null && liveTimelineKeyPostFilmData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyPostFilmData, liveTimelineKeyPostFilmData2, currentFrame);
updateInfo.filmPower = LerpWithoutClamp(liveTimelineKeyPostFilmData.filmPower, liveTimelineKeyPostFilmData2.filmPower, t);
updateInfo.filmOffsetParam = LerpWithoutClamp(liveTimelineKeyPostFilmData.filmOffsetParam, liveTimelineKeyPostFilmData2.filmOffsetParam, t);
updateInfo.filmOptionParam = LerpWithoutClamp(liveTimelineKeyPostFilmData.filmOptionParam, liveTimelineKeyPostFilmData2.filmOptionParam, t);
switch (liveTimelineKeyPostFilmData.colorType)
{
case PostColorType.ColorAll:
updateInfo.color0 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color0, liveTimelineKeyPostFilmData2.color0, t);
updateInfo.color1 = (updateInfo.color2 = (updateInfo.color3 = updateInfo.color0));
break;
case PostColorType.Color2TopBottom:
updateInfo.color0 = (updateInfo.color1 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color0, liveTimelineKeyPostFilmData2.color0, t));
updateInfo.color2 = (updateInfo.color3 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color1, liveTimelineKeyPostFilmData2.color1, t));
break;
case PostColorType.Color2LeftRight:
updateInfo.color0 = (updateInfo.color2 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color0, liveTimelineKeyPostFilmData2.color0, t));
updateInfo.color1 = (updateInfo.color3 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color1, liveTimelineKeyPostFilmData2.color1, t));
break;
case PostColorType.Color4:
updateInfo.color0 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color0, liveTimelineKeyPostFilmData2.color0, t);
updateInfo.color1 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color1, liveTimelineKeyPostFilmData2.color1, t);
updateInfo.color2 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color2, liveTimelineKeyPostFilmData2.color2, t);
updateInfo.color3 = LerpWithoutClamp(liveTimelineKeyPostFilmData.color3, liveTimelineKeyPostFilmData2.color3, t);
break;
}
updateInfo.colorBlendFactor = LerpWithoutClamp(liveTimelineKeyPostFilmData.colorBlendFactor, liveTimelineKeyPostFilmData2.colorBlendFactor, t);
float num = LerpWithoutClamp(liveTimelineKeyPostFilmData.movieSpeed, liveTimelineKeyPostFilmData2.movieSpeed, t);
updateInfo.movieTime = (float)(currentFrame - liveTimelineKeyPostFilmData.frame) * 0.0166666675f * num;
updateInfo.screenCircleDir = LerpWithoutClamp(liveTimelineKeyPostFilmData.screenCircleDir, liveTimelineKeyPostFilmData2.screenCircleDir, t);
}
else
{
updateInfo.filmPower = liveTimelineKeyPostFilmData.filmPower;
updateInfo.filmOffsetParam = liveTimelineKeyPostFilmData.filmOffsetParam;
updateInfo.filmOptionParam = liveTimelineKeyPostFilmData.filmOptionParam;
switch (liveTimelineKeyPostFilmData.colorType)
{
case PostColorType.ColorAll:
updateInfo.color0 = liveTimelineKeyPostFilmData.color0;
updateInfo.color1 = (updateInfo.color2 = (updateInfo.color3 = updateInfo.color0));
break;
case PostColorType.Color2TopBottom:
updateInfo.color0 = (updateInfo.color1 = liveTimelineKeyPostFilmData.color0);
updateInfo.color2 = (updateInfo.color3 = liveTimelineKeyPostFilmData.color1);
break;
case PostColorType.Color2LeftRight:
updateInfo.color0 = (updateInfo.color2 = liveTimelineKeyPostFilmData.color0);
updateInfo.color1 = (updateInfo.color3 = liveTimelineKeyPostFilmData.color1);
break;
case PostColorType.Color4:
updateInfo.color0 = liveTimelineKeyPostFilmData.color0;
updateInfo.color1 = liveTimelineKeyPostFilmData.color1;
updateInfo.color2 = liveTimelineKeyPostFilmData.color2;
updateInfo.color3 = liveTimelineKeyPostFilmData.color3;
break;
}
updateInfo.colorBlendFactor = liveTimelineKeyPostFilmData.colorBlendFactor;
updateInfo.movieTime = (float)(currentFrame - liveTimelineKeyPostFilmData.frame) * 0.0166666675f * liveTimelineKeyPostFilmData.movieSpeed;
updateInfo.screenCircleDir = liveTimelineKeyPostFilmData.screenCircleDir;
}
updateInfo.inverseVignette = liveTimelineKeyPostFilmData.isInverseVignette();
updateInfo.screenCircle = liveTimelineKeyPostFilmData.isScreenCircle;
updateInfo.layerMode = liveTimelineKeyPostFilmData.layerMode;
updateInfo.movieResId = liveTimelineKeyPostFilmData.movieResId;
updateInfo.movieFrameOffset = liveTimelineKeyPostFilmData.movieFrameOffset;
updateInfo.movieReverse = liveTimelineKeyPostFilmData.isReverseUVMovie();
updateInfo.colorBlend = liveTimelineKeyPostFilmData.colorBlend;
updateInfo.filmMode = liveTimelineKeyPostFilmData.filmMode;
updateInfo.colorType = liveTimelineKeyPostFilmData.colorType;
fnUpdatePostFilm(ref updateInfo);
}
/// <summary>
/// �^�C�����C���ɂăX�N���[���t�F�[�h���Ǘ�����
/// ���s���邩���Ǘ����A���ۂ̏�����AlterUpdate_ScreenFadeMain�ɂčs��
/// </summary>
private void AlterUpdate_ScreenFade(LiveTimelineKeyScreenFadeDataList keys, int currentFrame)
{
if (this.OnUpdateScreenFade != null && keys.Count != 0 && !keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && keys.EnablePlayModeTimeline(_playMode))
{
ScreenFadeUpdateInfo updateInfo = default(ScreenFadeUpdateInfo);
AlterUpdate_ScreenFadeMain(keys, currentFrame, ref updateInfo);
this.OnUpdateScreenFade(ref updateInfo);
}
}
/// <summary>
/// OnUpdateScreenFade�ɑ���ScreenFadeUpdateInfo�̒l�𐶐�����
/// </summary>
private void AlterUpdate_ScreenFadeMain(LiveTimelineKeyScreenFadeDataList keys, int currentFrame, ref ScreenFadeUpdateInfo updateInfo)
{
updateInfo.enable = false;
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyScreenFadeData liveTimelineKeyScreenFadeData = curKey as LiveTimelineKeyScreenFadeData;
LiveTimelineKeyScreenFadeData liveTimelineKeyScreenFadeData2 = nextKey as LiveTimelineKeyScreenFadeData;
if (liveTimelineKeyScreenFadeData2 != null && liveTimelineKeyScreenFadeData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyScreenFadeData, liveTimelineKeyScreenFadeData2, currentFrame);
updateInfo.color = Color.LerpUnclamped(liveTimelineKeyScreenFadeData.color, liveTimelineKeyScreenFadeData2.color, t);
}
else
{
updateInfo.color = liveTimelineKeyScreenFadeData.color;
}
updateInfo.enable = updateInfo.color.a > 0f;
updateInfo.onlyQuality3DLight = liveTimelineKeyScreenFadeData.onlyQuality3DLight;
}
}
private void AlterUpdate_CameraLayer(LiveTimelineWorkSheet sheet, int currentFrame, ref Vector3 layerOffset, ref Vector3 extraLayerOffset)
{
if (sheet.cameraLayerKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.cameraLayerKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.cameraLayerKeys, currentFrame);
if (curKey == null)
{
layerOffset = Vector3.zero;
return;
}
LiveTimelineKeyCameraLayerData liveTimelineKeyCameraLayerData = curKey as LiveTimelineKeyCameraLayerData;
LiveTimelineKeyCameraLayerData liveTimelineKeyCameraLayerData2 = nextKey as LiveTimelineKeyCameraLayerData;
if (liveTimelineKeyCameraLayerData2 != null && liveTimelineKeyCameraLayerData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraLayerData, liveTimelineKeyCameraLayerData2, currentFrame);
layerOffset = LerpWithoutClamp(liveTimelineKeyCameraLayerData.layerOffset, liveTimelineKeyCameraLayerData2.layerOffset, t);
_isExtraCameraLayer = liveTimelineKeyCameraLayerData.extraCamera;
if (liveTimelineKeyCameraLayerData.extraCamera)
{
extraLayerOffset = LerpWithoutClamp(liveTimelineKeyCameraLayerData.extraCameraLayerOffset, liveTimelineKeyCameraLayerData2.extraCameraLayerOffset, t);
}
}
else
{
layerOffset = liveTimelineKeyCameraLayerData.layerOffset;
_isExtraCameraLayer = liveTimelineKeyCameraLayerData.extraCamera;
if (liveTimelineKeyCameraLayerData.extraCamera)
{
extraLayerOffset = liveTimelineKeyCameraLayerData.extraCameraLayerOffset;
}
}
}
private void AlterUpdate_Projector(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateProjector == null)
{
return;
}
if (sheet.projecterList.Count > 0 && (_projectorWorks == null || _projectorWorks.Length < sheet.projecterList.Count))
{
_projectorWorks = new ProjectorWork[sheet.projecterList.Count];
for (int i = 0; i < _projectorWorks.Length; i++)
{
_projectorWorks[i] = new ProjectorWork();
}
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
ProjectorUpdateInfo updateInfo = default(ProjectorUpdateInfo);
for (int j = 0; j < sheet.projecterList.Count; j++)
{
LiveTimelineProjectorData liveTimelineProjectorData = sheet.projecterList[j];
if (liveTimelineProjectorData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineProjectorData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineProjectorData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
liveTimelineKey2 = ((liveTimelineKey == null) ? null : liveTimelineProjectorData.keys.At(findKeyResult.index + 1));
if (liveTimelineKey == null)
{
continue;
}
LiveTimelineKeyProjectorData liveTimelineKeyProjectorData = liveTimelineKey as LiveTimelineKeyProjectorData;
LiveTimelineKeyProjectorData liveTimelineKeyProjectorData2 = liveTimelineKey2 as LiveTimelineKeyProjectorData;
if (liveTimelineKeyProjectorData2 != null && liveTimelineKeyProjectorData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyProjectorData, liveTimelineKeyProjectorData2, currentFrame);
updateInfo.motionID = liveTimelineKeyProjectorData.motionID;
updateInfo.materialID = liveTimelineKeyProjectorData.materialID;
updateInfo.speed = LerpWithoutClamp(liveTimelineKeyProjectorData.speed, liveTimelineKeyProjectorData2.speed, t);
updateInfo.color1 = LerpWithoutClamp(liveTimelineKeyProjectorData.color1, liveTimelineKeyProjectorData2.color1, t);
updateInfo.power = LerpWithoutClamp(liveTimelineKeyProjectorData.power, liveTimelineKeyProjectorData2.power, t);
updateInfo.position = LerpWithoutClamp(liveTimelineKeyProjectorData.position, liveTimelineKeyProjectorData2.position, t);
updateInfo.rotate = LerpWithoutClamp(liveTimelineKeyProjectorData.rotate, liveTimelineKeyProjectorData2.rotate, t);
updateInfo.rotateXZ = LerpWithoutClamp(liveTimelineKeyProjectorData.rotateXZ, liveTimelineKeyProjectorData2.rotateXZ, t);
updateInfo.size = LerpWithoutClamp(liveTimelineKeyProjectorData.size, liveTimelineKeyProjectorData2.size, t);
}
else
{
updateInfo.motionID = liveTimelineKeyProjectorData.motionID;
updateInfo.materialID = liveTimelineKeyProjectorData.materialID;
updateInfo.speed = liveTimelineKeyProjectorData.speed;
updateInfo.color1 = liveTimelineKeyProjectorData.color1;
updateInfo.power = liveTimelineKeyProjectorData.power;
updateInfo.position = liveTimelineKeyProjectorData.position;
updateInfo.rotate = liveTimelineKeyProjectorData.rotate;
updateInfo.rotateXZ = liveTimelineKeyProjectorData.rotateXZ;
updateInfo.size = liveTimelineKeyProjectorData.size;
}
updateInfo.data = liveTimelineProjectorData;
ProjectorWork projectorWork = _projectorWorks[j];
float num = (float)(currentFrame - liveTimelineKeyProjectorData.frame) * 0.0166666675f;
if (liveTimelineKeyProjectorData.IsAnimContinuous())
{
if (liveTimelineKeyProjectorData.frame != projectorWork.startFrame || projectorWork.lineHash != liveTimelineProjectorData.nameHash)
{
projectorWork.lineHash = liveTimelineProjectorData.nameHash;
int frame = liveTimelineKeyProjectorData.frame;
for (int num2 = findKeyResult.index - 1; num2 >= 0; num2--)
{
LiveTimelineKey liveTimelineKey3 = liveTimelineProjectorData.keys[num2];
frame = liveTimelineKey3.frame;
if (!(liveTimelineKey3 as LiveTimelineKeyProjectorData).IsAnimContinuous())
{
break;
}
}
projectorWork.progressTime = (float)(liveTimelineKeyProjectorData.frame - frame) * 0.0166666675f;
}
num += projectorWork.progressTime;
}
projectorWork.startFrame = liveTimelineKeyProjectorData.frame;
updateInfo.progressTime = num;
this.OnUpdateProjector(ref updateInfo);
}
}
private void AlterUpdate_CharaWind(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnCharaWindUpdate == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
CharaWindUpdateInfo updateInfo = default(CharaWindUpdateInfo);
for (int i = 0; i < sheet.charaWindList.Count; i++)
{
LiveTimelineCharaWindData liveTimelineCharaWindData = sheet.charaWindList[i];
if (liveTimelineCharaWindData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineCharaWindData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineCharaWindData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyCharaWindData liveTimelineKeyCharaWindData = curKey as LiveTimelineKeyCharaWindData;
LiveTimelineKeyCharaWindData liveTimelineKeyCharaWindData2 = nextKey as LiveTimelineKeyCharaWindData;
Vector3 cySpringForceScale;
Vector3 windPower;
if (liveTimelineKeyCharaWindData2 != null && liveTimelineKeyCharaWindData2.IsInterpolateKey())
{
float t = LinearInterpolateKeyframes(liveTimelineKeyCharaWindData, liveTimelineKeyCharaWindData2, currentFrame);
cySpringForceScale = LerpWithoutClamp(liveTimelineKeyCharaWindData.cySpringForceScale, liveTimelineKeyCharaWindData2.cySpringForceScale, t);
windPower = LerpWithoutClamp(liveTimelineKeyCharaWindData.windPower, liveTimelineKeyCharaWindData2.windPower, t);
}
else
{
cySpringForceScale = liveTimelineKeyCharaWindData.cySpringForceScale;
windPower = liveTimelineKeyCharaWindData.windPower;
}
updateInfo.windMode = liveTimelineKeyCharaWindData.windMode;
updateInfo.loopTime = liveTimelineKeyCharaWindData.loopTime;
updateInfo.enable = liveTimelineKeyCharaWindData.enable;
updateInfo.selfPosition = liveTimelineCharaWindData.charaPosition;
updateInfo.cySpringForceScale = cySpringForceScale;
updateInfo.windPower = windPower;
this.OnCharaWindUpdate(ref updateInfo);
}
}
}
private void AlterUpdate_FacialData(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateFacial == null)
{
return;
}
FacialDataUpdateInfo updateInfo = default(FacialDataUpdateInfo);
if (sheet.facial1Set != null)
{
SetupFacialUpdateInfo_Face(ref updateInfo, sheet.facial1Set.faceKeys, currentFrame);
SetupFacialUpdateInfo_Mouth(ref updateInfo, sheet.facial1Set.mouthKeys, currentFrame);
SetupFacialUpdateInfo_Eye(ref updateInfo, sheet.facial1Set.eyeKeys, currentFrame);
SetupFacialUpdateInfo_EyeTrack(ref updateInfo, sheet.facial1Set.eyeTrackKeys, currentFrame);
this.OnUpdateFacial(updateInfo, currentLiveTime, LiveCharaPosition.Center);
}
if (sheet.other4EyeTrackKeys != null)
{
SetupFacialUpdateInfo_EyeTrack(ref updateInfo, sheet.other4EyeTrackKeys, currentFrame);
}
bool flag = false;
LiveTimelineKeyFacialNoiseData liveTimelineKeyFacialNoiseData = sheet.facialNoiseKeys.FindKeyCached(currentFrame, availableFindKeyCache).key as LiveTimelineKeyFacialNoiseData;
if (liveTimelineKeyFacialNoiseData != null)
{
flag = liveTimelineKeyFacialNoiseData.IsNoiseDisable();
}
for (int i = 1; i < liveCharaPositionMax; i++)
{
bool flag2 = false;
int num = currentFrame;
if (i <= sheet.other4FacialArray.Length)
{
LiveTimelineOther4FacialData liveTimelineOther4FacialData = sheet.other4FacialArray[i - 1];
num = (flag ? currentFrame : _facialNoiseFrameArray[i - 1]);
SetupFacialUpdateInfo_Face(ref updateInfo, liveTimelineOther4FacialData.faceKeys, num);
SetupFacialUpdateInfo_Mouth(ref updateInfo, liveTimelineOther4FacialData.mouthKeys, num);
SetupFacialUpdateInfo_Eye(ref updateInfo, liveTimelineOther4FacialData.eyeKeys, num);
updateInfo.eyeTrack = null;
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, liveTimelineOther4FacialData.eyeTrackKeys, num);
if (curKey != null && !(curKey as LiveTimelineKeyFacialEyeTrackData).IsNop())
{
SetupFacialUpdateInfo_EyeTrack(ref updateInfo, liveTimelineOther4FacialData.eyeTrackKeys, num);
flag2 = true;
}
}
if (!flag2 && sheet.other4EyeTrackKeys != null)
{
LiveTimelineKey curKey2 = null;
LiveTimelineKey nextKey2 = null;
FindTimelineKey(out curKey2, out nextKey2, sheet.other4EyeTrackKeys, num);
if (curKey2 != null)
{
SetupFacialUpdateInfo_EyeTrack(ref updateInfo, sheet.other4EyeTrackKeys, num);
}
}
float facialNoiseCurrentTime = GetFacialNoiseCurrentTime(i - 1);
this.OnUpdateFacial(updateInfo, facialNoiseCurrentTime, (LiveCharaPosition)i);
}
}
private void SetupFacialUpdateInfo_Face(ref FacialDataUpdateInfo updateInfo, LiveTimelineKeyFacialFaceDataList keys, int frame)
{
LiveTimelineKey liveTimelineKey = null;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
updateInfo.face = null;
return;
}
FindKeyResult findKeyResult = keys.FindKeyCached(frame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
updateInfo.face = liveTimelineKey as LiveTimelineKeyFacialFaceData;
updateInfo.faceKeyIndex = findKeyResult.index;
}
private void SetupFacialUpdateInfo_Mouth(ref FacialDataUpdateInfo updateInfo, LiveTimelineKeyFacialFaceMouthList keys, int frame)
{
LiveTimelineKey liveTimelineKey = null;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
updateInfo.mouth = null;
return;
}
FindKeyResult findKeyResult = keys.FindKeyCached(frame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
updateInfo.mouth = liveTimelineKey as LiveTimelineKeyFacialMouthData;
updateInfo.mouthKeyIndex = findKeyResult.index;
}
private void SetupFacialUpdateInfo_Eye(ref FacialDataUpdateInfo updateInfo, LiveTimelineKeyFacialEyeDataList keys, int frame)
{
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
updateInfo.eyeCur = null;
updateInfo.eyeNext = null;
return;
}
FindKeyResult findKeyResult = keys.FindKeyCached(frame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
liveTimelineKey2 = keys.At(findKeyResult.index + 1);
updateInfo.eyeCur = liveTimelineKey as LiveTimelineKeyFacialEyeData;
updateInfo.eyeNext = liveTimelineKey2 as LiveTimelineKeyFacialEyeData;
updateInfo.eyeKeyIndex = findKeyResult.index;
}
private void SetupFacialUpdateInfo_EyeTrack(ref FacialDataUpdateInfo updateInfo, LiveTimelineKeyFacialEyeTrackDataList keys, int frame)
{
LiveTimelineKeyFacialEyeTrackData liveTimelineKeyFacialEyeTrackData = null;
LiveTimelineKeyFacialEyeTrackData liveTimelineKeyFacialEyeTrackData2 = null;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
updateInfo.eyeTrack = null;
updateInfo.eyeTrackOffset = Vector3.zero;
return;
}
keys.FindKeyCached(frame, availableFindKeyCache, out var current, out var next);
liveTimelineKeyFacialEyeTrackData = current.key as LiveTimelineKeyFacialEyeTrackData;
liveTimelineKeyFacialEyeTrackData2 = next.key as LiveTimelineKeyFacialEyeTrackData;
if (liveTimelineKeyFacialEyeTrackData2 != null && liveTimelineKeyFacialEyeTrackData2.IsInterpolateKey())
{
float t = CalculateInterpolationValue(liveTimelineKeyFacialEyeTrackData, liveTimelineKeyFacialEyeTrackData2, frame);
if (liveTimelineKeyFacialEyeTrackData != null)
{
updateInfo.eyeTrackOffset = LerpWithoutClamp(liveTimelineKeyFacialEyeTrackData.position, liveTimelineKeyFacialEyeTrackData2.position, t);
}
}
else if (liveTimelineKeyFacialEyeTrackData != null)
{
updateInfo.eyeTrackOffset = liveTimelineKeyFacialEyeTrackData.position;
}
updateInfo.eyeTrack = liveTimelineKeyFacialEyeTrackData;
updateInfo.eyeTrackKeyIndex = current.index;
}
private void InitFormationOffsetWork()
{
for (int i = 0; i < _formationOffsetStartFrameArray.Length; i++)
{
_formationOffsetStartFrameArray[i] = -1;
}
}
private void AlterLateUpdate_FormationOffset(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (data.characterSettings.isCharaAxisRotateLateUpdate)
{
ILiveTimelineKeyDataList[] keyListArray = sheet.formationOffsetSet.GetKeyListArray();
for (int i = 0; i < keyListArray.Length; i++)
{
LateUpdateFormationOffset_Transform(i, currentFrame);
}
for (int j = 0; j < sheet.formationOffsetAdditionalList.Count; j++)
{
LateUpdateFormationOffset_Transform(keyListArray.Length + j, currentFrame);
}
}
}
private bool UpdateFormationOffset_CharacterVisible(LiveTimelineKeyFormationOffsetData curData, int iList)
{
bool visible = curData.visible;
bool flag = false;
if (_liveCharactorLocators[iList] != null)
{
flag = _liveCharactorLocators[iList].liveCharaVisible != visible;
_liveCharactorLocators[iList].liveCharaVisible = visible;
}
if ((_formationOffsetStartFrameArray[iList] != curData.frame || flag) && this.OnUpdateFormationOffset != null)
{
FormationOffsetUpdateInfo updateInfo = default(FormationOffsetUpdateInfo);
updateInfo.characterPosition = iList;
updateInfo.isVisible = visible;
updateInfo.isEffectClear = curData.IsEffectClear();
this.OnUpdateFormationOffset(ref updateInfo);
}
if (!visible)
{
return false;
}
return true;
}
private void LateUpdateFormationOffset_Transform(int iList, int currentFrame)
{
int num = iList * 2;
if (_formationOffsetLateUpdateKey[num] != null)
{
LiveTimelineKeyFormationOffsetData curData = _formationOffsetLateUpdateKey[num];
LiveTimelineKeyFormationOffsetData nextData = _formationOffsetLateUpdateKey[num + 1];
UpdateFormationOffset_Transform(iList, curData, nextData, currentFrame);
_formationOffsetLateUpdateKey[num] = null;
_formationOffsetLateUpdateKey[num + 1] = null;
}
}
private void UpdateFormationOffset_Transform(int iList, LiveTimelineKeyFormationOffsetData curData, LiveTimelineKeyFormationOffsetData nextData, int currentFrame)
{
Vector2 zero = Vector2.zero;
float num = 0f;
float num2 = 0f;
Vector3 zero2 = Vector3.zero;
bool isWorldSpace = curData.isWorldSpace;
bool isLookAtWorldOrigin = curData.isLookAtWorldOrigin;
Vector3 vector = Vector3.zero;
float y = 0f;
bool useLateRotate = curData.useLateRotate;
Vector3 lateCharaRotate = curData.lateCharaRotate;
if (nextData != null && nextData.interpolateType != 0)
{
float t = CalculateInterpolationValue(curData, nextData, currentFrame);
zero = LerpWithoutClamp(curData.posXZ, nextData.posXZ, t);
num = LerpWithoutClamp(curData.posY, nextData.posY, t);
num2 = LerpWithoutClamp(curData.rotY, nextData.rotY, t);
zero2 = LerpWithoutClamp(curData.charaAxisRotate, nextData.charaAxisRotate, t);
lateCharaRotate = LerpWithoutClamp(curData.lateCharaRotate, nextData.lateCharaRotate, t);
if (isWorldSpace)
{
vector = LerpWithoutClamp(curData.worldSpaceOrigin, nextData.worldSpaceOrigin, t);
y = LerpWithoutClamp(curData.worldRotationY, nextData.worldRotationY, t);
}
}
else
{
zero = curData.posXZ;
num = curData.posY;
num2 = curData.rotY;
zero2 = curData.charaAxisRotate;
lateCharaRotate = curData.lateCharaRotate;
if (isWorldSpace)
{
vector = curData.worldSpaceOrigin;
y = curData.worldRotationY;
}
}
Vector3 vector2 = new Vector3(zero.x, num, zero.y);
Quaternion quaternion = Quaternion.AngleAxis(num2, Vector3.up);
ILiveTimelineCharactorLocator liveTimelineCharactorLocator = _liveCharactorLocators[iList];
if (liveTimelineCharactorLocator != null && liveTimelineCharactorLocator.liveRootTransform != null)
{
if (liveTimelineCharactorLocator.liveParentTransform == null)
{
Vector3 vector3;
if (!useLateRotate)
{
if (zero2.x != 0f || zero2.y != 0f || zero2.z != 0f)
{
liveTimelineCharactorLocator.liveRootTransform.localRotation = Quaternion.Euler(new Vector3(0f, 0f, zero2.z));
Vector3 reverseOffsetPosition = GetReverseOffsetPosition(liveTimelineCharactorLocator.liveCharaWaistPosition, liveTimelineCharactorLocator.liveRootTransform.position, zero2.z, Vector3.back);
liveTimelineCharactorLocator.liveRootTransform.position = liveTimelineCharactorLocator.liveCharaInitialPosition + vector2 + reverseOffsetPosition;
liveTimelineCharactorLocator.liveRootTransform.localRotation = Quaternion.Euler(new Vector3(zero2.x, 0f, zero2.z));
Vector3 reverseOffsetPosition2 = GetReverseOffsetPosition(liveTimelineCharactorLocator.liveCharaWaistPosition, liveTimelineCharactorLocator.liveRootTransform.position, zero2.x, Vector3.left);
liveTimelineCharactorLocator.liveRootTransform.position += reverseOffsetPosition2;
liveTimelineCharactorLocator.liveRootTransform.localRotation = Quaternion.Euler(new Vector3(zero2.x, zero2.y, zero2.z));
Vector3 reverseOffsetPosition3 = GetReverseOffsetPosition(liveTimelineCharactorLocator.liveCharaWaistPosition, liveTimelineCharactorLocator.liveRootTransform.position, zero2.y, Vector3.down);
liveTimelineCharactorLocator.liveRootTransform.position += reverseOffsetPosition3;
vector3 = liveTimelineCharactorLocator.liveRootTransform.position;
quaternion = liveTimelineCharactorLocator.liveRootTransform.localRotation;
}
else
{
vector3 = liveTimelineCharactorLocator.liveCharaInitialPosition + vector2;
}
if (isWorldSpace)
{
Vector3 vector4 = vector3 - vector;
vector3 = vector + Quaternion.Euler(0f, y, 0f) * vector4;
if (isLookAtWorldOrigin)
{
quaternion = Quaternion.LookRotation(vector - vector3);
}
}
}
else
{
vector3 = liveTimelineCharactorLocator.liveCharaInitialPosition + vector2;
liveTimelineCharactorLocator.liveRootTransform.localRotation = Quaternion.Euler(lateCharaRotate);
quaternion = liveTimelineCharactorLocator.liveRootTransform.localRotation;
}
liveTimelineCharactorLocator.liveRootTransform.position = vector3;
liveTimelineCharactorLocator.liveRootTransform.localRotation = quaternion;
}
else
{
Matrix4x4 localToWorldMatrix = liveTimelineCharactorLocator.liveParentTransform.localToWorldMatrix;
Vector3 vector5 = localToWorldMatrix.MultiplyPoint3x4(liveTimelineCharactorLocator.liveCharaInitialPosition + vector2);
quaternion = localToWorldMatrix.rotation * quaternion;
if (!useLateRotate)
{
if (isWorldSpace)
{
Vector3 vector6 = vector5 - vector;
vector5 = vector + Quaternion.Euler(0f, y, 0f) * vector6;
if (isLookAtWorldOrigin)
{
quaternion = Quaternion.LookRotation(vector - vector5);
}
}
}
else
{
liveTimelineCharactorLocator.liveRootTransform.localRotation = Quaternion.Euler(lateCharaRotate);
quaternion = liveTimelineCharactorLocator.liveRootTransform.localRotation;
}
liveTimelineCharactorLocator.liveRootTransform.position = vector5;
liveTimelineCharactorLocator.liveRootTransform.rotation = quaternion;
}
}
_formationOffsetStartFrameArray[iList] = curData.frame;
}
private void UpdateFormationOffset(ILiveTimelineKeyDataList keys, int iList, int currentFrame)
{
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode) || keys.Count <= 0)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyFormationOffsetData liveTimelineKeyFormationOffsetData = curKey as LiveTimelineKeyFormationOffsetData;
if (!UpdateFormationOffset_CharacterVisible(liveTimelineKeyFormationOffsetData, iList))
{
_formationOffsetStartFrameArray[iList] = liveTimelineKeyFormationOffsetData.frame;
return;
}
int num = iList * 2;
LiveTimelineKeyFormationOffsetData liveTimelineKeyFormationOffsetData2 = nextKey as LiveTimelineKeyFormationOffsetData;
if (data.characterSettings.isCharaAxisRotateLateUpdate)
{
_formationOffsetLateUpdateKey[num] = liveTimelineKeyFormationOffsetData;
_formationOffsetLateUpdateKey[num + 1] = liveTimelineKeyFormationOffsetData2;
}
else
{
UpdateFormationOffset_Transform(iList, liveTimelineKeyFormationOffsetData, liveTimelineKeyFormationOffsetData2, currentFrame);
_formationOffsetLateUpdateKey[num] = null;
_formationOffsetLateUpdateKey[num + 1] = null;
}
}
private void AlterUpdate_FormationOffset(LiveTimelineWorkSheet sheet, int currentFrame)
{
ILiveTimelineKeyDataList[] keyListArray = sheet.formationOffsetSet.GetKeyListArray();
for (int i = 0; i < keyListArray.Length; i++)
{
ILiveTimelineKeyDataList keys = keyListArray[i];
UpdateFormationOffset(keys, i, currentFrame);
}
for (int j = 0; j < sheet.formationOffsetAdditionalList.Count; j++)
{
LiveTimelineKeyFormationOffsetDataList keys2 = sheet.formationOffsetAdditionalList[j];
UpdateFormationOffset(keys2, keyListArray.Length + j, currentFrame);
}
}
private Vector3 GetReverseOffsetPosition(Vector3 targetPosition, Vector3 parentPosition, float angle, Vector3 axis)
{
Quaternion quaternion = Quaternion.AngleAxis(angle, axis);
Vector3 vector = targetPosition - parentPosition;
return parentPosition + (quaternion * vector - targetPosition);
}
private void AlterUpdate_Particle(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (data.particleControllMode != LiveTimelineData.ParticleControllMode.Timeline || this.OnUpdateParticle == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
ParticleUpdateInfo updateInfo = default(ParticleUpdateInfo);
for (int i = 0; i < sheet.particleList.Count; i++)
{
LiveTimelineParticleData liveTimelineParticleData = sheet.particleList[i];
if (liveTimelineParticleData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineParticleData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineParticleData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineParticleData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyParticleData liveTimelineKeyParticleData = liveTimelineKey as LiveTimelineKeyParticleData;
LiveTimelineKeyParticleData liveTimelineKeyParticleData2 = liveTimelineKey2 as LiveTimelineKeyParticleData;
if (liveTimelineKeyParticleData2 != null && liveTimelineKeyParticleData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyParticleData, liveTimelineKeyParticleData2, currentFrame);
updateInfo.emissionRate = LerpWithoutClamp(liveTimelineKeyParticleData.emissionRate, liveTimelineKeyParticleData2.emissionRate, t);
}
else
{
updateInfo.emissionRate = liveTimelineKeyParticleData.emissionRate;
}
updateInfo.data = liveTimelineParticleData;
this.OnUpdateParticle(ref updateInfo);
}
}
}
private void AlterUpdate_ParticleGroup(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateParticleGroup == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
ParticleGroupUpdateInfo updateInfo = default(ParticleGroupUpdateInfo);
for (int i = 0; i < sheet.particleGroupList.Count; i++)
{
LiveTimelineParticleGroupData liveTimelineParticleGroupData = sheet.particleGroupList[i];
if (liveTimelineParticleGroupData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineParticleGroupData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineParticleGroupData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineParticleGroupData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyParticleGroupData liveTimelineKeyParticleGroupData = liveTimelineKey as LiveTimelineKeyParticleGroupData;
LiveTimelineKeyParticleGroupData liveTimelineKeyParticleGroupData2 = liveTimelineKey2 as LiveTimelineKeyParticleGroupData;
if (liveTimelineKeyParticleGroupData2 != null && liveTimelineKeyParticleGroupData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyParticleGroupData, liveTimelineKeyParticleGroupData2, currentFrame);
updateInfo.lerpColor = LerpWithoutClamp(liveTimelineKeyParticleGroupData.lerpColor, liveTimelineKeyParticleGroupData2.lerpColor, t);
updateInfo.lerpColorRate = LerpWithoutClamp(liveTimelineKeyParticleGroupData.colorLerpRate, liveTimelineKeyParticleGroupData2.colorLerpRate, t);
}
else
{
updateInfo.lerpColor = liveTimelineKeyParticleGroupData.lerpColor;
updateInfo.lerpColorRate = liveTimelineKeyParticleGroupData.colorLerpRate;
}
updateInfo.data = liveTimelineParticleGroupData;
this.OnUpdateParticleGroup(ref updateInfo);
}
}
}
/// <summary>
/// ���[�U�[��UpdateInfo�������ɓn���O����
/// </summary>
public void AlterUpdate_Laser(LiveTimelineWorkSheet sheet, int currentFrame, int sheetIdx)
{
if (this.OnUpdateLaser == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.laserList.Count;
LaserUpdateInfo updateInfo = default(LaserUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineLaserData liveTimelineLaserData = sheet.laserList[i];
if (liveTimelineLaserData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineLaserData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineLaserData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey == null)
{
continue;
}
liveTimelineKey2 = liveTimelineLaserData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyLaserData liveTimelineKeyLaserData = liveTimelineKey as LiveTimelineKeyLaserData;
LiveTimelineKeyLaserData liveTimelineKeyLaserData2 = liveTimelineKey2 as LiveTimelineKeyLaserData;
int num = liveTimelineKeyLaserData.joints.Length;
if (_numLaserParts != num)
{
_numLaserParts = num;
_arrLaserPosition = new Vector3[num];
_arrLaserRotation = new Vector3[num];
_arrLaserScale = new Vector3[num];
}
updateInfo.localPos = _arrLaserPosition;
updateInfo.localRot = _arrLaserRotation;
updateInfo.localScale = _arrLaserScale;
if (liveTimelineKeyLaserData2 != null && liveTimelineKeyLaserData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyLaserData, liveTimelineKeyLaserData2, currentFrame);
updateInfo.degRootYaw = LerpWithoutClamp(liveTimelineKeyLaserData.degRootYaw, liveTimelineKeyLaserData2.degRootYaw, t);
updateInfo.degLaserPitch = LerpWithoutClamp(liveTimelineKeyLaserData.degLaserPitch, liveTimelineKeyLaserData2.degLaserPitch, t);
updateInfo.posInterval = LerpWithoutClamp(liveTimelineKeyLaserData.posInterval, liveTimelineKeyLaserData2.posInterval, t);
updateInfo.blinkPeroid = LerpWithoutClamp(liveTimelineKeyLaserData.blinkPeriod, liveTimelineKeyLaserData2.blinkPeriod, t);
updateInfo.rootPos = LerpWithoutClamp(liveTimelineKeyLaserData.rootTransform.localPos, liveTimelineKeyLaserData2.rootTransform.localPos, t);
updateInfo.rootRot = LerpWithoutClamp(liveTimelineKeyLaserData.rootTransform.localRot, liveTimelineKeyLaserData2.rootTransform.localRot, t);
updateInfo.rootScale = LerpWithoutClamp(liveTimelineKeyLaserData.rootTransform.localScale, liveTimelineKeyLaserData2.rootTransform.localScale, t);
for (int j = 0; j < num; j++)
{
updateInfo.localPos[j] = LerpWithoutClamp(liveTimelineKeyLaserData.joints[j].localPos, liveTimelineKeyLaserData2.joints[j].localPos, t);
updateInfo.localRot[j] = LerpWithoutClamp(liveTimelineKeyLaserData.joints[j].localRot, liveTimelineKeyLaserData2.joints[j].localRot, t);
updateInfo.localScale[j] = LerpWithoutClamp(liveTimelineKeyLaserData.joints[j].localScale, liveTimelineKeyLaserData2.joints[j].localScale, t);
}
}
else
{
updateInfo.degRootYaw = liveTimelineKeyLaserData.degRootYaw;
updateInfo.degLaserPitch = liveTimelineKeyLaserData.degLaserPitch;
updateInfo.posInterval = liveTimelineKeyLaserData.posInterval;
updateInfo.blinkPeroid = liveTimelineKeyLaserData.blinkPeriod;
updateInfo.rootPos = liveTimelineKeyLaserData.rootTransform.localPos;
updateInfo.rootRot = liveTimelineKeyLaserData.rootTransform.localRot;
updateInfo.rootScale = liveTimelineKeyLaserData.rootTransform.localScale;
for (int k = 0; k < num; k++)
{
updateInfo.localPos[k] = liveTimelineKeyLaserData.joints[k].localPos;
updateInfo.localRot[k] = liveTimelineKeyLaserData.joints[k].localRot;
updateInfo.localScale[k] = liveTimelineKeyLaserData.joints[k].localScale;
}
}
updateInfo.data = liveTimelineLaserData;
updateInfo.formation = liveTimelineKeyLaserData.formation;
updateInfo.isBlink = liveTimelineKeyLaserData.IsBlink();
this.OnUpdateLaser(ref updateInfo, _ignoreLaserHashDic[sheetIdx]);
}
}
/// <summary>
/// PostFilm�pAlterUpdate
/// </summary>
private void AlterUpdate_Effect(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateEffect == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.effectList.Count;
EffectUpdateInfo updateInfo = default(EffectUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineEffectData liveTimelineEffectData = sheet.effectList[i];
if (liveTimelineEffectData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineEffectData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineEffectData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineEffectData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyEffectData liveTimelineKeyEffectData = liveTimelineKey as LiveTimelineKeyEffectData;
LiveTimelineKeyEffectData liveTimelineKeyEffectData2 = liveTimelineKey2 as LiveTimelineKeyEffectData;
if (liveTimelineKeyEffectData2 != null && liveTimelineKeyEffectData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyEffectData, liveTimelineKeyEffectData2, currentFrame);
updateInfo.color = LerpWithoutClamp(liveTimelineKeyEffectData.color, liveTimelineKeyEffectData2.color, t);
updateInfo.colorPower = LerpWithoutClamp(liveTimelineKeyEffectData.colorPower, liveTimelineKeyEffectData2.colorPower, t);
updateInfo.offset = LerpWithoutClamp(liveTimelineKeyEffectData.offset, liveTimelineKeyEffectData2.offset, t);
updateInfo.offsetAngle = LerpWithoutClamp(liveTimelineKeyEffectData.offsetAngle, liveTimelineKeyEffectData2.offsetAngle, t);
}
else
{
updateInfo.color = liveTimelineKeyEffectData.color;
updateInfo.colorPower = liveTimelineKeyEffectData.colorPower;
updateInfo.offset = liveTimelineKeyEffectData.offset;
updateInfo.offsetAngle = liveTimelineKeyEffectData.offsetAngle;
}
if (liveTimelineKeyEffectData.owner == eEffectOwner.World)
{
updateInfo.isEnable = true;
}
else
{
updateInfo.isEnable = _liveCharactorLocators[eEffectOwnerUtil.ToCharaPosIndex(liveTimelineKeyEffectData.owner)].liveCharaVisible;
}
updateInfo.isClear = liveTimelineEffectData.updatedKeyFrame != liveTimelineKeyEffectData.frame && liveTimelineKeyEffectData.IsClear();
updateInfo.blendMode = liveTimelineKeyEffectData.blendMode;
updateInfo.isPlay = liveTimelineKeyEffectData.IsPlay();
updateInfo.isLoop = liveTimelineKeyEffectData.IsLoop();
updateInfo.isStayPRS = liveTimelineKeyEffectData.IsStayPRS();
updateInfo.owner = liveTimelineKeyEffectData.owner;
updateInfo.occurrenceSpot = liveTimelineKeyEffectData.occurrenceSpot;
updateInfo.data = liveTimelineEffectData;
this.OnUpdateEffect(ref updateInfo);
liveTimelineEffectData.updatedKeyFrame = liveTimelineKeyEffectData.frame;
}
}
}
public bool IsDrawDeltaTimeGraph()
{
return _drawDeltaTimeGraph;
}
public void SetDrawDeltaTimeGraph(bool draw)
{
_drawDeltaTimeGraph = draw;
}
public void EnqueueDeltaTimeForGraph(float dt)
{
_headIndexOfDeltaTimeArray = (_headIndexOfDeltaTimeArray + 1) % kDeltaTimeArrayLength;
_deltaTimeArrayForGraph[_headIndexOfDeltaTimeArray] = dt;
}
private void UpdateDeltaTimeGraph()
{
graphWidth = (float)Screen.width - graphXMargin * 2f;
graphYMargin = (float)(Screen.height / 2) - graphHeight;
}
private void OnGUI()
{
if (!_drawDeltaTimeGraph)
{
return;
}
float num = graphWidth / kDeltaTimeArrayLength;
Drawing.DrawLine(new Vector2(graphXMargin, graphYMargin - graphHeight), new Vector2(graphXMargin + graphWidth, graphYMargin - graphHeight), Color.blue, 1f, antiAlias: false);
Drawing.DrawLine(new Vector2(graphXMargin, graphYMargin), new Vector2(graphXMargin + graphWidth, graphYMargin), Color.white, 1f, antiAlias: false);
Drawing.DrawLine(new Vector2(graphXMargin, graphYMargin + graphHeight), new Vector2(graphXMargin + graphWidth, graphYMargin + graphHeight), Color.yellow, 1f, antiAlias: false);
int num2 = _headIndexOfDeltaTimeArray;
int num3 = 0;
for (int i = 0; i < 299; i++)
{
num3 = num2 - 1;
if (num3 < 0)
{
num3 = 299;
}
float num4 = _deltaTimeArrayForGraph[num2];
float num5 = _deltaTimeArrayForGraph[num3];
float num6 = num4 / 0.0166666675f;
float num7 = num5 / 0.0166666675f;
Vector2 pointA = new Vector2(graphXMargin + graphWidth - num * (float)i, graphYMargin - graphHeight * num6);
Vector2 pointB = new Vector2(graphXMargin + graphWidth - num * (float)(i + 1), graphYMargin - graphHeight * num7);
Drawing.DrawLine(pointA, pointB, Color.green, 2f, antiAlias: false);
num2 = num3;
}
}
/// <summary>
/// �‹������X�V����
/// </summary>
private void AlterUpdate_Environment(LiveTimelineWorkSheet sheet, int currentFrame)
{
int count = sheet.environmentDataLists.Count;
EnvironmentCharacterShadowUpdateInfo updateInfo = default(EnvironmentCharacterShadowUpdateInfo);
EnvironmentMirrorUpdateInfo updateInfo2 = default(EnvironmentMirrorUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineKeyStageEnvironmentDataList keys = sheet.environmentDataLists[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
LiveTimelineKey curKey = null;
FindTimelineKeyCurrent(out curKey, keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyStageEnvironmentData liveTimelineKeyStageEnvironmentData = curKey as LiveTimelineKeyStageEnvironmentData;
if (this.OnEnvironmentCharacterShadow != null && (liveTimelineKeyStageEnvironmentData.characterShadow != _enviromentShadowCharacterPositionFlag || liveTimelineKeyStageEnvironmentData.softShadow != _enviromentSoftShadow))
{
_enviromentShadowCharacterPositionFlag = liveTimelineKeyStageEnvironmentData.characterShadow;
_enviromentSoftShadow = liveTimelineKeyStageEnvironmentData.softShadow;
updateInfo.positionFlag = liveTimelineKeyStageEnvironmentData.characterShadow;
updateInfo.softShadow = liveTimelineKeyStageEnvironmentData.softShadow;
this.OnEnvironmentCharacterShadow(ref updateInfo);
}
if (this.OnEnvironmentMirror != null)
{
updateInfo2.mirror = liveTimelineKeyStageEnvironmentData.mirror;
updateInfo2.mirrorReflectionRate = liveTimelineKeyStageEnvironmentData.mirrorReflectionRate;
this.OnEnvironmentMirror(ref updateInfo2);
}
}
}
}
/// <summary>
/// GlobalLight�pAlterUpdate
/// </summary>
private void AlterUpdate_GlobalLight(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnEnvironmentGlobalLight == null)
{
return;
}
int count = sheet.globalLightDataLists.Count;
EnvironmentGlobalLightUpdateInfo updateInfo = default(EnvironmentGlobalLightUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineKeyGlobalLightDataList keys = sheet.globalLightDataLists[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyGlobalLightData liveTimelineKeyGlobalLightData = curKey as LiveTimelineKeyGlobalLightData;
LiveTimelineKeyGlobalLightData liveTimelineKeyGlobalLightData2 = nextKey as LiveTimelineKeyGlobalLightData;
Quaternion quaternion = Quaternion.identity;
if (liveTimelineKeyGlobalLightData.cameraFollow)
{
quaternion = GetCamera(sheet.targetCameraIndex).cacheTransform.rotation;
}
Vector3 lightDirection;
float globalRimRate;
float globalRimShadowRate;
float globalRimSpecularRate;
float globalToonRate;
if (liveTimelineKeyGlobalLightData2 != null && liveTimelineKeyGlobalLightData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyGlobalLightData, liveTimelineKeyGlobalLightData2, currentFrame);
Quaternion a = Quaternion.Euler(liveTimelineKeyGlobalLightData.lightDir);
Quaternion b = Quaternion.Euler(liveTimelineKeyGlobalLightData2.lightDir);
lightDirection = Quaternion.Lerp(a, b, t) * quaternion * Vector3.forward;
globalRimRate = LerpWithoutClamp(liveTimelineKeyGlobalLightData.globalRimRate, liveTimelineKeyGlobalLightData2.globalRimRate, t);
globalRimShadowRate = LerpWithoutClamp(liveTimelineKeyGlobalLightData.globalRimShadowRate, liveTimelineKeyGlobalLightData2.globalRimShadowRate, t);
globalRimSpecularRate = LerpWithoutClamp(liveTimelineKeyGlobalLightData.globalRimSpecularRate, liveTimelineKeyGlobalLightData2.globalRimSpecularRate, t);
globalToonRate = LerpWithoutClamp(liveTimelineKeyGlobalLightData.globalToonRate, liveTimelineKeyGlobalLightData2.globalToonRate, t);
}
else
{
lightDirection = Quaternion.Euler(liveTimelineKeyGlobalLightData.lightDir) * quaternion * Vector3.forward;
globalRimRate = liveTimelineKeyGlobalLightData.globalRimRate;
globalRimShadowRate = liveTimelineKeyGlobalLightData.globalRimShadowRate;
globalRimSpecularRate = liveTimelineKeyGlobalLightData.globalRimSpecularRate;
globalToonRate = liveTimelineKeyGlobalLightData.globalToonRate;
}
updateInfo.lightDirection = lightDirection;
updateInfo.globalRimRate = globalRimRate;
updateInfo.globalRimShadowRate = globalRimShadowRate;
updateInfo.globalRimSpecularRate = globalRimSpecularRate;
updateInfo.globalToonRate = globalToonRate;
updateInfo.data = sheet.globalLightDataLists[i];
this.OnEnvironmentGlobalLight(ref updateInfo);
}
}
}
/// <summary>
/// GlobalFog�pAlterUpdate
/// </summary>
private void AlterUpdate_GlobalFog(LiveTimelineWorkSheet sheet, int currentFrame)
{
int count = sheet.globalFogDataLists.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyGlobalFogDataList keys = sheet.globalFogDataLists[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey == null)
{
continue;
}
LiveTimelineKeyGlobalFogData liveTimelineKeyGlobalFogData = curKey as LiveTimelineKeyGlobalFogData;
LiveTimelineKeyGlobalFogData liveTimelineKeyGlobalFogData2 = nextKey as LiveTimelineKeyGlobalFogData;
if (this.OnGlobalFog != null)
{
GlobalFogUpdateInfo updateInfo = default(GlobalFogUpdateInfo);
bool isDistance;
bool isHeight;
float startDistance;
float height;
float heightDensity;
Color color;
FogMode fogMode;
float expDensity;
float start;
float end;
bool useRadialDistance;
Vector4 heightOption;
Vector4 distanceOption;
if (liveTimelineKeyGlobalFogData2 != null && liveTimelineKeyGlobalFogData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyGlobalFogData, liveTimelineKeyGlobalFogData2, currentFrame);
isDistance = liveTimelineKeyGlobalFogData2.isDistance;
isHeight = liveTimelineKeyGlobalFogData2.isHeight;
startDistance = LerpWithoutClamp(liveTimelineKeyGlobalFogData.startDistance, liveTimelineKeyGlobalFogData2.startDistance, t);
height = LerpWithoutClamp(liveTimelineKeyGlobalFogData.height, liveTimelineKeyGlobalFogData2.height, t);
heightDensity = LerpWithoutClamp(liveTimelineKeyGlobalFogData.heightDensity, liveTimelineKeyGlobalFogData2.heightDensity, t);
color = LerpWithoutClamp(liveTimelineKeyGlobalFogData.color, liveTimelineKeyGlobalFogData2.color, t);
fogMode = liveTimelineKeyGlobalFogData2.fogMode;
expDensity = LerpWithoutClamp(liveTimelineKeyGlobalFogData.expDensity, liveTimelineKeyGlobalFogData2.expDensity, t);
start = LerpWithoutClamp(liveTimelineKeyGlobalFogData.start, liveTimelineKeyGlobalFogData2.start, t);
end = LerpWithoutClamp(liveTimelineKeyGlobalFogData.end, liveTimelineKeyGlobalFogData2.end, t);
useRadialDistance = liveTimelineKeyGlobalFogData2.useRadialDistance;
heightOption = LerpWithoutClamp(liveTimelineKeyGlobalFogData.heightOption, liveTimelineKeyGlobalFogData2.heightOption, t);
distanceOption = LerpWithoutClamp(liveTimelineKeyGlobalFogData.distanceOption, liveTimelineKeyGlobalFogData2.distanceOption, t);
}
else
{
isDistance = liveTimelineKeyGlobalFogData.isDistance;
isHeight = liveTimelineKeyGlobalFogData.isHeight;
startDistance = liveTimelineKeyGlobalFogData.startDistance;
height = liveTimelineKeyGlobalFogData.height;
heightDensity = liveTimelineKeyGlobalFogData.heightDensity;
color = liveTimelineKeyGlobalFogData.color;
fogMode = liveTimelineKeyGlobalFogData.fogMode;
expDensity = liveTimelineKeyGlobalFogData.expDensity;
start = liveTimelineKeyGlobalFogData.start;
end = liveTimelineKeyGlobalFogData.end;
useRadialDistance = liveTimelineKeyGlobalFogData.useRadialDistance;
heightOption = liveTimelineKeyGlobalFogData.heightOption;
distanceOption = liveTimelineKeyGlobalFogData.distanceOption;
}
updateInfo.isDistance = isDistance;
updateInfo.isHeight = isHeight;
updateInfo.startDistance = startDistance;
updateInfo.height = height;
updateInfo.heightDensity = heightDensity;
updateInfo.color = color;
updateInfo.fogMode = fogMode;
updateInfo.expDensity = expDensity;
updateInfo.start = start;
updateInfo.end = end;
updateInfo.useRadialDistance = useRadialDistance;
updateInfo.heightOption = heightOption;
updateInfo.distanceOption = distanceOption;
this.OnGlobalFog(ref updateInfo);
}
}
}
/// <summary>
/// TiltShift�pAlterUpdate
/// </summary>
private void AlterUpdate_TiltShift(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateTiltShift == null || sheet.tiltShiftKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.tiltShiftKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.tiltShiftKeys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyTiltShiftData liveTimelineKeyTiltShiftData = curKey as LiveTimelineKeyTiltShiftData;
LiveTimelineKeyTiltShiftData liveTimelineKeyTiltShiftData2 = nextKey as LiveTimelineKeyTiltShiftData;
TilsShiftUpdateInfo updateInfo = default(TilsShiftUpdateInfo);
updateInfo.mode = liveTimelineKeyTiltShiftData.mode;
updateInfo.quality = liveTimelineKeyTiltShiftData.quality;
updateInfo.downsample = liveTimelineKeyTiltShiftData.downsample;
if (liveTimelineKeyTiltShiftData2 != null && liveTimelineKeyTiltShiftData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyTiltShiftData, liveTimelineKeyTiltShiftData2, currentFrame);
updateInfo.blurArea = LerpWithoutClamp(liveTimelineKeyTiltShiftData.blurArea, liveTimelineKeyTiltShiftData2.blurArea, t);
updateInfo.maxBlurSize = LerpWithoutClamp(liveTimelineKeyTiltShiftData.maxBlurSize, liveTimelineKeyTiltShiftData2.maxBlurSize, t);
updateInfo.offset = LerpWithoutClamp(liveTimelineKeyTiltShiftData.offset, liveTimelineKeyTiltShiftData2.offset, t);
updateInfo.roll = LerpWithoutClamp(liveTimelineKeyTiltShiftData.roll, liveTimelineKeyTiltShiftData2.roll, t);
updateInfo.blurDir = LerpWithoutClamp(liveTimelineKeyTiltShiftData.blurDir, liveTimelineKeyTiltShiftData2.blurDir, t);
updateInfo.blurAreaDir = LerpWithoutClamp(liveTimelineKeyTiltShiftData.blurAreaDir, liveTimelineKeyTiltShiftData2.blurAreaDir, t);
}
else
{
updateInfo.blurArea = liveTimelineKeyTiltShiftData.blurArea;
updateInfo.maxBlurSize = liveTimelineKeyTiltShiftData.maxBlurSize;
updateInfo.offset = liveTimelineKeyTiltShiftData.offset;
updateInfo.roll = liveTimelineKeyTiltShiftData.roll;
updateInfo.blurDir = liveTimelineKeyTiltShiftData.blurDir;
updateInfo.blurAreaDir = liveTimelineKeyTiltShiftData.blurAreaDir;
}
this.OnUpdateTiltShift(ref updateInfo);
}
}
/// <summary>
/// LightShuft�pAlterUpdate
/// </summary>
private void AlterUpdate_LightShuft(LiveTimelineWorkSheet sheet, int currentFrame)
{
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
if (this.OnLightShuft == null)
{
return;
}
LightShuftUpdateInfo updateInfo = default(LightShuftUpdateInfo);
for (int i = 0; i < sheet.lightShuftKeys.Count; i++)
{
LiveTimelineLightShuftData liveTimelineLightShuftData = sheet.lightShuftKeys[i];
if (liveTimelineLightShuftData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineLightShuftData.keys, currentFrame);
if (curKey == null)
{
continue;
}
LiveTimelineKeyLightShuftData liveTimelineKeyLightShuftData = curKey as LiveTimelineKeyLightShuftData;
LiveTimelineKeyLightShuftData liveTimelineKeyLightShuftData2 = nextKey as LiveTimelineKeyLightShuftData;
if (liveTimelineKeyLightShuftData2 != null && liveTimelineKeyLightShuftData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyLightShuftData, liveTimelineKeyLightShuftData2, currentFrame);
updateInfo._enable = liveTimelineKeyLightShuftData.enabled;
updateInfo._offset = LerpWithoutClamp(liveTimelineKeyLightShuftData.offset, liveTimelineKeyLightShuftData2.offset, t);
updateInfo._scale = LerpWithoutClamp(liveTimelineKeyLightShuftData.scale, liveTimelineKeyLightShuftData2.scale, t);
updateInfo._speed = LerpWithoutClamp(liveTimelineKeyLightShuftData.speed, liveTimelineKeyLightShuftData2.speed, t);
updateInfo._alpha = LerpWithoutClamp(liveTimelineKeyLightShuftData.alpha, liveTimelineKeyLightShuftData2.alpha, t);
updateInfo._alpha2 = LerpWithoutClamp(liveTimelineKeyLightShuftData.alpha2, liveTimelineKeyLightShuftData2.alpha2, t);
updateInfo._maskAlpha = LerpWithoutClamp(liveTimelineKeyLightShuftData.maskAlpha, liveTimelineKeyLightShuftData2.maskAlpha, t);
updateInfo._angle = LerpWithoutClamp(liveTimelineKeyLightShuftData.angle, liveTimelineKeyLightShuftData2.angle, t);
}
else
{
updateInfo._enable = liveTimelineKeyLightShuftData.enabled;
updateInfo._offset = liveTimelineKeyLightShuftData.offset;
updateInfo._scale = liveTimelineKeyLightShuftData.scale;
updateInfo._speed = liveTimelineKeyLightShuftData.speed;
updateInfo._angle = liveTimelineKeyLightShuftData.angle;
updateInfo._alpha = liveTimelineKeyLightShuftData.alpha;
updateInfo._alpha2 = liveTimelineKeyLightShuftData.alpha2;
updateInfo._maskAlpha = liveTimelineKeyLightShuftData.maskAlpha;
}
float num = Mathf.RoundToInt(liveTimelineKeyLightShuftData.maskAnimeTime * 60f);
if (num <= 0f)
{
updateInfo._alpha.z = liveTimelineKeyLightShuftData.maskAlphaRange.x;
}
else
{
float num2 = liveTimelineKeyLightShuftData.maskAlphaRange.y - liveTimelineKeyLightShuftData.maskAlphaRange.x;
float num3 = (float)(currentFrame - liveTimelineKeyLightShuftData.frame) % num;
num /= 2f;
if (num3 >= num)
{
num3 -= num;
updateInfo._alpha.z = liveTimelineKeyLightShuftData.maskAlphaRange.x + (num2 - num2 * num3 / num);
}
else
{
updateInfo._alpha.z = liveTimelineKeyLightShuftData.maskAlphaRange.x + num2 * num3 / num;
}
}
this.OnLightShuft(ref updateInfo);
}
}
private void AlterUpdate_ColorCorrection(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnColorCorrection == null)
{
return;
}
int count = sheet.colorCorrectionDataLists.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyColorCorrectionDataList keys = sheet.colorCorrectionDataLists[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyColorCorrectionData liveTimelineKeyColorCorrectionData = curKey as LiveTimelineKeyColorCorrectionData;
bool flag = false;
if (_oldFrame < curKey.frame || _colorCorrectionCameraIndex != sheet.targetCameraIndex)
{
_colorCorrectionCameraIndex = sheet.targetCameraIndex;
flag = true;
}
if (nextKey != null && _oldFrame >= nextKey.frame)
{
flag = true;
}
if (flag)
{
ColorCorrectionUpdateInfo updateInfo = default(ColorCorrectionUpdateInfo);
updateInfo._enable = liveTimelineKeyColorCorrectionData.enable;
updateInfo._saturation = liveTimelineKeyColorCorrectionData.saturation;
updateInfo._redCurve = liveTimelineKeyColorCorrectionData.redCurve;
updateInfo._greenCurve = liveTimelineKeyColorCorrectionData.greenCurve;
updateInfo._blueCurve = liveTimelineKeyColorCorrectionData.blueCurve;
updateInfo._selective = liveTimelineKeyColorCorrectionData.selective;
updateInfo._keyColor = liveTimelineKeyColorCorrectionData.keyColor;
updateInfo._targetColor = liveTimelineKeyColorCorrectionData.targetColor;
updateInfo._cameraIndex = sheet.targetCameraIndex;
this.OnColorCorrection(ref updateInfo);
}
}
}
}
private void AlterUpdate_SweatLocator(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateSweatLocator == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.sweatLocatorList.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineSweatLocatorData liveTimelineSweatLocatorData = sheet.sweatLocatorList[i];
if (liveTimelineSweatLocatorData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineSweatLocatorData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineSweatLocatorData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey == null)
{
continue;
}
liveTimelineKey2 = liveTimelineSweatLocatorData.keys.At(findKeyResult.index + 1);
LiveTimelineKeySweatLocatorData liveTimelineKeySweatLocatorData = liveTimelineKey as LiveTimelineKeySweatLocatorData;
LiveTimelineKeySweatLocatorData liveTimelineKeySweatLocatorData2 = liveTimelineKey2 as LiveTimelineKeySweatLocatorData;
if (liveTimelineKeySweatLocatorData2 != null && liveTimelineKeySweatLocatorData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeySweatLocatorData, liveTimelineKeySweatLocatorData2, currentFrame);
_sweatLocatorUpdateInfo.alpha = LerpWithoutClamp(liveTimelineKeySweatLocatorData.alpha, liveTimelineKeySweatLocatorData2.alpha, t);
_sweatLocatorUpdateInfo.locatorInfo[0].offset = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator0_offset, liveTimelineKeySweatLocatorData2.locator0_offset, t);
_sweatLocatorUpdateInfo.locatorInfo[0].offsetAngle = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator0_offsetAngle, liveTimelineKeySweatLocatorData2.locator0_offsetAngle, t);
_sweatLocatorUpdateInfo.locatorInfo[1].offset = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator1_offset, liveTimelineKeySweatLocatorData2.locator1_offset, t);
_sweatLocatorUpdateInfo.locatorInfo[1].offsetAngle = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator1_offsetAngle, liveTimelineKeySweatLocatorData2.locator1_offsetAngle, t);
_sweatLocatorUpdateInfo.locatorInfo[2].offset = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator2_offset, liveTimelineKeySweatLocatorData2.locator2_offset, t);
_sweatLocatorUpdateInfo.locatorInfo[2].offsetAngle = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator2_offsetAngle, liveTimelineKeySweatLocatorData2.locator2_offsetAngle, t);
_sweatLocatorUpdateInfo.locatorInfo[3].offset = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator3_offset, liveTimelineKeySweatLocatorData2.locator3_offset, t);
_sweatLocatorUpdateInfo.locatorInfo[3].offsetAngle = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator3_offsetAngle, liveTimelineKeySweatLocatorData2.locator3_offsetAngle, t);
_sweatLocatorUpdateInfo.locatorInfo[4].offset = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator4_offset, liveTimelineKeySweatLocatorData2.locator4_offset, t);
_sweatLocatorUpdateInfo.locatorInfo[4].offsetAngle = LerpWithoutClamp(liveTimelineKeySweatLocatorData.locator4_offsetAngle, liveTimelineKeySweatLocatorData2.locator4_offsetAngle, t);
}
else
{
_sweatLocatorUpdateInfo.alpha = liveTimelineKeySweatLocatorData.alpha;
_sweatLocatorUpdateInfo.locatorInfo[0].offset = liveTimelineKeySweatLocatorData.locator0_offset;
_sweatLocatorUpdateInfo.locatorInfo[0].offsetAngle = liveTimelineKeySweatLocatorData.locator0_offsetAngle;
_sweatLocatorUpdateInfo.locatorInfo[1].offset = liveTimelineKeySweatLocatorData.locator1_offset;
_sweatLocatorUpdateInfo.locatorInfo[1].offsetAngle = liveTimelineKeySweatLocatorData.locator1_offsetAngle;
_sweatLocatorUpdateInfo.locatorInfo[2].offset = liveTimelineKeySweatLocatorData.locator2_offset;
_sweatLocatorUpdateInfo.locatorInfo[2].offsetAngle = liveTimelineKeySweatLocatorData.locator2_offsetAngle;
_sweatLocatorUpdateInfo.locatorInfo[3].offset = liveTimelineKeySweatLocatorData.locator3_offset;
_sweatLocatorUpdateInfo.locatorInfo[3].offsetAngle = liveTimelineKeySweatLocatorData.locator3_offsetAngle;
_sweatLocatorUpdateInfo.locatorInfo[4].offset = liveTimelineKeySweatLocatorData.locator4_offset;
_sweatLocatorUpdateInfo.locatorInfo[4].offsetAngle = liveTimelineKeySweatLocatorData.locator4_offsetAngle;
}
_sweatLocatorUpdateInfo.owner = liveTimelineKeySweatLocatorData.owner;
_sweatLocatorUpdateInfo.locatorInfo[0].isVisible = liveTimelineKeySweatLocatorData.locator0_isVisible;
_sweatLocatorUpdateInfo.locatorInfo[1].isVisible = liveTimelineKeySweatLocatorData.locator1_isVisible;
_sweatLocatorUpdateInfo.locatorInfo[2].isVisible = liveTimelineKeySweatLocatorData.locator2_isVisible;
_sweatLocatorUpdateInfo.locatorInfo[3].isVisible = liveTimelineKeySweatLocatorData.locator3_isVisible;
_sweatLocatorUpdateInfo.locatorInfo[4].isVisible = liveTimelineKeySweatLocatorData.locator4_isVisible;
if (liveTimelineSweatLocatorData.randomVisibleIndex.Count < liveTimelineKeySweatLocatorData.randomVisibleCount)
{
_sweatLocatorRandomIndex.Clear();
for (int j = 0; j < _sweatLocatorUpdateInfo.locatorInfo.Length; j++)
{
_sweatLocatorRandomIndex.Add(j);
}
do
{
int index = UnityEngine.Random.Range(0, _sweatLocatorRandomIndex.Count);
int item = _sweatLocatorRandomIndex[index];
if (!liveTimelineSweatLocatorData.randomVisibleIndex.Contains(item))
{
liveTimelineSweatLocatorData.randomVisibleIndex.Add(item);
}
_sweatLocatorRandomIndex.RemoveAt(index);
}
while (liveTimelineSweatLocatorData.randomVisibleIndex.Count < liveTimelineKeySweatLocatorData.randomVisibleCount && 0 < _sweatLocatorRandomIndex.Count);
}
else if (liveTimelineKeySweatLocatorData.randomVisibleCount < liveTimelineSweatLocatorData.randomVisibleIndex.Count)
{
do
{
int index2 = UnityEngine.Random.Range(0, liveTimelineSweatLocatorData.randomVisibleIndex.Count);
liveTimelineSweatLocatorData.randomVisibleIndex.RemoveAt(index2);
}
while (liveTimelineKeySweatLocatorData.randomVisibleCount < liveTimelineSweatLocatorData.randomVisibleIndex.Count);
}
if (0 < liveTimelineSweatLocatorData.randomVisibleIndex.Count)
{
for (int k = 0; k < _sweatLocatorUpdateInfo.locatorInfo.Length; k++)
{
_sweatLocatorUpdateInfo.locatorInfo[k].isVisible = false;
_sweatLocatorUpdateInfo.locatorInfo[k].offset = Vector3.zero;
_sweatLocatorUpdateInfo.locatorInfo[k].offsetAngle = Vector3.zero;
}
for (int l = 0; l < liveTimelineSweatLocatorData.randomVisibleIndex.Count; l++)
{
_sweatLocatorUpdateInfo.locatorInfo[liveTimelineSweatLocatorData.randomVisibleIndex[l]].isVisible = true;
}
}
this.OnUpdateSweatLocator(ref _sweatLocatorUpdateInfo);
}
}
/// <summary>
/// �����Y�t���A�̃p�����[�^���X�V����
/// </summary>
public void AlterUpdate_LensFlare(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateLensFlare == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.lensFlareList.Count;
LensFlareUpdateInfo updateInfo = default(LensFlareUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineLensFlareData liveTimelineLensFlareData = sheet.lensFlareList[i];
if (liveTimelineLensFlareData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineLensFlareData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineLensFlareData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineLensFlareData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyLensFlareData liveTimelineKeyLensFlareData = liveTimelineKey as LiveTimelineKeyLensFlareData;
LiveTimelineKeyLensFlareData liveTimelineKeyLensFlareData2 = liveTimelineKey2 as LiveTimelineKeyLensFlareData;
if (liveTimelineKeyLensFlareData2 != null && liveTimelineKeyLensFlareData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyLensFlareData, liveTimelineKeyLensFlareData2, currentFrame);
updateInfo.color = LerpWithoutClamp(liveTimelineKeyLensFlareData.color, liveTimelineKeyLensFlareData2.color, t);
updateInfo.offset = LerpWithoutClamp(liveTimelineKeyLensFlareData.offset, liveTimelineKeyLensFlareData2.offset, t);
updateInfo.brightness = LerpWithoutClamp(liveTimelineKeyLensFlareData.brightness, liveTimelineKeyLensFlareData2.brightness, t);
updateInfo.fadeSpeed = LerpWithoutClamp(liveTimelineKeyLensFlareData.fadeSpeed, liveTimelineKeyLensFlareData2.fadeSpeed, t);
}
else
{
updateInfo.color = liveTimelineKeyLensFlareData.color;
updateInfo.offset = liveTimelineKeyLensFlareData.offset;
updateInfo.brightness = liveTimelineKeyLensFlareData.brightness;
updateInfo.fadeSpeed = liveTimelineKeyLensFlareData.fadeSpeed;
}
updateInfo.data = liveTimelineLensFlareData;
this.OnUpdateLensFlare(ref updateInfo);
}
}
}
private void AlterUpdate_A2UConfig(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateA2UConfig == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
A2UConfigUpdateInfo updateInfo = default(A2UConfigUpdateInfo);
float num = 0.0166666675f;
for (int i = 0; i < sheet.a2uConfigList.Count; i++)
{
LiveTimelineA2UConfigData liveTimelineA2UConfigData = sheet.a2uConfigList[i];
if (!liveTimelineA2UConfigData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
FindTimelineKey(out curKey, out nextKey, liveTimelineA2UConfigData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyA2UConfigData liveTimelineKeyA2UConfigData = curKey as LiveTimelineKeyA2UConfigData;
updateInfo.blend = liveTimelineKeyA2UConfigData.blend;
updateInfo.order = liveTimelineKeyA2UConfigData.order;
updateInfo.enable = liveTimelineKeyA2UConfigData.enable;
updateInfo.data = liveTimelineA2UConfigData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyA2UConfigData.frame) * num;
this.OnUpdateA2UConfig(ref updateInfo);
}
}
}
}
private void AlterUpdate_A2U(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateA2U == null)
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
A2UUpdateInfo updateInfo = default(A2UUpdateInfo);
float num = 0.0166666675f;
for (int i = 0; i < sheet.a2uList.Count; i++)
{
LiveTimelineA2UData liveTimelineA2UData = sheet.a2uList[i];
if (liveTimelineA2UData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
continue;
}
FindTimelineKey(out curKey, out nextKey, liveTimelineA2UData.keys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyA2UData liveTimelineKeyA2UData = curKey as LiveTimelineKeyA2UData;
LiveTimelineKeyA2UData liveTimelineKeyA2UData2 = nextKey as LiveTimelineKeyA2UData;
if (liveTimelineKeyA2UData2 != null && liveTimelineKeyA2UData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyA2UData, liveTimelineKeyA2UData2, currentFrame);
updateInfo.position = LerpWithoutClamp(liveTimelineKeyA2UData.position, liveTimelineKeyA2UData2.position, t);
updateInfo.scale = LerpWithoutClamp(liveTimelineKeyA2UData.scale, liveTimelineKeyA2UData2.scale, t);
updateInfo.rotationZ = LerpWithoutClamp(liveTimelineKeyA2UData.rotationZ, liveTimelineKeyA2UData2.rotationZ, t);
updateInfo.spriteScale = LerpWithoutClamp(liveTimelineKeyA2UData.spriteScale, liveTimelineKeyA2UData2.spriteScale, t);
updateInfo.spriteOpacity = LerpWithoutClamp(liveTimelineKeyA2UData.spriteOpacity, liveTimelineKeyA2UData2.spriteOpacity, t);
updateInfo.speed = LerpWithoutClamp(liveTimelineKeyA2UData.speed, liveTimelineKeyA2UData2.speed, t);
}
else
{
updateInfo.position = liveTimelineKeyA2UData.position;
updateInfo.scale = liveTimelineKeyA2UData.scale;
updateInfo.rotationZ = liveTimelineKeyA2UData.rotationZ;
updateInfo.spriteScale = liveTimelineKeyA2UData.spriteScale;
updateInfo.spriteOpacity = liveTimelineKeyA2UData.spriteOpacity;
updateInfo.speed = liveTimelineKeyA2UData.speed;
}
updateInfo.spriteColor = liveTimelineKeyA2UData.spriteColor;
updateInfo.textureIndex = (uint)Math.Max(0, liveTimelineKeyA2UData.textureIndex);
updateInfo.appearanceRandomSeed = liveTimelineKeyA2UData.appearanceRandomSeed;
updateInfo.spriteAppearance = liveTimelineKeyA2UData.spriteAppearance;
updateInfo.slopeRandomSeed = liveTimelineKeyA2UData.slopeRandomSeed;
updateInfo.spriteMinSlope = liveTimelineKeyA2UData.spriteMinSlope;
updateInfo.spriteMaxSlope = liveTimelineKeyA2UData.spriteMaxSlope;
updateInfo.startSec = Mathf.Max(0f, liveTimelineKeyA2UData.startSec);
updateInfo.isFlick = liveTimelineKeyA2UData.isFlick;
updateInfo.enable = liveTimelineKeyA2UData.enable;
updateInfo.data = liveTimelineA2UData;
updateInfo.progressTime = (float)(currentFrame - liveTimelineKeyA2UData.frame) * num;
this.OnUpdateA2U(ref updateInfo);
}
}
}
public void InitializeCrossFadeCamera(CacheCamera camera)
{
_crossFadeCameraCache = camera;
}
public Quaternion GetCrossCameraWorldRotation()
{
if (_crossFadeCameraCache == null)
{
return Quaternion.identity;
}
return _crossFadeCameraCache.cacheTransform.rotation;
}
public CacheCamera GetCrossFadeCameraCache()
{
return _crossFadeCameraCache;
}
public bool CalculateCrossFadeCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, int currentFrame)
{
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
config.lookAtKeys = null;
config.posKeys = sheet.crossFadeCameraPosKeys;
config.extraCameraIndex = 0;
CacheCamera crossFadeCameraCache = _crossFadeCameraCache;
return CalculateCameraPos(out pos, sheet, currentFrame, crossFadeCameraCache, ref config, ref fnGetCameraPosValue);
}
public bool CalculateCrossFadeCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, LiveTimelineKey curKey, LiveTimelineKey nextKey, int currentFrame)
{
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = curKey;
config.nextKey = nextKey;
config.keyType = FindTimelineConfig.KeyType.KeyDirect;
config.posKeys = sheet.crossFadeCameraPosKeys;
config.lookAtKeys = null;
CacheCamera crossFadeCameraCache = _crossFadeCameraCache;
config.extraCameraIndex = 0;
return CalculateCameraPos(out pos, sheet, currentFrame, crossFadeCameraCache, ref config, ref fnGetCameraPosValue);
}
public bool CalculateCrossFadeCameraLookAt(out Vector3 lookAtPos, LiveTimelineWorkSheet sheet, int currentFrame)
{
CacheCamera crossFadeCameraCache = GetCrossFadeCameraCache();
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
config.posKeys = sheet.crossFadeCameraPosKeys;
config.lookAtKeys = sheet.crossFadeCameraLookAtKeys;
config.extraCameraIndex = 0;
return CalculateCameraLookAt(out lookAtPos, sheet, currentFrame, crossFadeCameraCache, ref config, ref fnGetCameraLookAtValue, ref fnGetCameraPosValue);
}
private void AlterUpdate_CrossFadeCameraPosition(CacheCamera cam, LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateCrossFadeCamera == null)
{
return;
}
CrossFadeCameraUpdateInfo updateInfo = default(CrossFadeCameraUpdateInfo);
updateInfo.isEnable = false;
updateInfo.alpha = 0f;
if (sheet.crossFadeCameraPosKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
this.OnUpdateCrossFadeCamera(ref updateInfo);
return;
}
if (!sheet.crossFadeCameraPosKeys.EnablePlayModeTimeline(_playMode))
{
this.OnUpdateCrossFadeCamera(ref updateInfo);
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.crossFadeCameraPosKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCrossFadeCameraPositionData liveTimelineKeyCrossFadeCameraPositionData = curKey as LiveTimelineKeyCrossFadeCameraPositionData;
AlterUpdate_CrossFadeCameraAlpha(cam, sheet, currentFrame, out var alpha);
updateInfo.isEnable = liveTimelineKeyCrossFadeCameraPositionData.isEnable;
updateInfo.alpha = alpha;
this.OnUpdateCrossFadeCamera(ref updateInfo);
if (updateInfo.isEnable)
{
cam.camera.nearClipPlane = liveTimelineKeyCrossFadeCameraPositionData.nearClip;
cam.camera.farClipPlane = liveTimelineKeyCrossFadeCameraPositionData.farClip;
if (CalculateCrossFadeCameraPos(out var pos, sheet, curKey, nextKey, currentFrame))
{
cam.cacheTransform.position = pos;
int cullingMask = liveTimelineKeyCrossFadeCameraPositionData.GetCullingMask();
cam.camera.cullingMask = cullingMask;
}
}
}
private void AlterUpdate_CrossFadeCameraAlpha(CacheCamera cam, LiveTimelineWorkSheet sheet, int currentFrame, out float alpha)
{
alpha = 0f;
if (sheet.crossFadeCameraAlphaKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.crossFadeCameraAlphaKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.crossFadeCameraAlphaKeys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyCrossFadeCameraAlphaData liveTimelineKeyCrossFadeCameraAlphaData = curKey as LiveTimelineKeyCrossFadeCameraAlphaData;
LiveTimelineKeyCrossFadeCameraAlphaData liveTimelineKeyCrossFadeCameraAlphaData2 = nextKey as LiveTimelineKeyCrossFadeCameraAlphaData;
if (liveTimelineKeyCrossFadeCameraAlphaData2 != null && liveTimelineKeyCrossFadeCameraAlphaData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCrossFadeCameraAlphaData, liveTimelineKeyCrossFadeCameraAlphaData2, currentFrame);
alpha = LerpWithoutClamp(liveTimelineKeyCrossFadeCameraAlphaData.alpha, liveTimelineKeyCrossFadeCameraAlphaData2.alpha, t);
}
else
{
alpha = liveTimelineKeyCrossFadeCameraAlphaData.alpha;
}
}
}
private void AlterUpdate_CrossFadeCameraLookAt(CacheCamera cam, LiveTimelineWorkSheet sheet, int currentFrame, ref Vector3 outLookAt)
{
if (!sheet.crossFadeCameraLookAtKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && sheet.crossFadeCameraLookAtKeys.EnablePlayModeTimeline(_playMode) && CalculateCrossFadeCameraLookAt(out var lookAtPos, sheet, currentFrame))
{
cam.cacheTransform.LookAt(lookAtPos, Vector3.up);
outLookAt = lookAtPos;
}
}
private void AlterUpdate_CrossFadeCameraFov(CacheCamera cam, LiveTimelineWorkSheet sheet, int currentFrame)
{
if (sheet.crossFadeCameraFovKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.crossFadeCameraFovKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.crossFadeCameraFovKeys, currentFrame);
if (curKey == null)
{
return;
}
LiveTimelineKeyCrossFadeCameraFovData liveTimelineKeyCrossFadeCameraFovData = curKey as LiveTimelineKeyCrossFadeCameraFovData;
LiveTimelineKeyCrossFadeCameraFovData liveTimelineKeyCrossFadeCameraFovData2 = nextKey as LiveTimelineKeyCrossFadeCameraFovData;
float num = 80f;
if (liveTimelineKeyCrossFadeCameraFovData2 != null && liveTimelineKeyCrossFadeCameraFovData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCrossFadeCameraFovData, liveTimelineKeyCrossFadeCameraFovData2, currentFrame);
num = LerpWithoutClamp(liveTimelineKeyCrossFadeCameraFovData.fov, liveTimelineKeyCrossFadeCameraFovData2.fov, t);
}
else if (liveTimelineKeyCrossFadeCameraFovData.fovType == LiveCameraFovType.Direct)
{
num = liveTimelineKeyCrossFadeCameraFovData.fov;
}
if (_limitFovForWidth)
{
float num2 = (float)cam.camera.pixelWidth / (float)cam.camera.pixelHeight;
if (num2 > _baseCameraAspectRatio)
{
float num3 = num2 / _baseCameraAspectRatio;
num /= num3;
}
}
cam.camera.fieldOfView = num;
}
private void AlterUpdate_CrossFadeCameraRoll(CacheCamera cam, LiveTimelineWorkSheet sheet, int currentFrame)
{
if (sheet.crossFadeCameraRollKeys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !sheet.crossFadeCameraRollKeys.EnablePlayModeTimeline(_playMode))
{
return;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.crossFadeCameraRollKeys, currentFrame);
if (curKey != null)
{
LiveTimelineKeyCameraRollData liveTimelineKeyCameraRollData = curKey as LiveTimelineKeyCameraRollData;
LiveTimelineKeyCameraRollData liveTimelineKeyCameraRollData2 = nextKey as LiveTimelineKeyCameraRollData;
float num = 80f;
if (liveTimelineKeyCameraRollData2 != null && liveTimelineKeyCameraRollData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyCameraRollData, liveTimelineKeyCameraRollData2, currentFrame);
num = LerpWithoutClamp(liveTimelineKeyCameraRollData.degree, liveTimelineKeyCameraRollData2.degree, t);
}
else
{
num = liveTimelineKeyCameraRollData.degree;
}
cam.cacheTransform.Rotate(0f, 0f, num);
}
}
private void AlterUpdate_CrossFadeCamera(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_crossFadeCameraCache != null)
{
AlterUpdate_CrossFadeCameraPosition(_crossFadeCameraCache, sheet, currentFrame);
if (_crossFadeCameraCache.camera.enabled)
{
Vector3 outLookAt = Vector3.zero;
AlterUpdate_CrossFadeCameraLookAt(_crossFadeCameraCache, sheet, currentFrame, ref outLookAt);
AlterUpdate_CrossFadeCameraFov(_crossFadeCameraCache, sheet, currentFrame);
AlterUpdate_CrossFadeCameraRoll(_crossFadeCameraCache, sheet, currentFrame);
}
}
}
public Quaternion GetMonitorCameraWorldRotation(int index)
{
if (_arrMonitorCameraCache == null || _arrMonitorCameraCache.Length <= index)
{
return Quaternion.identity;
}
return _arrMonitorCameraCache[index].cacheTransform.rotation;
}
public bool ExistsMonitroCamera(int index)
{
if (_arrMonitorCameraCache != null && index < _arrMonitorCameraCache.Length)
{
return _arrMonitorCameraCache[index] != null;
}
return false;
}
/// <summary>
/// ���j�^�[�J�������Z�b�g����
/// </summary>
public void SetMonitorCameras(MonitorCamera[] monitorCameras)
{
if (monitorCameras != null && monitorCameras.Length != 0)
{
int num = monitorCameras.Length;
_arrMonitorCameraCache = new CacheCamera[num];
_arrMonitorCameraRoll = new float[num];
for (int i = 0; i < num; i++)
{
_arrMonitorCameraCache[i] = new CacheCamera(monitorCameras[i].targetCamera);
_arrMonitorCameraRoll[i] = 0f;
}
}
else
{
_arrMonitorCameraCache = null;
}
}
/// <summary>
/// ���j�^�[�J�������X�V����
/// </summary>
private void AlterUpdate_MonitorCamera(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length != 0)
{
AlterUpdate_MonitorCameraPosition(sheet, currentFrame);
AlterUpdate_MonitorCameraLookAt(sheet, currentFrame);
for (int i = 0; i < _arrMonitorCameraCache.Length; i++)
{
float zAngle = _arrMonitorCameraRoll[i];
_arrMonitorCameraCache[i].cacheTransform.Rotate(0f, 0f, zAngle);
}
}
}
private static Vector3 GetMonitorCameraPositionValue(LiveTimelineKeyCameraPositionData keyData, LiveTimelineControl timelineControl, FindTimelineConfig config)
{
return (keyData as LiveTimelineKeyMonitorCameraPositionData).GetValue(timelineControl, config.extraCameraIndex);
}
public bool CalculateMonitorCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, int currentFrame, int timelineIndex = 0)
{
if (sheet.monitorCameraPosKeys.Count <= timelineIndex || _arrMonitorCameraCache == null || (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length <= timelineIndex))
{
pos = Vector3.zero;
return false;
}
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
config.lookAtKeys = null;
config.posKeys = sheet.monitorCameraPosKeys[timelineIndex].keys;
config.extraCameraIndex = timelineIndex;
return CalculateCameraPos(out pos, sheet, currentFrame, _arrMonitorCameraCache[timelineIndex], ref config, ref fnGetMonitorCameraPositionValue);
}
public bool CalculateMonitorCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, int currentFrame, LiveTimelineKey curKey, LiveTimelineKey nextKey, int timelineIndex = 0)
{
if (sheet.monitorCameraPosKeys.Count <= timelineIndex || _arrMonitorCameraCache == null || (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length <= timelineIndex))
{
pos = Vector3.zero;
return false;
}
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = curKey;
config.nextKey = nextKey;
config.keyType = FindTimelineConfig.KeyType.KeyDirect;
config.lookAtKeys = null;
config.posKeys = sheet.monitorCameraPosKeys[timelineIndex].keys;
config.extraCameraIndex = timelineIndex;
return CalculateCameraPos(out pos, sheet, currentFrame, _arrMonitorCameraCache[timelineIndex], ref config, ref fnGetMonitorCameraPositionValue);
}
/// <summary>
/// ���j�^�[�J�����̃|�W�V�������X�V����
/// �J�����̃p�����[�^�������ōX�V
/// </summary>
private void AlterUpdate_MonitorCameraPosition(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_arrMonitorCameraCache == null || (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length == 0))
{
return;
}
int count = sheet.monitorCameraPosKeys.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyMonitorCameraPositionDataList keys = sheet.monitorCameraPosKeys[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode) || _arrMonitorCameraCache.Length <= i)
{
continue;
}
CacheCamera cacheCamera = _arrMonitorCameraCache[i];
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (curKey != null)
{
if (CalculateMonitorCameraPos(out var pos, sheet, currentFrame, curKey, nextKey, i))
{
cacheCamera.cacheTransform.position = pos;
}
LiveTimelineKeyMonitorCameraPositionData liveTimelineKeyMonitorCameraPositionData = curKey as LiveTimelineKeyMonitorCameraPositionData;
LiveTimelineKeyMonitorCameraPositionData liveTimelineKeyMonitorCameraPositionData2 = nextKey as LiveTimelineKeyMonitorCameraPositionData;
float num = 80f;
float num2 = 0f;
if (liveTimelineKeyMonitorCameraPositionData2 != null && liveTimelineKeyMonitorCameraPositionData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMonitorCameraPositionData, liveTimelineKeyMonitorCameraPositionData2, currentFrame);
num = LerpWithoutClamp(liveTimelineKeyMonitorCameraPositionData.fov, liveTimelineKeyMonitorCameraPositionData2.fov, t);
num2 = LerpWithoutClamp(liveTimelineKeyMonitorCameraPositionData.roll, liveTimelineKeyMonitorCameraPositionData2.roll, t);
}
else
{
num = liveTimelineKeyMonitorCameraPositionData.fov;
num2 = liveTimelineKeyMonitorCameraPositionData.roll;
}
_arrMonitorCameraRoll[i] = num2;
cacheCamera.camera.fieldOfView = num;
cacheCamera.camera.nearClipPlane = liveTimelineKeyMonitorCameraPositionData.nearClip;
cacheCamera.camera.farClipPlane = liveTimelineKeyMonitorCameraPositionData.farClip;
if (liveTimelineKeyMonitorCameraPositionData.enable)
{
cacheCamera.camera.cullingMask = liveTimelineKeyMonitorCameraPositionData.GetCullingMask();
}
if (this.OnUpdateMonitorCamera != null)
{
MonitorCameraUpdateInfo updateInfo = default(MonitorCameraUpdateInfo);
updateInfo.index = i;
updateInfo.enable = liveTimelineKeyMonitorCameraPositionData.enable;
updateInfo.visibleCharaFlag = liveTimelineKeyMonitorCameraPositionData.visibleCharaPositionFlag;
this.OnUpdateMonitorCamera(ref updateInfo);
}
}
}
}
private static Vector3 GetMonitorCameraLookAtValue(LiveTimelineKeyCameraLookAtData keyData, LiveTimelineControl timelineControl, Vector3 camPos, FindTimelineConfig config)
{
return (keyData as LiveTimelineKeyMonitorCameraLookAtData).GetValue(timelineControl, camPos, config.extraCameraIndex);
}
/// <summary>
/// ���j�^�[�J�����̎��_���v�Z����
/// </summary>
public bool CalculateMonitorCameraLookAt(out Vector3 lookAtPos, LiveTimelineWorkSheet sheet, int currentFrame, int timelineIndex = 0)
{
if (sheet.monitorLookAtPosKeys.Count <= timelineIndex || _arrMonitorCameraCache == null || (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length <= timelineIndex))
{
lookAtPos = Vector3.zero;
return false;
}
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = null;
config.nextKey = null;
config.keyType = FindTimelineConfig.KeyType.CurrentFrame;
if (sheet.monitorCameraPosKeys.Count <= timelineIndex || sheet.monitorLookAtPosKeys.Count <= timelineIndex)
{
lookAtPos = Vector3.zero;
return false;
}
config.posKeys = sheet.monitorCameraPosKeys[timelineIndex].keys;
config.lookAtKeys = sheet.monitorLookAtPosKeys[timelineIndex].keys;
config.extraCameraIndex = timelineIndex;
return CalculateCameraLookAt(out lookAtPos, sheet, currentFrame, _arrMonitorCameraCache[timelineIndex], ref config, ref fnGetMonitorCameraLookAtValue, ref fnGetMonitorCameraPositionValue);
}
/// <summary>
/// ���j�^�[�J�����̎��_���X�V����
/// </summary>
private void AlterUpdate_MonitorCameraLookAt(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_arrMonitorCameraCache == null || (_arrMonitorCameraCache != null && _arrMonitorCameraCache.Length == 0))
{
return;
}
int count = sheet.monitorLookAtPosKeys.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyMonitorCameraLookAtDataList keys = sheet.monitorLookAtPosKeys[i].keys;
if (!keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && keys.EnablePlayModeTimeline(_playMode) && _arrMonitorCameraCache.Length > i)
{
CacheCamera cacheCamera = _arrMonitorCameraCache[i];
if (!CalculateMonitorCameraLookAt(out var lookAtPos, sheet, currentFrame, i))
{
break;
}
cacheCamera.cacheTransform.LookAt(lookAtPos);
}
}
}
public MultiCameraManager GetMultiCameraManager()
{
return _multiCameraManager;
}
public Quaternion GetMultiCameraWorldRotation(int index)
{
if (_multiCameraCache == null || _multiCameraCache.Length <= index)
{
return Quaternion.identity;
}
return _multiCameraCache[index].cacheTransform.rotation;
}
public bool ExistsMultiCamera(int index)
{
if (_multiCameraCache != null && index < _multiCameraCache.Length)
{
return _multiCameraCache[index] != null;
}
return false;
}
public void SetMultiCamera(MultiCameraManager manager, MultiCamera[] multiCamera)
{
_multiCamera = multiCamera;
_multiCameraManager = manager;
if (multiCamera != null)
{
_multiCameraCache = new CacheCamera[multiCamera.Length];
for (int i = 0; i < multiCamera.Length; i++)
{
_multiCameraCache[i] = new CacheCamera(multiCamera[i].GetCamera());
}
}
}
private static Vector3 GetMultiCameraPositionValue(LiveTimelineKeyCameraPositionData keyData, LiveTimelineControl timelineControl, FindTimelineConfig config)
{
return (keyData as LiveTimelineKeyMultiCameraPositionData).GetValue(timelineControl, config.extraCameraIndex);
}
public bool CalculateMultiCameraPos(out Vector3 pos, LiveTimelineWorkSheet sheet, LiveTimelineKey curKey, LiveTimelineKey nextKey, int currentFrame, int timelineIndex)
{
if (sheet.multiCameraPositionKeys.Count <= timelineIndex)
{
pos = Vector3.zero;
return false;
}
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = curKey;
config.nextKey = nextKey;
config.keyType = FindTimelineConfig.KeyType.KeyDirect;
config.posKeys = sheet.multiCameraPositionKeys[timelineIndex].keys;
config.lookAtKeys = null;
config.extraCameraIndex = timelineIndex;
return CalculateCameraPos(out pos, sheet, currentFrame, _multiCameraCache[timelineIndex], ref config, ref fnGetMultiCameraPositionValueFunc);
}
private void AlterUpdate_MultiCameraPosition(LiveTimelineWorkSheet sheet, int currentFrame)
{
int count = sheet.multiCameraPositionKeys.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyMultiCameraPositionDataList keys = sheet.multiCameraPositionKeys[i].keys;
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode) || i >= _multiCameraCache.Length)
{
continue;
}
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, keys, currentFrame);
if (!CalculateMultiCameraPos(out var pos, sheet, curKey, nextKey, currentFrame, i))
{
continue;
}
CacheCamera cacheCamera = _multiCameraCache[i];
Camera camera = cacheCamera.camera;
if (curKey == null)
{
continue;
}
LiveTimelineKeyMultiCameraPositionData liveTimelineKeyMultiCameraPositionData = curKey as LiveTimelineKeyMultiCameraPositionData;
LiveTimelineKeyMultiCameraPositionData liveTimelineKeyMultiCameraPositionData2 = nextKey as LiveTimelineKeyMultiCameraPositionData;
camera.enabled = liveTimelineKeyMultiCameraPositionData.enableMultiCamera;
if (liveTimelineKeyMultiCameraPositionData.enableMultiCamera)
{
_isMultiCameraEnable = true;
camera.cullingMask = 0x10000000 | liveTimelineKeyMultiCameraPositionData.GetCullingMask();
float fieldOfView;
Vector3 maskPosition;
Quaternion maskRotation;
Vector3 maskScale;
if (liveTimelineKeyMultiCameraPositionData2 != null && liveTimelineKeyMultiCameraPositionData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMultiCameraPositionData, liveTimelineKeyMultiCameraPositionData2, currentFrame);
fieldOfView = LerpWithoutClamp(liveTimelineKeyMultiCameraPositionData.fov, liveTimelineKeyMultiCameraPositionData2.fov, t);
maskPosition = LerpWithoutClamp(liveTimelineKeyMultiCameraPositionData.maskPosition, liveTimelineKeyMultiCameraPositionData2.maskPosition, t);
maskRotation = Quaternion.Lerp(liveTimelineKeyMultiCameraPositionData.maskRotation, liveTimelineKeyMultiCameraPositionData2.maskRotation, t);
maskScale = LerpWithoutClamp(liveTimelineKeyMultiCameraPositionData.maskScale, liveTimelineKeyMultiCameraPositionData2.maskScale, t);
}
else
{
fieldOfView = liveTimelineKeyMultiCameraPositionData.fov;
maskPosition = liveTimelineKeyMultiCameraPositionData.maskPosition;
maskRotation = liveTimelineKeyMultiCameraPositionData.maskRotation;
maskScale = liveTimelineKeyMultiCameraPositionData.maskScale;
}
camera.nearClipPlane = liveTimelineKeyMultiCameraPositionData.nearClip;
camera.farClipPlane = liveTimelineKeyMultiCameraPositionData.farClip;
camera.fieldOfView = fieldOfView;
cacheCamera.cacheTransform.localPosition = pos;
if (_multiCamera[i].maskIndex != liveTimelineKeyMultiCameraPositionData.maskIndex)
{
_multiCameraManager.AttachMask(i, liveTimelineKeyMultiCameraPositionData.maskIndex);
}
if (_multiCamera[i].maskIndex >= 0)
{
_multiCamera[i].maskPosition = maskPosition;
_multiCamera[i].maskRotation = maskRotation;
_multiCamera[i].maskScale = maskScale;
}
}
}
}
private static Vector3 GetMultiCameraLookAtValue(LiveTimelineKeyCameraLookAtData keyData, LiveTimelineControl timelineControl, Vector3 camPos, FindTimelineConfig config)
{
return (keyData as LiveTimelineKeyMultiCameraLookAtData).GetValue(timelineControl, camPos, config.extraCameraIndex);
}
public bool CalculateMultiCameraLookAt(out Vector3 pos, LiveTimelineWorkSheet sheet, LiveTimelineKey curKey, LiveTimelineKey nextKey, int currentFrame, int timelineIndex = 0)
{
if (sheet.multiCameraPositionKeys.Count <= timelineIndex || sheet.multiCameraLookAtKeys.Count <= timelineIndex)
{
pos = Vector3.zero;
return false;
}
FindTimelineConfig config = default(FindTimelineConfig);
config.curKey = curKey;
config.nextKey = nextKey;
config.keyType = FindTimelineConfig.KeyType.KeyDirect;
config.posKeys = sheet.multiCameraPositionKeys[timelineIndex].keys;
config.lookAtKeys = sheet.multiCameraLookAtKeys[timelineIndex].keys;
config.extraCameraIndex = timelineIndex;
return CalculateCameraLookAt(out pos, sheet, currentFrame, _multiCameraCache[timelineIndex], ref config, ref fnGetMultiCameraLookAtValueFunc, ref fnGetMultiCameraPositionValueFunc);
}
private void AlterUpdate_MultiCameraLookAt(LiveTimelineWorkSheet sheet, int currentFrame)
{
int count = sheet.multiCameraLookAtKeys.Count;
for (int i = 0; i < count; i++)
{
LiveTimelineKeyMultiCameraLookAtDataList keys = sheet.multiCameraLookAtKeys[i].keys;
if (i >= _multiCameraCache.Length)
{
break;
}
if (keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindTimelineKey(out var curKey, out var nextKey, keys, currentFrame);
if (curKey != null && CalculateMultiCameraLookAt(out var pos, sheet, curKey, nextKey, currentFrame, i))
{
LiveTimelineKeyMultiCameraLookAtData liveTimelineKeyMultiCameraLookAtData = curKey as LiveTimelineKeyMultiCameraLookAtData;
LiveTimelineKeyMultiCameraLookAtData liveTimelineKeyMultiCameraLookAtData2 = nextKey as LiveTimelineKeyMultiCameraLookAtData;
float zAngle;
if (liveTimelineKeyMultiCameraLookAtData2 != null && liveTimelineKeyMultiCameraLookAtData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyMultiCameraLookAtData, liveTimelineKeyMultiCameraLookAtData2, currentFrame);
zAngle = LerpWithoutClamp(liveTimelineKeyMultiCameraLookAtData.roll, liveTimelineKeyMultiCameraLookAtData2.roll, t);
}
else
{
zAngle = liveTimelineKeyMultiCameraLookAtData.roll;
}
Transform cacheTransform = _multiCameraCache[i].cacheTransform;
cacheTransform.LookAt(pos);
cacheTransform.Rotate(0f, 0f, zAngle);
}
}
}
private void AlterUpdate_MultiCamera(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (_multiCameraCache != null && !(_multiCameraManager == null) && _multiCameraManager.isInitialize)
{
AlterUpdate_MultiCameraPosition(sheet, currentFrame);
AlterUpdate_MultiCameraLookAt(sheet, currentFrame);
}
}
/// <summary>
/// Glass�pAlterUpdate
/// </summary>
public void AlterUpdate_Glass(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateGlass == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.glassList.Count;
GlassUpdateInfo updateInfo = default(GlassUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineGlassData liveTimelineGlassData = sheet.glassList[i];
if (liveTimelineGlassData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineGlassData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineGlassData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineGlassData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyGlassData liveTimelineKeyGlassData = liveTimelineKey as LiveTimelineKeyGlassData;
LiveTimelineKeyGlassData liveTimelineKeyGlassData2 = liveTimelineKey2 as LiveTimelineKeyGlassData;
if (liveTimelineKeyGlassData2 != null && liveTimelineKeyGlassData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyGlassData, liveTimelineKeyGlassData2, currentFrame);
updateInfo.transparent = LerpWithoutClamp(liveTimelineKeyGlassData.transparent, liveTimelineKeyGlassData2.transparent, t);
updateInfo.specularColor = LerpWithoutClamp(liveTimelineKeyGlassData.specularColor, liveTimelineKeyGlassData2.specularColor, t);
updateInfo.specularPower = LerpWithoutClamp(liveTimelineKeyGlassData.specularPower, liveTimelineKeyGlassData2.specularPower, t);
updateInfo.specularColor = LerpWithoutClamp(liveTimelineKeyGlassData.specularColor, liveTimelineKeyGlassData2.specularColor, t);
updateInfo.lightPosition = LerpWithoutClamp(liveTimelineKeyGlassData.lightPosition, liveTimelineKeyGlassData2.lightPosition, t);
}
else
{
updateInfo.transparent = liveTimelineKeyGlassData.transparent;
updateInfo.specularColor = liveTimelineKeyGlassData.specularColor;
updateInfo.specularPower = liveTimelineKeyGlassData.specularPower;
updateInfo.specularColor = liveTimelineKeyGlassData.specularColor;
updateInfo.lightPosition = liveTimelineKeyGlassData.lightPosition;
}
updateInfo.data = liveTimelineGlassData;
updateInfo.sortOrderOffset = liveTimelineKeyGlassData.sortOrderOffset;
this.OnUpdateGlass(ref updateInfo);
}
}
}
public void AlterUpdate_ShaderControl(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (this.OnUpdateShaderControl == null)
{
return;
}
LiveTimelineKey liveTimelineKey = null;
LiveTimelineKey liveTimelineKey2 = null;
int count = sheet.shdCtrlList.Count;
ShaderControlUpdateInfo updateInfo = default(ShaderControlUpdateInfo);
for (int i = 0; i < count; i++)
{
LiveTimelineShaderControlData liveTimelineShaderControlData = sheet.shdCtrlList[i];
if (liveTimelineShaderControlData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable) || !liveTimelineShaderControlData.keys.EnablePlayModeTimeline(_playMode))
{
continue;
}
FindKeyResult findKeyResult = liveTimelineShaderControlData.keys.FindKeyCached(currentFrame, availableFindKeyCache);
liveTimelineKey = findKeyResult.key;
if (liveTimelineKey != null)
{
liveTimelineKey2 = liveTimelineShaderControlData.keys.At(findKeyResult.index + 1);
LiveTimelineKeyShaderControlData liveTimelineKeyShaderControlData = liveTimelineKey as LiveTimelineKeyShaderControlData;
LiveTimelineKeyShaderControlData liveTimelineKeyShaderControlData2 = liveTimelineKey2 as LiveTimelineKeyShaderControlData;
if (liveTimelineShaderControlData.updatedKeyFrame == liveTimelineKeyShaderControlData.frame)
{
break;
}
liveTimelineShaderControlData.updatedKeyFrame = liveTimelineKeyShaderControlData.frame;
updateInfo.condition = liveTimelineKeyShaderControlData.condition;
updateInfo.conditionParam = liveTimelineKeyShaderControlData.conditionParam;
updateInfo.targetFlags = liveTimelineKeyShaderControlData.targetFlags;
updateInfo.behaviorFlags = liveTimelineKeyShaderControlData.behaviorFlags;
updateInfo.useVtxClrB = liveTimelineKeyShaderControlData.useVtxClrB;
if (liveTimelineKeyShaderControlData2 != null && liveTimelineKeyShaderControlData2.interpolateType != 0)
{
float t = CalculateInterpolationValue(liveTimelineKeyShaderControlData, liveTimelineKeyShaderControlData2, currentFrame);
updateInfo.lerpDiffuse = LerpWithoutClamp(liveTimelineKeyShaderControlData.lerpDiffuse, liveTimelineKeyShaderControlData2.lerpDiffuse, t);
updateInfo.lerpGradation = LerpWithoutClamp(liveTimelineKeyShaderControlData.lerpGradetion, liveTimelineKeyShaderControlData2.lerpGradetion, t);
}
else
{
updateInfo.lerpDiffuse = liveTimelineKeyShaderControlData.lerpDiffuse;
updateInfo.lerpGradation = liveTimelineKeyShaderControlData.lerpGradetion;
}
updateInfo.data = liveTimelineShaderControlData;
this.OnUpdateShaderControl(ref updateInfo);
}
}
}
public void AlterUpdate_DressChange(LiveTimelineWorkSheet sheet, int currentFrame)
{
if (!sheet.dressChangeDataList.HasAttribute(LiveTimelineKeyDataListAttr.Disable) && sheet.dressChangeDataList.EnablePlayModeTimeline(_playMode) && this.OnUpdateDressChange != null)
{
LiveTimelineKey curKey = null;
LiveTimelineKey nextKey = null;
FindTimelineKey(out curKey, out nextKey, sheet.dressChangeDataList, currentFrame);
if (curKey != null)
{
DressChangeUpdateInfo updateInfo = default(DressChangeUpdateInfo);
LiveTimelineKeyDressChangeData liveTimelineKeyDressChangeData = curKey as LiveTimelineKeyDressChangeData;
updateInfo.targetFlags = liveTimelineKeyDressChangeData.targetFlags;
updateInfo.dressType = liveTimelineKeyDressChangeData.dressType;
this.OnUpdateDressChange(ref updateInfo);
}
}
}
public void CreateIgnoreLaserHashDic()
{
int count = data.GetWorkSheetList().Count;
_ignoreLaserHashDic = new Dictionary<int, bool>[count];
for (int i = 0; i < count; i++)
{
int[] controlledGameObjectHashes = GetControlledGameObjectHashes(i);
Dictionary<int, bool> dictionary = new Dictionary<int, bool>();
for (int j = 0; j < controlledGameObjectHashes.Length; j++)
{
dictionary[controlledGameObjectHashes[j]] = true;
}
_ignoreLaserHashDic[i] = dictionary;
}
}
private int[] GetControlledGameObjectHashes(int sheetIdx)
{
if (data == null || data.GetWorkSheetList().Count <= sheetIdx)
{
return new int[0];
}
List<int> list = new List<int>();
LiveTimelineWorkSheet workSheet = data.GetWorkSheet(sheetIdx);
for (int i = 0; i < workSheet.objectList.Count; i++)
{
LiveTimelineObjectData liveTimelineObjectData = workSheet.objectList[i];
if (!liveTimelineObjectData.keys.HasAttribute(LiveTimelineKeyDataListAttr.Disable))
{
list.Add(liveTimelineObjectData.nameHash);
}
}
return list.ToArray();
}
}
}