// Use this for initialization
void Start()
{
//The scene unlocker function that runs every time a new scene is loaded
SceneManager.sceneLoaded += SceneUnlocker;
levelSelectPanels = new RectTransform[numOfPanels];
targetPositions = new Vector3[numOfPanels];
starImages = new Image[maxStarCount];
//If the player prefs has no key that is called LevelCounter, create it
if (!PlayerPrefs.HasKey("LevelCounter"))
{
PlayerPrefs.SetInt("LevelCounter", 1);
PlayerPrefs.Save();
clearedLevels = (PlayerPrefs.GetInt("LevelCounter"));
//first level is unlocked, every other level is locked
}
//If it has the key, then instantiate the buttons
else
{
clearedLevels = PlayerPrefs.GetInt("LevelCounter");
}
cameraScript = FindObjectOfType <CameraAnim>();
LevelPanelCreate();
CreatingButtons();
CreateStars();
}
public void Reload(CameraAnim anim)
{
Name = anim.Name;
FrameCount = anim.FrameCount;
FrameRate = 60.0f;
Loop = anim.Flags.HasFlag(CameraAnimFlags.Looping);
CameraAnimGroup group = new CameraAnimGroup();
group.Name = anim.Name;
group.IsOrtho = !anim.Flags.HasFlag(CameraAnimFlags.Perspective);
group.IsLookat = !anim.Flags.HasFlag(CameraAnimFlags.EulerZXY);
group.PositionX.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.X));
group.PositionY.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.Y));
group.PositionZ.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Position.Z));
group.RotationX.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.X));
group.RotationY.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.Y));
group.RotationZ.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Rotation.Z));
group.Twist.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.Twist));
group.ClipNear.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.ClipNear));
group.ClipFar.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.ClipFar));
group.AspectRatio.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.AspectRatio));
group.FieldOfView.KeyFrames.Add(new STKeyFrame(0, anim.BaseData.FieldOfView));
AnimGroups.Clear();
AnimGroups.Add(group);
for (int i = 0; i < anim.Curves.Count; i++)
{
var curve = anim.Curves[i];
switch ((CameraAnimDataOffset)curve.AnimDataOffset)
{
case CameraAnimDataOffset.PositionX: BfresAnimations.GenerateKeys(group.PositionX, curve); break;
case CameraAnimDataOffset.PositionY: BfresAnimations.GenerateKeys(group.PositionY, curve); break;
case CameraAnimDataOffset.PositionZ: BfresAnimations.GenerateKeys(group.PositionZ, curve); break;
case CameraAnimDataOffset.RotationX: BfresAnimations.GenerateKeys(group.RotationX, curve); break;
case CameraAnimDataOffset.RotationY: BfresAnimations.GenerateKeys(group.RotationY, curve); break;
case CameraAnimDataOffset.RotationZ: BfresAnimations.GenerateKeys(group.RotationZ, curve); break;
case CameraAnimDataOffset.Twist: BfresAnimations.GenerateKeys(group.Twist, curve); break;
case CameraAnimDataOffset.ClipNear: BfresAnimations.GenerateKeys(group.ClipNear, curve); break;
case CameraAnimDataOffset.ClipFar: BfresAnimations.GenerateKeys(group.ClipFar, curve); break;
case CameraAnimDataOffset.AspectRatio: BfresAnimations.GenerateKeys(group.AspectRatio, curve); break;
case CameraAnimDataOffset.FieldOFView: BfresAnimations.GenerateKeys(group.FieldOfView, curve); break;
}
}
}
protected override void Awake()
{
base.Awake();
MoveCamTs = GameObject.Find("MoveCamera").transform;
MainCamTs = MoveCamTs.GetComponentInChildren <Camera>().transform;
mCameraAnim = MoveCamTs.GetComponent <CameraAnim>();
LoadStage();
}
internal static unsafe void Invoke(IntPtr obj, CameraAnim Anim, bool bImmediate)
{
long *p = stackalloc long[] { 0L, 0L, 0L };
byte *b = (byte *)p;
*((IntPtr *)(b + 0)) = Anim;
*((bool *)(b + 8)) = bImmediate;
Main.GetProcessEvent(obj, StopAllInstancesOfCameraAnim_ptr, new IntPtr(p));;
}
}
public CameraAnimConfig(CameraAnim camAnim)
{
FrameCount = camAnim.FrameCount;
BakedSize = camAnim.BakedSize;
Name = camAnim.Name;
Loop = camAnim.Flags.HasFlag(CameraAnimFlags.Looping);
EulerZXY = camAnim.Flags.HasFlag(CameraAnimFlags.EulerZXY);
Perspective = camAnim.Flags.HasFlag(CameraAnimFlags.Perspective);
BaseData = camAnim.BaseData;
foreach (var curve in camAnim.Curves)
{
Curves.Add(new CameraAnimCurve(curve));
}
}
internal static unsafe void Invoke(IntPtr obj, CameraAnim AnimToPlay, float Scale, float Rate, float BlendInTime, float BlendOutTime, bool bLoop, bool bRandomStartTime, byte Space, Rotator CustomPlaySpace)
{
long *p = stackalloc long[] { 0L, 0L, 0L, 0L, 0L, 0L };
byte *b = (byte *)p;
*((IntPtr *)(b + 0)) = AnimToPlay;
*((float *)(b + 8)) = Scale;
*((float *)(b + 12)) = Rate;
*((float *)(b + 16)) = BlendInTime;
*((float *)(b + 20)) = BlendOutTime;
*((bool *)(b + 24)) = bLoop;
*((bool *)(b + 25)) = bRandomStartTime;
*(b + 26) = Space;
*((Rotator *)(b + 28)) = CustomPlaySpace;
Main.GetProcessEvent(obj, ClientPlayCameraAnim_ptr, new IntPtr(p));;
}
}
internal static unsafe CameraAnimInst Invoke(IntPtr obj, CameraAnim Anim, float Rate, float Scale, float BlendInTime, float BlendOutTime, bool bLoop, bool bRandomStartTime, float Duration, byte PlaySpace, Rotator UserPlaySpaceRot)
{
long *p = stackalloc long[] { 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L };
byte *b = (byte *)p;
*((IntPtr *)(b + 0)) = Anim;
*((float *)(b + 8)) = Rate;
*((float *)(b + 12)) = Scale;
*((float *)(b + 16)) = BlendInTime;
*((float *)(b + 20)) = BlendOutTime;
*((bool *)(b + 24)) = bLoop;
*((bool *)(b + 25)) = bRandomStartTime;
*((float *)(b + 28)) = Duration;
*(b + 32) = PlaySpace;
*((Rotator *)(b + 36)) = UserPlaySpaceRot;
Main.GetProcessEvent(obj, PlayCameraAnim_ptr, new IntPtr(p));;
return(*((IntPtr *)(b + 48)));
}
}
public static void Read(ResFileSwitchLoader loader, CameraAnim cameraAnim)
{
if (loader.ResFile.VersionMajor2 == 9)
{
cameraAnim.Flags = loader.ReadEnum <CameraAnimFlags>(true);
loader.Seek(2);
}
else
{
loader.LoadHeaderBlock();
}
cameraAnim.Name = loader.LoadString();
long CurveArrayOffset = loader.ReadInt64();
cameraAnim.BaseData = loader.LoadCustom(() => new CameraAnimData(loader));
cameraAnim.UserData = loader.LoadDictValues <UserData>();
byte numCurve = 0;
if (loader.ResFile.VersionMajor2 == 9)
{
cameraAnim.FrameCount = loader.ReadInt32();
cameraAnim.BakedSize = loader.ReadUInt32();
ushort numUserData = loader.ReadUInt16();
numCurve = loader.ReadByte();
loader.Seek(1);
loader.Seek(4);
}
else
{
cameraAnim.Flags = loader.ReadEnum <CameraAnimFlags>(true);
loader.Seek(2);
cameraAnim.FrameCount = loader.ReadInt32();
numCurve = loader.ReadByte();
loader.Seek(1);
ushort numUserData = loader.ReadUInt16();
cameraAnim.BakedSize = loader.ReadUInt32();
}
cameraAnim.Curves = loader.LoadList <AnimCurve>(numCurve, (uint)CurveArrayOffset);
}
public static void Write(ResFileSwitchSaver saver, CameraAnim cameraAnim)
{
if (saver.ResFile.VersionMajor2 == 9)
{
saver.Write(cameraAnim.Flags, true);
saver.Seek(2);
}
else
{
saver.Seek(12);
}
saver.SaveRelocateEntryToSection(saver.Position, 5, 1, 0, ResFileSwitchSaver.Section1, "Camera Animation");
saver.SaveString(cameraAnim.Name);
cameraAnim.PosCurveArrayOffset = saver.SaveOffset();
cameraAnim.PosBaseDataOffset = saver.SaveOffset();
cameraAnim.PosUserDataOffset = saver.SaveOffset();
cameraAnim.PosUserDataDictOffset = saver.SaveOffset();
if (saver.ResFile.VersionMajor2 == 9)
{
saver.Write(cameraAnim.FrameCount);
saver.Write(cameraAnim.BakedSize);
saver.Write((ushort)cameraAnim.UserData.Count);
saver.Write((byte)cameraAnim.Curves.Count);
saver.Seek(1);
saver.Seek(4);
}
else
{
saver.Write(cameraAnim.Flags, true);
saver.Seek(2);
saver.Write(cameraAnim.FrameCount);
saver.Write((byte)cameraAnim.Curves.Count);
saver.Seek(1);
saver.Write((ushort)cameraAnim.UserData.Count);
saver.Write(cameraAnim.BakedSize);
}
}
public void LoadAnim(CameraAnim anim)
{
Initialize();
CameraAnim = anim;
Text = anim.Name;
FrameCount = anim.FrameCount;
AspectRatio = anim.BaseData.AspectRatio;
ClipFar = anim.BaseData.ClipFar;
ClipNear = anim.BaseData.ClipNear;
FieldOfView = anim.BaseData.FieldOfView;
Position = Utils.ToVec3(anim.BaseData.Position);
Rotation = Utils.ToVec3(anim.BaseData.Rotation);
Twist = anim.BaseData.Twist;
if (anim.Flags.HasFlag(CameraAnimFlags.EulerZXY))
{
settings |= Settings.EulerZXY;
}
if (anim.Flags.HasFlag(CameraAnimFlags.Perspective))
{
settings |= Settings.Perspective;
}
for (int curve = 0; curve < anim.Curves.Count; curve++)
{
Animation.KeyGroup keyGroup = CurveHelper.CreateTrack(anim.Curves[curve]);
keyGroup.AnimDataOffset = anim.Curves[curve].AnimDataOffset;
Values.Add(new Animation.KeyGroup()
{
AnimDataOffset = keyGroup.AnimDataOffset,
Keys = keyGroup.Keys,
});
}
}
public BfresCameraAnim(CameraAnim anim)
{
CanPlay = false; //Default all animations to not play unless toggled in list
Reload(anim);
}
public static void FromJson(SceneAnim anim, string json)
{
JsonConvert.DefaultSettings = () =>
{
var settings = new JsonSerializerSettings();
return(settings);
};
var animJson = JsonConvert.DeserializeObject <SceneAnimStuct>(json);
anim.Name = animJson.Name;
anim.CameraAnims = new ResDict <CameraAnim>();
anim.LightAnims = new ResDict <LightAnim>();
anim.FogAnims = new ResDict <FogAnim>();
anim.UserData = UserDataConvert.Convert(animJson.UserData);
foreach (var camAnimJson in animJson.CameraAnims)
{
CameraAnim camAnim = new CameraAnim();
camAnim.Flags = 0;
anim.CameraAnims.Add(camAnimJson.Name, camAnim);
if (camAnimJson.Loop)
{
camAnim.Flags |= CameraAnimFlags.Looping;
}
if (camAnimJson.Baked)
{
camAnim.Flags |= CameraAnimFlags.BakedCurve;
}
if (camAnimJson.Perspective)
{
camAnim.Flags |= CameraAnimFlags.Perspective;
}
if (camAnimJson.EulerRotation)
{
camAnim.Flags |= CameraAnimFlags.EulerZXY;
}
camAnim.Name = camAnimJson.Name;
camAnim.FrameCount = camAnimJson.FrameCount;
camAnim.BaseData = camAnimJson.BaseData;
foreach (var curveJson in camAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
camAnim.Curves.Add(curve);
}
}
foreach (var lightAnimJson in animJson.LightAnims)
{
LightAnim lightAnim = new LightAnim();
lightAnim.Flags = 0;
anim.LightAnims.Add(lightAnimJson.Name, lightAnim);
if (lightAnimJson.Loop)
{
lightAnim.Flags |= LightAnimFlags.Looping;
}
if (lightAnimJson.Baked)
{
lightAnim.Flags |= LightAnimFlags.BakedCurve;
}
if (lightAnimJson.BaseAngleAttn)
{
lightAnim.Flags |= LightAnimFlags.BaseAngleAttn;
}
if (lightAnimJson.BaseColor0)
{
lightAnim.Flags |= LightAnimFlags.BaseColor0;
}
if (lightAnimJson.BaseColor1)
{
lightAnim.Flags |= LightAnimFlags.BaseColor1;
}
if (lightAnimJson.BaseDir)
{
lightAnim.Flags |= LightAnimFlags.BaseDir;
}
if (lightAnimJson.BaseDistAttn)
{
lightAnim.Flags |= LightAnimFlags.BaseDistAttn;
}
if (lightAnimJson.BasePos)
{
lightAnim.Flags |= LightAnimFlags.BasePos;
}
lightAnim.Name = lightAnimJson.Name;
lightAnim.FrameCount = lightAnimJson.FrameCount;
lightAnim.BaseData = lightAnimJson.BaseData;
if (lightAnim.BaseData.Enable == 1)
{
lightAnim.Flags |= LightAnimFlags.BaseEnable;
}
foreach (var curveJson in lightAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
lightAnim.Curves.Add(curve);
}
}
foreach (var fogAnimJson in animJson.FogAnims)
{
FogAnim fogAnim = new FogAnim();
fogAnim.Flags = 0;
anim.CameraAnims.Add(fogAnimJson.Name, fogAnim);
if (fogAnimJson.Loop)
{
fogAnim.Flags |= FogAnimFlags.Looping;
}
if (fogAnimJson.Baked)
{
fogAnim.Flags |= FogAnimFlags.BakedCurve;
}
fogAnim.Name = fogAnimJson.Name;
fogAnim.FrameCount = fogAnimJson.FrameCount;
fogAnim.DistanceAttnFuncIndex = fogAnimJson.DistanceAttnFuncIndex;
fogAnim.DistanceAttnFuncName = fogAnimJson.DistanceAttnFuncName;
fogAnim.BaseData = fogAnimJson.BaseData;
foreach (var curveJson in fogAnimJson.Curves)
{
var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);
var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
fogAnim.Curves.Add(curve);
}
}
}
public SceneAnim FromYaml()
{
SceneAnim anim = new SceneAnim();
anim.Name = Name;
anim.Path = Path;
foreach (var camera in CameraAnimations)
{
CameraAnim camAnim = new CameraAnim();
camAnim.Name = camera.Name;
camAnim.FrameCount = camera.FrameCount;
camAnim.BakedSize = camera.BakedSize;
camAnim.BaseData = camera.BaseData;
if (camera.EulerZXY)
{
camAnim.Flags |= CameraAnimFlags.EulerZXY;
}
if (camera.Loop)
{
camAnim.Flags |= CameraAnimFlags.Looping;
}
if (camera.Perspective)
{
camAnim.Flags |= CameraAnimFlags.Perspective;
}
foreach (var curve in camera.Curves)
{
AnimCurve animCurve = new AnimCurve();
animCurve.AnimDataOffset = ConvertOffset(curve.Type);
animCurve.Scale = 1;
animCurve.CurveType = AnimCurveType.Linear;
int FrameCount = curve.KeyFrames.Count;
animCurve.Frames = new float[FrameCount];
animCurve.Keys = new float[FrameCount, 2];
var values = curve.KeyFrames.Values.ToList();
for (int i = 0; i < curve.KeyFrames.Count; i++)
{
var KeyFrame = curve.KeyFrames.ElementAt(i);
animCurve.Frames[i] = KeyFrame.Key;
animCurve.Keys[i, 0] = KeyFrame.Value;
//Calculate delta
float Delta = 0;
if (i < values.Count - 1)
{
Delta = values[i + 1] - values[i];
}
animCurve.Keys[i, 1] = Delta;
}
animCurve.StartFrame = animCurve.Frames.Max();
animCurve.EndFrame = animCurve.Frames.Max();
if (animCurve.Keys.Length > 1)
{
animCurve.Delta = values[values.Count - 1] - values[0];
}
animCurve.KeyType = AnimCurveKeyType.Single;
animCurve.FrameType = AnimCurveFrameType.Single;
camAnim.Curves.Add(animCurve);
}
anim.CameraAnims.Add(camAnim);
anim.CameraAnimDict.Add(camAnim.Name);
}
return(anim);
}
