private static void cin_log()
{
for (var i = 0; i < ModdedCinemaCamera.keyFrames.Count; i++)
{
CameraKeyFrame cam = ModdedCinemaCamera.keyFrames[i];
uConsole.Log($"{i} - Duration to get to from previous: {cam.m_DurationSeconds}");
}
}
public static void restore(int pos)
{
CameraKeyFrame cam = keyFrames[pos];
Cameras.MainCamera().transform.position = cam.m_StartPos;
Cameras.MainCamera().transform.rotation = cam.m_StartRot;
PointsOfView.UpdatePivotBasedOnCamera();
Cameras.SetOrthographicSize(cam.m_StartOrthographicSize);
}
public static CameraKeyFrame currentCamera()
{
CameraKeyFrame cam = new CameraKeyFrame();
cam.m_StartPos = Cameras.MainCamera().transform.position;
cam.m_StartRot = Cameras.MainCamera().transform.rotation;
cam.m_StartPivot = PointsOfView.m_Pivot;
cam.m_StartOrthographicSize = Cameras.GetOrthographicSize();
return(cam);
}
public static void StartInterpolate()
{
restore(current_start);
CameraKeyFrame target = keyFrames[current_end];
CameraInterpolate.SlerpTo(
target.m_StartPivot,
target.m_StartPos,
target.m_StartRot,
target.m_StartOrthographicSize,
target.m_DurationSeconds,
target.m_Ease
);
}
private void SyncCamera(CameraKeyFrame keyframe, CameraKeyFrame prevKeyframe, float t)
{
Human human = Human.all[0];
Vector3 pos = prevKeyframe.pos;
Quaternion a = prevKeyframe.rot;
Vector3 pos2 = keyframe.pos;
Quaternion b = keyframe.rot;
if (prevKeyframe.humanRelative)
{
pos += human.transform.position;
}
if (keyframe.humanRelative)
{
pos2 += human.transform.position;
}
Vector3 vector = Vector3.Lerp(pos, pos2, t);
Vector3 a2 = Vector3.Lerp(prevKeyframe.targetPos, keyframe.targetPos, t);
Quaternion quaternion = Quaternion.LookRotation(a2 - vector, Vector3.up);
Quaternion quaternion2 = Quaternion.LookRotation(human.transform.position - vector, Vector3.up);
if (prevKeyframe.targetFocus)
{
a = quaternion;
}
if (keyframe.targetFocus)
{
b = quaternion;
}
if (prevKeyframe.humanRelative)
{
a = quaternion2;
}
if (keyframe.humanRelative)
{
b = quaternion2;
}
Quaternion rotation = Quaternion.Lerp(a, b, t);
base.transform.position = vector;
base.transform.rotation = rotation;
}
private static void cin_add()
{
CinemaCamera.SaveStart(null); // we do this...
CinemaCamera.SaveEnd(); // to trick the main Cinema Camera into thinking it's initiated
// usage: cin_add <float m_DurationSeconds> <bool m_Ease> <int index>
float m_DurationSeconds = 5;
bool m_Ease = false;
int index = -1;
if (uConsole.NextParameterIsFloat())
{
m_DurationSeconds = uConsole.GetFloat();
}
if (uConsole.NextParameterIsBool())
{
m_Ease = uConsole.GetBool();
}
if (uConsole.GetNumParameters() == 3 && uConsole.NextParameterIsInt())
{
index = Math.Max(0, uConsole.GetInt());
}
CameraKeyFrame cam = ModdedCinemaCamera.currentCamera();
cam.m_DurationSeconds = m_DurationSeconds;
cam.m_Ease = m_Ease;
if (index != -1)
{
ModdedCinemaCamera.keyFrames.Insert(index, cam);
ModdedCinemaCamera.InterpolateHandler.controlPointsList.Insert(index, cam.m_StartPos.normalized);
ModdedCinemaCamera.PivotHandler.controlPointsList.Insert(index, cam.m_StartPivot);
uConsole.Log($"Inserted keyframe into position {index} of list.");
}
else
{
ModdedCinemaCamera.keyFrames.Add(cam);
ModdedCinemaCamera.InterpolateHandler.controlPointsList.Add(cam.m_StartPos.normalized);
ModdedCinemaCamera.PivotHandler.controlPointsList.Add(cam.m_StartPivot);
uConsole.Log("Added keyframe to end of list.");
}
}
private static void cin_modify()
{
CinemaCamera.SaveStart(null); // we do this...
CinemaCamera.SaveEnd(); // to trick the main Cinema Camera into thinking it's initiated
// usage: cin_add <float m_DurationSeconds> <bool m_Ease> <int index>
int index = ModdedCinemaCamera.keyFrames.Count - 1;
if (uConsole.NextParameterIsInt())
{
index = Mathf.Clamp(uConsole.GetInt(), 0, ModdedCinemaCamera.keyFrames.Count - 1);
}
CameraKeyFrame cam = ModdedCinemaCamera.keyFrames[index];
if (uConsole.NextParameterIsFloat())
{
cam.m_DurationSeconds = uConsole.GetFloat();
}
if (uConsole.NextParameterIsBool())
{
cam.m_Ease = uConsole.GetBool();
}
uConsole.Log($"Modified keyframe {index}");
}
public void OnFrame()
{
if (UIImGui.requireOpenFolder.SetFalse())
{
string path = OpenResourceFolder();
if (!string.IsNullOrEmpty(path))
{
DirectoryInfo folder = new DirectoryInfo(path);
UIImGui.viewRequest = folder;
caches.AddFolder(folder);
}
gameDriverContext.RequireRender(false);
}
if (UIImGui.requestSelectRenderPipelines.SetFalse())
{
string path = OpenResourceFolder();
if (!string.IsNullOrEmpty(path))
{
DirectoryInfo folder = new DirectoryInfo(path);
UIImGui.renderPipelinesRequest = folder;
caches.AddFolder(folder);
}
gameDriverContext.RequireRender(false);
}
if (UIImGui.viewRequest != null)
{
var view = UIImGui.viewRequest;
UIImGui.viewRequest = null;
UIImGui.currentFolder = view;
SetViewFolder(view.GetFileSystemInfos());
gameDriverContext.RequireRender(false);
}
if (UIImGui.openRequest != null)
{
var file = UIImGui.openRequest;
UIImGui.openRequest = null;
string ext = file.Extension.ToLower();
switch (ext)
{
case ".pmx":
case ".gltf":
LoadEntityIntoScene(file);
break;
case ".vmd":
BinaryReader reader = new BinaryReader(file.OpenRead());
VMDFormat motionSet = VMDFormat.Load(reader);
if (motionSet.CameraKeyFrames.Count != 0)
{
var camera = windowSystem.currentChannel.camera;
camera.cameraMotion.cameraKeyFrames = motionSet.CameraKeyFrames;
for (int i = 0; i < camera.cameraMotion.cameraKeyFrames.Count; i++)
{
CameraKeyFrame frame = camera.cameraMotion.cameraKeyFrames[i];
frame.distance *= 0.1f;
frame.position *= 0.1f;
camera.cameraMotion.cameraKeyFrames[i] = frame;
}
camera.CameraMotionOn = true;
}
else
{
foreach (var gameObject in this.scene.SelectedGameObjects)
{
var animationState = gameObject.GetComponent <Components.AnimationStateComponent>();
if (animationState != null)
{
animationState.motionPath = file.FullName;
}
}
gameDriverContext.RequireResetPhysics = true;
}
break;
case ".coocoo3dscene":
var scene = ReadJsonStream <Coocoo3DScene>(file.OpenRead());
scene.ToScene(this.scene, caches);
gameDriverContext.RequireResetPhysics = true;
break;
}
gameDriverContext.RequireRender(true);
}
if (UIImGui.requestRecord.SetFalse())
{
gameDriverContext.NeedRender = 0;
string path = OpenResourceFolder();
if (!string.IsNullOrEmpty(path))
{
DirectoryInfo folder = new DirectoryInfo(path);
if (!folder.Exists)
{
return;
}
gameDriver.ToRecordMode(folder.FullName);
}
}
if (UIImGui.requestSave.SetFalse())
{
FileOpenDialog fileDialog = new FileOpenDialog()
{
file = new string(new char[512]),
fileTitle = new string(new char[512]),
initialDir = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer),
filter = ".coocoo3DScene\0*.coocoo3DScene\0\0",
defExt = "coocoo3DScene",
flags = 0x00080000 | 0x00001000 | 0x00000800 | 0x00000200 | 0x00000008,
structSize = Marshal.SizeOf(typeof(FileOpenDialog))
};
fileDialog.maxFile = fileDialog.file.Length;
fileDialog.maxFileTitle = fileDialog.fileTitle.Length;
if (GetSaveFileName(fileDialog))
{
var scene = Coocoo3DScene.FromScene(this.scene);
SaveJsonStream(new FileInfo(fileDialog.file).Create(), scene);
}
}
}
//这个函数缓存之前的结果，顺序访问能提高性能。
public CameraKeyFrame GetCameraMotion(float time)
{
if (cameraKeyFrames == null)
{
return(new CameraKeyFrame()
{
FOV = 30, distance = 45
});
}
if (cameraKeyFrames.Count == 0)
{
return new CameraKeyFrame()
{
FOV = 30, distance = 45
}
}
;
float frame = Math.Max(time * c_framePerSecond, 0);
int _cacheIndex = cacheIndex;
CameraKeyFrame ComputeKeyFrame(CameraKeyFrame _Left, CameraKeyFrame _Right)
{
float _getAmount(Interpolator interpolator, float _a)
{
if (interpolator.ax == interpolator.ay && interpolator.bx == interpolator.by)
{
return(_a);
}
var _curve = Utility.CubicBezierCurve.Load(interpolator.ax, interpolator.ay, interpolator.bx, interpolator.by);
return(_curve.Sample(_a));
}
float t = (frame - _Left.Frame) / (_Right.Frame - _Left.Frame);
float amountX = _getAmount(_Right.mxInterpolator, t);
float amountY = _getAmount(_Right.myInterpolator, t);
float amountZ = _getAmount(_Right.mzInterpolator, t);
float amountR = _getAmount(_Right.rInterpolator, t);
float amountD = _getAmount(_Right.dInterpolator, t);
float amountF = _getAmount(_Right.fInterpolator, t);
CameraKeyFrame newKeyFrame = new CameraKeyFrame();
newKeyFrame.Frame = (int)MathF.Round(frame);
newKeyFrame.position = new Vector3(amountX, amountY, amountZ) * _Right.position + new Vector3(1 - amountX, 1 - amountY, 1 - amountZ) * _Left.position;
newKeyFrame.rotation = _Right.rotation * amountR + _Left.rotation * (1 - amountR);
newKeyFrame.distance = _Right.distance * amountD + _Left.distance * (1 - amountD);
newKeyFrame.FOV = _Right.FOV * amountF + _Left.FOV * (1 - amountF);
if (newKeyFrame.FOV < 0)
{
}
return(newKeyFrame);
}
if (_cacheIndex < cameraKeyFrames.Count - 1 && cameraKeyFrames[_cacheIndex].Frame <frame && cameraKeyFrames[_cacheIndex + 1].Frame> frame)
{
return(ComputeKeyFrame(cameraKeyFrames[_cacheIndex], cameraKeyFrames[_cacheIndex + 1]));
}
else if (_cacheIndex < cameraKeyFrames.Count - 2 && cameraKeyFrames[_cacheIndex + 1].Frame <frame && cameraKeyFrames[_cacheIndex + 2].Frame> frame)
{
cacheIndex++;
return(ComputeKeyFrame(cameraKeyFrames[_cacheIndex + 1], cameraKeyFrames[_cacheIndex + 2]));
}
int left = 0;
int right = cameraKeyFrames.Count - 1;
if (left == right)
{
return(cameraKeyFrames[left]);
}
if (cameraKeyFrames[right].Frame < frame)
{
return(cameraKeyFrames[right]);
}
while (right - left > 1)
{
int mid = (right + left) / 2;
if (cameraKeyFrames[mid].Frame > frame)
{
right = mid;
}
else
{
left = mid;
}
}
cacheIndex = left;
return(ComputeKeyFrame(cameraKeyFrames[left], cameraKeyFrames[right]));
}
}
public void Reload(BinaryReader reader)
{
headerChars = reader.ReadBytes(30);
var uName = reader.ReadBytes(20);
var jpEncoding = CodePagesEncodingProvider.Instance.GetEncoding("shift_jis");
Name = jpEncoding.GetString(uName);
var stream = reader.BaseStream;
int numOfBone = reader.ReadInt32();
for (int i = 0; i < numOfBone; i++)
{
uName = reader.ReadBytes(15);
int j = 0;
for (; j < uName.Length; j++)
{
if (uName[j] == 0)
{
break;
}
}
string nName = jpEncoding.GetString(uName, 0, j);
if (!BoneKeyFrameSet.TryGetValue(nName, out List <BoneKeyFrame> keyFrames))
{
keyFrames = new List <BoneKeyFrame>();
BoneKeyFrameSet.Add(nName, keyFrames);
}
BoneKeyFrame keyFrame = new BoneKeyFrame();
keyFrame.Frame = reader.ReadInt32();
keyFrame.translation = ReadVector3XInv(reader);
keyFrame.rotation = ReadQuaternionYZInv(reader);
keyFrame.xInterpolator = ReadBoneInterpolator(reader);
keyFrame.yInterpolator = ReadBoneInterpolator(reader);
keyFrame.zInterpolator = ReadBoneInterpolator(reader);
keyFrame.rInterpolator = ReadBoneInterpolator(reader);
keyFrames.Add(keyFrame);
}
if (stream.Length - stream.Position == 0)
{
goto endlabel;
}
int numOfMorph = reader.ReadInt32();
for (int i = 0; i < numOfMorph; i++)
{
uName = reader.ReadBytes(15);
int j = 0;
for (; j < uName.Length; j++)
{
if (uName[j] == 0)
{
break;
}
}
string nName = jpEncoding.GetString(uName, 0, j);
if (!MorphKeyFrameSet.TryGetValue(nName, out List <MorphKeyFrame> keyFrames))
{
keyFrames = new List <MorphKeyFrame>();
MorphKeyFrameSet.Add(nName, keyFrames);
}
MorphKeyFrame keyFrame = new MorphKeyFrame();
keyFrame.Frame = reader.ReadInt32();
keyFrame.Weight = reader.ReadSingle();
keyFrames.Add(keyFrame);
}
if (stream.Length - stream.Position == 0)
{
goto endlabel;
}
int numOfCam = reader.ReadInt32();
for (int i = 0; i < numOfCam; i++)
{
CameraKeyFrame keyFrame = new CameraKeyFrame();
keyFrame.Frame = reader.ReadInt32();
keyFrame.distance = reader.ReadSingle();
keyFrame.position = ReadVector3XInv(reader);
keyFrame.rotation = ReadVector3YZInv(reader);
keyFrame.mxInterpolator = ReadCameraInterpolator(reader);
keyFrame.myInterpolator = ReadCameraInterpolator(reader);
keyFrame.mzInterpolator = ReadCameraInterpolator(reader);
keyFrame.rInterpolator = ReadCameraInterpolator(reader);
keyFrame.dInterpolator = ReadCameraInterpolator(reader);
keyFrame.fInterpolator = ReadCameraInterpolator(reader);
keyFrame.FOV = reader.ReadInt32();
keyFrame.orthographic = reader.ReadByte() != 0;
CameraKeyFrames.Add(keyFrame);
}
if (stream.Length - stream.Position == 0)
{
goto endlabel;
}
int numOfLight = reader.ReadInt32();
for (int i = 0; i < numOfLight; i++)
{
LightKeyFrame lightKeyFrame = new LightKeyFrame();
lightKeyFrame.Frame = reader.ReadInt32();
lightKeyFrame.Color = ReadVector3(reader);
lightKeyFrame.Position = ReadVector3XInv(reader);
LightKeyFrames.Add(lightKeyFrame);
}
if (stream.Length - stream.Position == 0)
{
goto endlabel;
}
endlabel:
foreach (var keyframes in BoneKeyFrameSet.Values)
{
keyframes.Sort();
}
foreach (var keyframes in MorphKeyFrameSet.Values)
{
keyframes.Sort();
}
CameraKeyFrames.Sort();
LightKeyFrames.Sort();
}
public static bool Prefix(
ref Vector3 ___m_StartPos,
ref Vector3 ___m_StartPivot,
ref float ___m_StartOrthographicSize,
ref Vector3 ___m_EndPos,
ref Vector3 ___m_EndPivot,
ref float ___m_EndOrthographicSize,
ref Quaternion ___m_EndRot,
ref float ___m_ElapsedSeconds,
ref float ___m_TransitionSeconds,
ref bool ___m_Slerping
)
{
if (CinemaCamera.Activated())
{
if (ModdedCinemaCamera.keyFrames.Count == 0)
{
CameraInterpolate.Cancel();
return(false);
}
else if (ModdedCinemaCamera.keyFrames.Count < 2)
{
PopUpWarning.Display("You must add at least 2 keyframes to use the cinematic camera!");
CameraInterpolate.Cancel();
return(false);
}
___m_ElapsedSeconds += Time.unscaledDeltaTime;
float num = Mathf.Clamp01(___m_ElapsedSeconds / ___m_TransitionSeconds);
Vector3 vector = ModdedCinemaCamera.PivotHandler.Interpolate(ModdedCinemaCamera.current_start, num);
Vector3 normalized3 = ModdedCinemaCamera.InterpolateHandler.Interpolate(ModdedCinemaCamera.current_start, num).normalized;
// testing smooth movement
PointsOfView.m_Pivot = vector;
Cameras.MainCamera().transform.position = vector + normalized3 * GameSettings.CamDistFromPivot();
Cameras.MainCamera().transform.LookAt(vector);
Cameras.SetOrthographicSize(Mathf.SmoothStep(___m_StartOrthographicSize, ___m_EndOrthographicSize, num));
Bridge.RefreshZoomDependentVisibility();
if (Mathf.Approximately(num, 1f))
{
ModdedCinemaCamera.current_start += 1;
ModdedCinemaCamera.current_end += 1;
if (ModdedCinemaCamera.current_end >= ModdedCinemaCamera.keyFrames.Count)
{
CameraInterpolate.Cancel();
}
else
{
CameraKeyFrame target = ModdedCinemaCamera.keyFrames[ModdedCinemaCamera.current_end];
CameraInterpolate.SlerpTo(
target.m_StartPivot,
target.m_StartPos,
target.m_StartRot,
target.m_StartOrthographicSize,
target.m_DurationSeconds,
target.m_Ease
);
}
}
CameraControl.RegisterTransformUpdate();
return(false);
}
return(true);
}
public CameraKeyFrame GetCameraMotion(float time)
{
if (cameraKeyFrames == null || cameraKeyFrames.Count == 0)
{
return(new CameraKeyFrame()
{
FOV = 30, distance = -4.5f, position = new Vector3(0, 1, 0)
});
}
float frame = Math.Max(time * c_framePerSecond, 0);
CameraKeyFrame ComputeKeyFrame(CameraKeyFrame _Left, CameraKeyFrame _Right)
{
float t = (frame - _Left.Frame) / (_Right.Frame - _Left.Frame);
float amountX = GetAmount(_Right.mxInterpolator, t);
float amountY = GetAmount(_Right.myInterpolator, t);
float amountZ = GetAmount(_Right.mzInterpolator, t);
float amountR = GetAmount(_Right.rInterpolator, t);
float amountD = GetAmount(_Right.dInterpolator, t);
float amountF = GetAmount(_Right.fInterpolator, t);
CameraKeyFrame newKeyFrame = new CameraKeyFrame();
newKeyFrame.Frame = (int)MathF.Round(frame);
newKeyFrame.position = Lerp(_Left.position, _Right.position, new Vector3(amountX, amountY, amountZ));
newKeyFrame.rotation = Lerp(_Left.rotation, _Right.rotation, amountR);
newKeyFrame.distance = Lerp(_Left.distance, _Right.distance, amountD);
newKeyFrame.FOV = Lerp(_Left.FOV, _Right.FOV, amountF);
if (newKeyFrame.FOV < 0)
{
}
return(newKeyFrame);
}
int left = 0;
int right = cameraKeyFrames.Count - 1;
if (left == right)
{
return(cameraKeyFrames[left]);
}
if (cameraKeyFrames[right].Frame < frame)
{
return(cameraKeyFrames[right]);
}
while (right - left > 1)
{
int mid = (right + left) / 2;
if (cameraKeyFrames[mid].Frame > frame)
{
right = mid;
}
else
{
left = mid;
}
}
return(ComputeKeyFrame(cameraKeyFrames[left], cameraKeyFrames[right]));
}
private void Update()
{
if (Game.instance == null)
{
return;
}
if (NetGame.isLocal && Game.GetKeyDown(KeyCode.F6))
{
if (Time.timeScale == 0f)
{
Time.timeScale = 1f;
}
else
{
Time.timeScale = 0f;
}
}
if (Input.GetKeyDown(KeyCode.F7) && NetGame.instance.players.Count == 2)
{
MenuCameraEffects.instance.SetCOOPFullScreenViewport(coopCameraToggle);
coopCameraToggle = !coopCameraToggle;
}
if (Game.GetKeyDown(KeyCode.F8))
{
if (!GameSave.ProgressMoreOrEqual(Game.instance.currentLevelNumber + 1, 0))
{
SubtitleManager.instance.SetProgress(ScriptLocalization.TUTORIAL.CAMERADISABLED, 5f, -1f);
return;
}
ResetKeyFrames();
if (!allowFreeRoam)
{
Camera gameCam = NetGame.instance.local.players[0].cameraController.gameCam;
base.transform.position = gameCam.transform.position;
base.transform.rotation = gameCam.transform.rotation;
allowFreeRoam = true;
cam = MenuCameraEffects.instance.OverrideCamera(base.transform, applyEffects: true);
}
else
{
CleanUp();
}
}
if (NetGame.isLocal && Game.GetKeyDown(KeyCode.T) && Game.GetKey(KeyCode.LeftShift) && Game.GetKey(KeyCode.LeftControl))
{
if (Time.timeScale == 1f)
{
Time.timeScale = 0.5f;
}
else
{
Time.timeScale = 1f;
}
}
if (Game.GetKey(KeyCode.LeftBracket))
{
MenuCameraEffects.instance.zoom.to *= Mathf.Pow(1.4f, Time.unscaledDeltaTime);
}
if (Game.GetKey(KeyCode.RightBracket))
{
MenuCameraEffects.instance.zoom.to /= Mathf.Pow(1.4f, Time.unscaledDeltaTime);
}
if (Game.GetKey(KeyCode.Comma))
{
CaveRender.fogDensityMultiplier -= 10f * Time.unscaledDeltaTime;
}
if (Game.GetKey(KeyCode.Period))
{
CaveRender.fogDensityMultiplier += 10f * Time.unscaledDeltaTime;
}
CaveRender.fogDensityMultiplier = Mathf.Clamp(CaveRender.fogDensityMultiplier, 0f, 60f);
if (Game.GetKeyDown(KeyCode.F9))
{
Camera gameCam2 = cam;
if (gameCam2 == null)
{
gameCam2 = NetGame.instance.local.players[0].cameraController.gameCam;
}
if (!gameCam2.isActiveAndEnabled)
{
MultiplayerLobbyController multiplayerLobbyController = Object.FindObjectOfType <MultiplayerLobbyController>();
if (multiplayerLobbyController != null)
{
gameCam2 = multiplayerLobbyController.gameCamera.gameCam;
}
}
if (gameCam2 != null)
{
RenderTexture renderTexture2 = gameCam2.targetTexture = new RenderTexture(1024, 576, 16);
gameCam2.Render();
RenderTexture.active = renderTexture2;
Texture2D texture2D = new Texture2D(renderTexture2.width, renderTexture2.height, TextureFormat.RGB24, mipmap: false);
texture2D.ReadPixels(new Rect(0f, 0f, renderTexture2.width, renderTexture2.height), 0, 0);
RenderTexture.active = null;
gameCam2.targetTexture = null;
FileTools.WriteTexture(FileTools.Combine(Application.persistentDataPath, "thumbnail.png"), texture2D);
Object.Destroy(renderTexture2);
SubtitleManager.instance.SetProgress(ScriptLocalization.Get("WORKSHOP/ThumbnailCaptured"), 2f, 0.5f);
}
}
if (!allowFreeRoam)
{
return;
}
if (Game.GetKeyDown(KeyCode.Alpha0))
{
ResetKeyFrames();
}
for (int i = 0; i < keyframes.Length; i++)
{
if (Game.GetKeyDown((KeyCode)(49 + i)))
{
Human human = Human.all[0];
keyframes[i] = new CameraKeyFrame
{
pos = base.transform.position,
targetPos = human.transform.position,
rot = base.transform.rotation,
targetFocus = (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) || Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl) || Input.GetKey(KeyCode.Tab)),
humanRelative = (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.RightControl) || Input.GetKey(KeyCode.Tab)),
frame = ReplayRecorder.instance.currentFrame
};
if (keyframes[i].humanRelative)
{
keyframes[i].pos -= human.transform.position;
}
ReplayUI.instance.SyncCameras(keyframes);
}
}
if (ReplayRecorder.instance.state == ReplayRecorder.ReplayState.PlayForward || ReplayRecorder.instance.state == ReplayRecorder.ReplayState.PlayBackward)
{
for (int j = 0; j < keyframes.Length; j++)
{
CameraKeyFrame cameraKeyFrame = keyframes[j];
if (cameraKeyFrame.frame < 0f)
{
break;
}
if (cameraKeyFrame.frame >= (float)ReplayRecorder.instance.currentFrame)
{
CameraKeyFrame prevKeyframe = (j <= 0) ? cameraKeyFrame : keyframes[j - 1];
float t = Mathf.InverseLerp(prevKeyframe.frame, cameraKeyFrame.frame, ReplayRecorder.instance.currentFrame);
SyncCamera(cameraKeyFrame, prevKeyframe, t);
return;
}
}
}
else if (ReplayRecorder.instance.state == ReplayRecorder.ReplayState.None && keyframes[0].pos != Vector3.zero && keyframes[1].pos != Vector3.zero)
{
if (Game.GetKeyDown(KeyCode.Space))
{
if (animationPhase < 1f)
{
animationPhase = 1f;
}
else
{
animationPhase = 0f;
}
}
if (animationPhase < 1f)
{
animationPhase += Time.unscaledDeltaTime / duration;
SyncCamera(keyframes[1], keyframes[0], animationPhase);
return;
}
}
bool flag = Game.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
int num = flag ? 1 : 10;
if (Game.GetKey(KeyCode.W))
{
base.transform.position += base.transform.forward * Time.unscaledDeltaTime * num;
}
if (Game.GetKey(KeyCode.S))
{
base.transform.position -= base.transform.forward * Time.unscaledDeltaTime * num;
}
if (Game.GetKey(KeyCode.A))
{
base.transform.position -= base.transform.right * Time.unscaledDeltaTime * num;
}
if (Game.GetKey(KeyCode.D))
{
base.transform.position += base.transform.right * Time.unscaledDeltaTime * num;
}
if (Game.GetKey(KeyCode.Q))
{
base.transform.position += base.transform.up * Time.unscaledDeltaTime * num;
}
if (Game.GetKey(KeyCode.Z))
{
base.transform.position -= base.transform.up * Time.unscaledDeltaTime * num;
}
Vector2 mouseScrollDelta = Input.mouseScrollDelta;
float y = mouseScrollDelta.y;
cam.fieldOfView *= Mathf.Pow(1.1f, 0f - y);
cam.fieldOfView = Mathf.Clamp(cam.fieldOfView, 5f, 120f);
cam.nearClipPlane = 0.05f * Mathf.Pow(1.1f, 0f - Mathf.Log(cam.fieldOfView / 60f, 1.1f));
if (Input.GetMouseButton(2))
{
cam.fieldOfView = 60f;
cam.nearClipPlane = 0.05f;
}
float num2 = (!flag) ? 0.2f : 0.1f;
float axis = Input.GetAxis("mouse x");
float axis2 = Input.GetAxis("mouse y");
if (axis != 0f || axis2 != 0f)
{
Vector3 eulerAngles = base.transform.rotation.eulerAngles;
if (eulerAngles.x > 180f)
{
eulerAngles.x -= 360f;
}
if (eulerAngles.x < -180f)
{
eulerAngles.x += 360f;
}
eulerAngles.x -= axis2 * num2;
if (eulerAngles.x < -89f)
{
eulerAngles.x = -89f;
}
if (eulerAngles.x > 89f)
{
eulerAngles.x = 89f;
}
eulerAngles.y += axis * num2;
base.transform.rotation = Quaternion.Euler(eulerAngles);
}
}
