Soullies/ichni_Creator_Studio
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

效果模块，以及代码位置整理

Browse Source
This commit is contained in:
SoulliesOfficial
2025-02-16 11:15:42 -05:00
parent 934d1b5aba
commit d77e1a0f70
204 changed files with 1107 additions and 347 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
Assets/Scripts/EditorGame/Animations/AnimationBase.cs Normal file
View File

@@ -0,0 +1,52 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.Serialization;
namespace Ichni.RhythmGame
{
public abstract class AnimationBase : GameElement, IHaveTimeDurationSubmodule
{
public GameElement animatedObject;
public FlexibleReturnType animationReturnType;
public TimeDurationSubmodule timeDurationSubmodule { get; set; }
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected abstract void UpdateAnimation(float songTime);
protected virtual void Update()
{
if (timeDurationSubmodule.CheckTimeInDuration(EditorManager.instance.songInformation.songTime))
{
UpdateAnimation(EditorManager.instance.songInformation.songTime);
}
}
}
namespace Beatmap
{
public abstract class AnimationBase_BM : GameElement_BM
{
public AnimationBase_BM()
{
}
public AnimationBase_BM(string elementName, Guid elementGuid, List<string> tags,
GameElement_BM attachedElement) : base(elementName, elementGuid, tags, attachedElement)
{
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/AnimationBase.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 8136d0b00cb8049c98eb2b1d40ad0820
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Scripts/EditorGame/Animations/Color.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: e3418d0d84b6b476db0e552f2e754c7e
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

115
Assets/Scripts/EditorGame/Animations/Color/BaseColorChange.cs Normal file
View File

@@ -0,0 +1,115 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class BaseColorChange : AnimationBase
{
private ColorSubmodule targetColorSubmodule;
public FlexibleFloat colorR, colorG, colorB, colorA;
public static BaseColorChange GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
FlexibleFloat colorR, FlexibleFloat colorG, FlexibleFloat colorB, FlexibleFloat colorA)
{
BaseColorChange baseColorChange = Instantiate(EditorManager.instance.basePrefabs.emptyObject)
.AddComponent<BaseColorChange>();
baseColorChange.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
baseColorChange.animatedObject = animatedObject;
baseColorChange.colorR = colorR;
baseColorChange.colorG = colorG;
baseColorChange.colorB = colorB;
baseColorChange.colorA = colorA;
baseColorChange.animationReturnType = FlexibleReturnType.Before;
baseColorChange.targetColorSubmodule = (animatedObject as IHaveColorSubmodule).colorSubmodule;
//baseColorChange.timeDurationSubmodule.SetDuration(colorR, colorG, colorB, colorA);
return baseColorChange;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
colorR.UpdateFlexibleFloat(songTime);
colorG.UpdateFlexibleFloat(songTime);
colorB.UpdateFlexibleFloat(songTime);
colorA.UpdateFlexibleFloat(songTime);
if (colorR.returnType is FlexibleReturnType.MiddleExecuting ||
colorG.returnType is FlexibleReturnType.MiddleExecuting ||
colorB.returnType is FlexibleReturnType.MiddleExecuting ||
colorA.returnType is FlexibleReturnType.MiddleExecuting)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Color colorOffset = new Color(colorR.value, colorG.value, colorB.value, colorA.value);
targetColorSubmodule.baseColorOffset.Add(colorOffset);
targetColorSubmodule.baseColorDirtyMark = true;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
}
}
}
public partial class BaseColorChange
{
public override void SaveBM()
{
matchedBM = new BaseColorChange_BM(elementName, elementGuid, tags,
animatedObject.matchedBM as GameElement_BM, colorR.ConvertToBM(),
colorG.ConvertToBM(), colorB.ConvertToBM(), colorA.ConvertToBM());
}
}
namespace Beatmap
{
public class BaseColorChange_BM : AnimationBase_BM
{
public FlexibleFloat_BM colorR, colorG, colorB, colorA;
public BaseColorChange_BM()
{
}
public BaseColorChange_BM(string elementName, Guid elementGuid, List<string> tags,
GameElement_BM attachedElement, FlexibleFloat_BM colorR, FlexibleFloat_BM colorG,
FlexibleFloat_BM colorB, FlexibleFloat_BM colorA) :
base(elementName, elementGuid, tags, attachedElement)
{
this.colorR = colorR;
this.colorG = colorG;
this.colorB = colorB;
this.colorA = colorA;
}
public override void ExecuteBM()
{
matchedElement = BaseColorChange.GenerateElement(elementName, elementGuid, tags, false,
GetElement(attachedElementGuid), colorR.ConvertToGameType(),
colorG.ConvertToGameType(), colorB.ConvertToGameType(), colorA.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return BaseColorChange.GenerateElement(elementName, elementGuid, tags, false,
parent, colorR.ConvertToGameType(), colorG.ConvertToGameType(),
colorB.ConvertToGameType(), colorA.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Color/BaseColorChange.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 3dada7ead8505418198027da3d9984bb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

114
Assets/Scripts/EditorGame/Animations/Color/EmissionColorChange.cs Normal file
View File

@@ -0,0 +1,114 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class EmissionColorChange : AnimationBase
{
private ColorSubmodule targetColorSubmodule;
public FlexibleFloat colorR, colorG, colorB, colorI;
public static EmissionColorChange GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
FlexibleFloat colorR, FlexibleFloat colorG, FlexibleFloat colorB, FlexibleFloat colorI)
{
EmissionColorChange emissionColorChange = Instantiate(EditorManager.instance.basePrefabs.emptyObject).AddComponent<EmissionColorChange>();
emissionColorChange.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
emissionColorChange.animatedObject = animatedObject;
emissionColorChange.colorR = colorR;
emissionColorChange.colorG = colorG;
emissionColorChange.colorB = colorB;
emissionColorChange.colorI = colorI;
emissionColorChange.animationReturnType = FlexibleReturnType.Before;
emissionColorChange.targetColorSubmodule = (animatedObject as IHaveColorSubmodule).colorSubmodule;
//emissionColorChange.timeDurationSubmodule.SetDuration(colorR, colorG, colorB, colorI);
return emissionColorChange;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
colorR.UpdateFlexibleFloat(songTime);
colorG.UpdateFlexibleFloat(songTime);
colorB.UpdateFlexibleFloat(songTime);
colorI.UpdateFlexibleFloat(songTime);
if (colorR.returnType is FlexibleReturnType.MiddleExecuting ||
colorG.returnType is FlexibleReturnType.MiddleExecuting ||
colorB.returnType is FlexibleReturnType.MiddleExecuting ||
colorI.returnType is FlexibleReturnType.MiddleExecuting)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Color colorOffset = new Color(colorR.value, colorG.value, colorB.value);
float intensityOffset = colorI.value;
targetColorSubmodule.emissionColorOffset.Add(colorOffset);
targetColorSubmodule.emissionIntensityOffset.Add(intensityOffset);
targetColorSubmodule.emissionColorDirtyMark = true;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
}
}
}
public partial class EmissionColorChange
{
public override void SaveBM()
{
matchedBM = new EmissionColorChange_BM(elementName, elementGuid, tags, animatedObject.matchedBM as GameElement_BM,
colorR.ConvertToBM(), colorG.ConvertToBM(), colorB.ConvertToBM(), colorI.ConvertToBM());
}
}
namespace Beatmap
{
public class EmissionColorChange_BM : AnimationBase_BM
{
public FlexibleFloat_BM colorR, colorG, colorB, colorI;
public EmissionColorChange_BM()
{
}
public EmissionColorChange_BM(string elementName, Guid elementGuid, List<string> tags, GameElement_BM parentElement,
FlexibleFloat_BM colorR, FlexibleFloat_BM colorG, FlexibleFloat_BM colorB, FlexibleFloat_BM colorI) :
base(elementName, elementGuid, tags, parentElement)
{
this.colorR = colorR;
this.colorG = colorG;
this.colorB = colorB;
this.colorI = colorI;
}
public override void ExecuteBM()
{
matchedElement = EmissionColorChange.GenerateElement(elementName, elementGuid, tags, false, GetElement(attachedElementGuid),
colorR.ConvertToGameType(), colorG.ConvertToGameType(), colorB.ConvertToGameType(), colorI.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return EmissionColorChange.GenerateElement(elementName, elementGuid, tags, false, parent,
colorR.ConvertToGameType(), colorG.ConvertToGameType(), colorB.ConvertToGameType(), colorI.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Color/EmissionColorChange.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ed8c4bbcff6cc433dae44740d8f01b84
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Scripts/EditorGame/Animations/Track.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 17936224adc4a4e3497f05188aeb115f
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

89
Assets/Scripts/EditorGame/Animations/Track/TrackTotalTimeChange.cs Normal file
View File

@@ -0,0 +1,89 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class TrackTotalTimeChange : AnimationBase
{
public FlexibleFloat totalTime;
public TrackTimeSubmoduleStatic targetTrackTimeSubmoduleStatic;
public static TrackTotalTimeChange GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, Track animatedTrack, FlexibleFloat totalTime)
{
TrackTotalTimeChange trackTotalTimeChange = Instantiate(EditorManager.instance.basePrefabs.emptyObject)
.AddComponent<TrackTotalTimeChange>();
trackTotalTimeChange.Initialize(elementName, id, tags, isFirstGenerated, animatedTrack);
trackTotalTimeChange.animatedObject = animatedTrack;
trackTotalTimeChange.targetTrackTimeSubmoduleStatic = animatedTrack.trackTimeSubmodule as TrackTimeSubmoduleStatic;
trackTotalTimeChange.totalTime = totalTime;
trackTotalTimeChange.animationReturnType = FlexibleReturnType.Before;
//trackTotalTimeChange.timeDurationSubmodule.SetDuration(totalTime);
return trackTotalTimeChange;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
totalTime.UpdateFlexibleFloat(songTime);
if (totalTime.returnType == FlexibleReturnType.MiddleExecuting)
{
targetTrackTimeSubmoduleStatic.trackTotalTime = totalTime.value;
}
}
}
public partial class TrackTotalTimeChange
{
public override void SaveBM()
{
matchedBM = new TrackTotalTimeChange_BM(elementName, elementGuid, tags, animatedObject.matchedBM as Track_BM, totalTime.ConvertToBM());
}
}
namespace Beatmap
{
public class TrackTotalTimeChange_BM : GameElement_BM
{
public FlexibleFloat_BM totalTime;
public TrackTotalTimeChange_BM()
{
}
public TrackTotalTimeChange_BM(string elementName, Guid elementGuid, List<string> tags,
GameElement_BM attachedElement, FlexibleFloat_BM totalTime) :
base(elementName, elementGuid, tags, attachedElement)
{
this.totalTime = totalTime;
}
public override void ExecuteBM()
{
matchedElement = TrackTotalTimeChange.GenerateElement(elementName, elementGuid, tags, false,
GetElement(attachedElementGuid) as Track, totalTime.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return TrackTotalTimeChange.GenerateElement(elementName, elementGuid, tags, false,
parent as Track, totalTime.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Track/TrackTotalTimeChange.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 2eec4a2a4ac744e0ca183d59c465c4e2
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Scripts/EditorGame/Animations/Transform.meta Normal file
View File

@@ -0,0 +1,8 @@
fileFormatVersion: 2
guid: 469791310ebae4cbbb29b4d818077938
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

126
Assets/Scripts/EditorGame/Animations/Transform/Displacement.cs Normal file
View File

@@ -0,0 +1,126 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Dreamteck.Splines;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using Unity.Mathematics;
using Unity.VisualScripting;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class Displacement : AnimationBase
{
private TransformSubmodule targetTransformSubmodule;
public FlexibleFloat positionX, positionY, positionZ;
public static Displacement GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
FlexibleFloat positionX, FlexibleFloat positionY, FlexibleFloat positionZ)
{
Displacement displacement = Instantiate(EditorManager.instance.basePrefabs.emptyObject).AddComponent<Displacement>();
displacement.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
displacement.animatedObject = animatedObject;
displacement.positionX = positionX;
displacement.positionY = positionY;
displacement.positionZ = positionZ;
displacement.animationReturnType = FlexibleReturnType.Before;
displacement.targetTransformSubmodule = (animatedObject as IHaveTransformSubmodule).transformSubmodule;
//displacement.timeDurationSubmodule.SetDuration(positionX, positionY, positionZ);
return displacement;
}
protected override void UpdateAnimation(float songTime)
{
positionX.UpdateFlexibleFloat(songTime);
positionY.UpdateFlexibleFloat(songTime);
positionZ.UpdateFlexibleFloat(songTime);
if (positionX.returnType is FlexibleReturnType.MiddleExecuting or FlexibleReturnType.After or FlexibleReturnType.Before ||
positionY.returnType is FlexibleReturnType.MiddleExecuting or FlexibleReturnType.After or FlexibleReturnType.Before ||
positionZ.returnType is FlexibleReturnType.MiddleExecuting or FlexibleReturnType.After or FlexibleReturnType.Before)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Vector3 currentPosition = new Vector3(positionX.value, positionY.value, positionZ.value);
targetTransformSubmodule.positionOffset.Add(currentPosition);
targetTransformSubmodule.positionDirtyMark = true;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
}
}
}
public partial class Displacement
{
public override void SaveBM()
{
matchedBM = new Beatmap.Displacement_BM(elementName, elementGuid, tags, parentElement.matchedBM as GameElement_BM,
positionX.ConvertToBM(), positionY.ConvertToBM(), positionZ.ConvertToBM());
}
public override void SetUpInspector()
{
base.SetUpInspector();
var container = inspector.GenerateContainer("Displacement");
var positionXButton = inspector.GenerateButton(this, container, "Position X",
() =>
{
inspector.GenerateCompositeParameterWindow(this, "Position X", nameof(positionX)).SetAsFlexibleFloat();
});
var positionYButton = inspector.GenerateButton(this, container, "Position Y",
() =>
{
inspector.GenerateCompositeParameterWindow(this, "Position Y", nameof(positionY)).SetAsFlexibleFloat();
});
var positionZButton = inspector.GenerateButton(this, container, "Position Z",
() =>
{
inspector.GenerateCompositeParameterWindow(this, "Position Z", nameof(positionZ)).SetAsFlexibleFloat();
});
}
}
namespace Beatmap
{
public class Displacement_BM : AnimationBase_BM
{
public FlexibleFloat_BM positionX, positionY, positionZ;
public Displacement_BM()
{
}
public Displacement_BM(string elementName, Guid elementGuid, List<string> tags,
GameElement_BM attachedElement, FlexibleFloat_BM positionX, FlexibleFloat_BM positionY, FlexibleFloat_BM positionZ)
: base(elementName, elementGuid, tags, attachedElement)
{
this.positionX = positionX;
this.positionY = positionY;
this.positionZ = positionZ;
}
public override void ExecuteBM()
{
matchedElement = Displacement.GenerateElement(elementName, elementGuid, tags, false, GetElement(attachedElementGuid),
positionX.ConvertToGameType(), positionY.ConvertToGameType(), positionZ.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return Displacement.GenerateElement(elementName, elementGuid, tags, false, parent,
positionX.ConvertToGameType(), positionY.ConvertToGameType(), positionZ.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Transform/Displacement.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 30dde730c51f742719fcc5c36eb811e5
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

108
Assets/Scripts/EditorGame/Animations/Transform/LookAt.cs Normal file
View File

@@ -0,0 +1,108 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;
using UnityEngine.Serialization;
namespace Ichni.RhythmGame
{
/// <summary>
/// 将物体的z轴指向目标物体，注意，LookAt的启用期间，物体的旋转将被锁定
/// </summary>
public partial class LookAt : AnimationBase
{
public TransformSubmodule targetTransformSubmodule;
public GameElement lookAtObject;
public FlexibleBool enabling;
public static LookAt GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
GameElement lookAtTarget, FlexibleBool enabling)
{
LookAt look = Instantiate(EditorManager.instance.basePrefabs.emptyObject).AddComponent<LookAt>();
look.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
look.animatedObject = animatedObject;
look.lookAtObject = lookAtTarget;
look.enabling = enabling;
look.animationReturnType = FlexibleReturnType.Before;
look.targetTransformSubmodule = (animatedObject as IHaveTransformSubmodule).transformSubmodule;
//look.timeDurationSubmodule.SetDuration(-999f, 999f); //TODO: 换为(-delay, songLength)
return look;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
enabling.UpdateFlexibleBool(songTime);
if (enabling.value)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Vector3 lookingDirection =
(lookAtObject.transform.position - animatedObject.transform.position).normalized;
Vector3 eulerAnglesOffset = Quaternion.LookRotation(lookingDirection).eulerAngles;
targetTransformSubmodule.eulerAnglesOffsetLock = true;
targetTransformSubmodule.currentEulerAngles = eulerAnglesOffset;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
targetTransformSubmodule.eulerAnglesOffsetLock = false;
}
}
public override void SaveBM()
{
matchedBM = new LookAt_BM(elementName, elementGuid, tags, parentElement.matchedBM as GameElement_BM,
enabling.ConvertToBM(), lookAtObject.elementGuid);
}
}
namespace Beatmap
{
public class LookAt_BM : GameElement_BM
{
public FlexibleBool_BM enabling;
public Guid lookAtObjectGuid;
public LookAt_BM()
{
}
public LookAt_BM(string elementName, Guid elementGuid, List<string> tags,
GameElement_BM attachedElement, FlexibleBool_BM enabling, Guid lookAtObjectGuid)
: base(elementName, elementGuid, tags, attachedElement)
{
this.enabling = enabling;
this.lookAtObjectGuid = lookAtObjectGuid;
}
public override void ExecuteBM()
{
matchedElement = LookAt.GenerateElement(elementName, elementGuid, tags, false,
GetElement(attachedElementGuid), GetElement(lookAtObjectGuid), enabling.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return LookAt.GenerateElement(elementName, elementGuid, tags, false, parent,
GetElement(lookAtObjectGuid), enabling.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Transform/LookAt.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: c02ee9e15cdc048c5909a61377382530
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

106
Assets/Scripts/EditorGame/Animations/Transform/Scale.cs Normal file
View File

@@ -0,0 +1,106 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class Scale : AnimationBase
{
public TransformSubmodule targetTransformSubmodule;
public FlexibleFloat scaleX, scaleY, scaleZ;
public static Scale GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
FlexibleFloat scaleX, FlexibleFloat scaleY, FlexibleFloat scaleZ)
{
Scale scale = Instantiate(EditorManager.instance.basePrefabs.emptyObject).AddComponent<Scale>();
scale.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
scale.animatedObject = animatedObject;
scale.scaleX = scaleX;
scale.scaleY = scaleY;
scale.scaleZ = scaleZ;
scale.animationReturnType = FlexibleReturnType.Before;
scale.targetTransformSubmodule = (animatedObject as IHaveTransformSubmodule).transformSubmodule;
//scale.timeDurationSubmodule.SetDuration(scaleX, scaleY, scaleZ);
return scale;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
scaleX.UpdateFlexibleFloat(songTime);
scaleY.UpdateFlexibleFloat(songTime);
scaleZ.UpdateFlexibleFloat(songTime);
if (scaleX.returnType is FlexibleReturnType.MiddleExecuting ||
scaleY.returnType is FlexibleReturnType.MiddleExecuting ||
scaleZ.returnType is FlexibleReturnType.MiddleExecuting)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Vector3 currentScale = new Vector3(scaleX.value, scaleY.value, scaleZ.value);
targetTransformSubmodule.scaleOffset.Add(currentScale);
targetTransformSubmodule.scaleDirtyMark = true;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
}
}
}
public partial class Scale
{
public override void SaveBM()
{
matchedBM = new Scale_BM(elementName, elementGuid, tags, parentElement.matchedBM as GameElement_BM,
scaleX.ConvertToBM(), scaleY.ConvertToBM(), scaleZ.ConvertToBM());
}
}
namespace Beatmap
{
public class Scale_BM : GameElement_BM
{
public FlexibleFloat_BM scaleX, scaleY, scaleZ;
public Scale_BM()
{
}
public Scale_BM(string elementName, Guid elementGuid, List<string> tags, GameElement_BM attachedElement,
FlexibleFloat_BM scaleX, FlexibleFloat_BM scaleY, FlexibleFloat_BM scaleZ)
: base(elementName, elementGuid, tags, attachedElement)
{
this.scaleX = scaleX;
this.scaleY = scaleY;
this.scaleZ = scaleZ;
}
public override void ExecuteBM()
{
matchedElement = Scale.GenerateElement(elementName, elementGuid, tags, false, GetElement(attachedElementGuid),
scaleX.ConvertToGameType(), scaleY.ConvertToGameType(), scaleZ.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return Scale.GenerateElement(elementName, elementGuid, tags, false,
parent, scaleX.ConvertToGameType(), scaleY.ConvertToGameType(), scaleZ.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Transform/Scale.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 1119784540bef4e73b37c7cb9f597065
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

107
Assets/Scripts/EditorGame/Animations/Transform/Swirl.cs Normal file
View File

@@ -0,0 +1,107 @@
using System;
using System.Collections;
using System.Collections.Generic;
using Ichni.RhythmGame.Beatmap;
using Lean.Pool;
using UnityEngine;
namespace Ichni.RhythmGame
{
public partial class Swirl : AnimationBase
{
private TransformSubmodule targetTransformSubmodule;
public FlexibleFloat eulerAngleX, eulerAngleY, eulerAngleZ;
public static Swirl GenerateElement(string elementName, Guid id,
List<string> tags, bool isFirstGenerated, GameElement animatedObject,
FlexibleFloat eulerAngleX, FlexibleFloat eulerAngleY, FlexibleFloat eulerAngleZ)
{
Swirl swirl = Instantiate(EditorManager.instance.basePrefabs.emptyObject).AddComponent<Swirl>();
swirl.Initialize(elementName, id, tags, isFirstGenerated, animatedObject);
swirl.animatedObject = animatedObject;
swirl.eulerAngleX = eulerAngleX;
swirl.eulerAngleY = eulerAngleY;
swirl.eulerAngleZ = eulerAngleZ;
swirl.animationReturnType = FlexibleReturnType.Before;
swirl.targetTransformSubmodule = (animatedObject as IHaveTransformSubmodule).transformSubmodule;
//swirl.timeDurationSubmodule.SetDuration(eulerAngleX, eulerAngleY, eulerAngleZ);
return swirl;
}
protected override void SetDefaultSubmodules()
{
timeDurationSubmodule = new TimeDurationSubmodule(this);
submoduleList.Add(timeDurationSubmodule);
}
protected override void UpdateAnimation(float songTime)
{
eulerAngleX.UpdateFlexibleFloat(songTime);
eulerAngleY.UpdateFlexibleFloat(songTime);
eulerAngleZ.UpdateFlexibleFloat(songTime);
if (eulerAngleX.returnType is FlexibleReturnType.MiddleExecuting ||
eulerAngleY.returnType is FlexibleReturnType.MiddleExecuting ||
eulerAngleZ.returnType is FlexibleReturnType.MiddleExecuting)
{
animationReturnType = FlexibleReturnType.MiddleExecuting;
Vector3 currentEulerAngles = new Vector3(eulerAngleX.value, eulerAngleY.value, eulerAngleZ.value);
targetTransformSubmodule.eulerAnglesOffset.Add(currentEulerAngles);
targetTransformSubmodule.eulerAnglesDirtyMark = true;
}
else
{
animationReturnType = FlexibleReturnType.MiddleInterval;
}
}
}
public partial class Swirl
{
public override void SaveBM()
{
matchedBM = new Swirl_BM(elementName, elementGuid, tags, parentElement.matchedBM as GameElement_BM,
eulerAngleX.ConvertToBM(), eulerAngleY.ConvertToBM(), eulerAngleZ.ConvertToBM());
}
}
namespace Beatmap
{
public class Swirl_BM : AnimationBase_BM
{
public FlexibleFloat_BM eulerAngleX, eulerAngleY, eulerAngleZ;
public Swirl_BM()
{
}
public Swirl_BM(string elementName, Guid elementGuid, List<string> tags, GameElement_BM attachedElement,
FlexibleFloat_BM eulerAngleX, FlexibleFloat_BM eulerAngleY, FlexibleFloat_BM eulerAngleZ)
: base(elementName, elementGuid, tags, attachedElement)
{
this.eulerAngleX = eulerAngleX;
this.eulerAngleY = eulerAngleY;
this.eulerAngleZ = eulerAngleZ;
}
public override void ExecuteBM()
{
matchedElement = Swirl.GenerateElement(elementName, elementGuid, tags, false, GetElement(attachedElementGuid),
eulerAngleX.ConvertToGameType(), eulerAngleY.ConvertToGameType(), eulerAngleZ.ConvertToGameType());
}
public override GameElement DuplicateBM(GameElement parent)
{
return Swirl.GenerateElement(elementName, elementGuid, tags, false, parent,
eulerAngleX.ConvertToGameType(), eulerAngleY.ConvertToGameType(), eulerAngleZ.ConvertToGameType());
}
}
}
}

11
Assets/Scripts/EditorGame/Animations/Transform/Swirl.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: e6daf69621681491bb09cc72e2ff4bdb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: