private void Update_Tray(Beatmap.Track linkedTrack, Beatmap.Note noteData)
{
if (linkedTrack.HasTray && noteData.Time < linkedTrack.c_TrayTime && (noteData.Time + noteData.Duration) > MusicTime)
{
linkedTrack.c_TrayTime = noteData.Time;
linkedTrack.c_TrayX = (noteData.X - noteData.Width * 0.5f, noteData.X + noteData.Width * 0.5f);
}
}
private void Update_Movement(Beatmap.Stage linkedStage, Beatmap.Track trackData)
{
var(zoneMin, zoneMax, zoneSize, _) = ZoneMinMax;
float trackWidth = GetTrackWidth(trackData);
float stageWidth = Stage.GetStageWidth(linkedStage);
float stageHeight = Stage.GetStageHeight(linkedStage);
float stagePivotY = Stage.GetStagePivotY(linkedStage);
float stageRotZ = Stage.GetStageWorldRotationZ(linkedStage);
var stagePos = Stage.GetStagePosition(linkedStage, trackData.StageIndex);
float rotX = GetTrackAngle(trackData);
float trackX = GetTrackX(trackData);
var pos = Stage.LocalToZone(trackX, 0f, 0f, stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ);
// Movement
transform.position = Util.Vector3Lerp3(zoneMin, zoneMax, pos.x, pos.y);
transform.localRotation = Quaternion.Euler(0f, 0f, stageRotZ) * Quaternion.Euler(rotX, 0, 0);
ColSize = MainRenderer.transform.localScale = m_TrackTintRenderer.transform.localScale = new Vector3(
zoneSize * trackWidth * stageWidth,
zoneSize * stageHeight,
1f
);
// Tray
if (trackData.HasTray)
{
var traySize = GetRectSize(SkinType.Tray, trackData.ItemType, false, false);
var judgeLineSize = GetRectSize(SkinType.JudgeLine, trackData.ItemType);
var trayPos = LocalToZone(
TrayX, judgeLineSize.y / 2f / stageHeight, 0f,
stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ,
trackX, trackWidth, rotX
);
m_TrayRenderer.transform.position = Util.Vector3Lerp3(zoneMin, zoneMax, trayPos.x, trayPos.y);
m_TrayRenderer.transform.localScale = new Vector3(traySize.x, traySize.y, 1f);
m_TrayRenderer.Scale = traySize;
}
// Renderer
MainRenderer.RendererEnable = true;
m_TrackTintRenderer.RendererEnable = true;
m_TrackTintRenderer.ItemType = trackData.ItemType;
MainRenderer.ItemType = trackData.ItemType;
m_TrayRenderer.RendererEnable = trackData.HasTray;
m_TrayRenderer.ItemType = trackData.ItemType;
MainRenderer.Duration = m_TrayRenderer.Duration = m_TrackTintRenderer.Duration = Duration;
MainRenderer.Scale = m_TrackTintRenderer.Scale = new Vector2(stageWidth * trackWidth, stageHeight);
m_TrackTintRenderer.Tint = trackData.c_Tint = GetTrackColor(trackData);
MainRenderer.Alpha = m_TrayRenderer.Alpha = Stage.GetStageAlpha(linkedStage) * GetTrackAlpha(trackData);
m_TrackTintRenderer.Alpha *= MainRenderer.Alpha;
MainRenderer.SetSortingLayer(SortingLayerID_Track, GetSortingOrder());
m_TrackTintRenderer.SetSortingLayer(SortingLayerID_TrackTint, GetSortingOrder());
m_TrayRenderer.SetSortingLayer(SortingLayerID_Tray, GetSortingOrder());
}
private void LateUpdate_Tray(Beatmap.Track trackData)
{
if (trackData.HasTray)
{
if (AimTrayX < trackData.c_TrayX.min)
{
AimTrayX = Mathf.Lerp(trackData.c_TrayX.min, trackData.c_TrayX.max, trackData.c_TrayTime - MusicTime > 0.5f ? 0.5f : 0.3f);
}
else if (AimTrayX > trackData.c_TrayX.max)
{
AimTrayX = Mathf.Lerp(trackData.c_TrayX.min, trackData.c_TrayX.max, trackData.c_TrayTime - MusicTime > 0.5f ? 0.5f : 0.7f);
}
TrayX = Mathf.Lerp(TrayX, AimTrayX, UnityEngine.Time.deltaTime * 20f);
}
trackData.c_TrayTime = float.MaxValue;
}
private void Update()
{
MainRenderer.RendererEnable = false;
m_TrackTintRenderer.RendererEnable = false;
m_TrayRenderer.RendererEnable = false;
ColSize = null;
LateTrackData = null;
// Get TrackData
int trackIndex = transform.GetSiblingIndex();
var trackData = !(Beatmap is null) && trackIndex < Beatmap.Tracks.Count ? Beatmap.Tracks[trackIndex] : null;
if (trackData == null)
{
Update_Gizmos(false, trackIndex, 1f);
gameObject.SetActive(false);
return;
}
Time = trackData.Time;
Duration = trackData.Duration;
// Get/Check Track/Stage
var linkedStage = trackData.StageIndex >= 0 && trackData.StageIndex < Beatmap.Stages.Count ? Beatmap.Stages[trackData.StageIndex] : null;
if (linkedStage == null)
{
Update_Gizmos(false, trackIndex, 1f);
gameObject.SetActive(false);
return;
}
Update_Gizmos(trackData._Active, trackIndex, trackData._SpeedMuti);
if (!trackData._Active)
{
gameObject.SetActive(false);
return;
}
LateTrackData = trackData;
// Movement
Update_Movement(linkedStage, trackData);
}
private void FixTrackLogic(Beatmap map, GeneData gene, Beatmap.Track track, int index)
{
var config = GetTrackConfig(gene, index);
if (config.UseConfig)
{
bool tiling = GetStageConfig(gene, track.stageIndex).TileTrack;
if (config.Time_Real.Active)
{
track.time = (int)(config.Time_Real.Value * GetMusicDuration());
}
if (config.Duration_Real.Active)
{
track.duration = (int)(config.Duration_Real.Value * map.GetDuration(0, track.stageIndex));
}
if (config.ItemType.Active)
{
track.itemType = config.ItemType.Value;
}
if (config.X.Active && !tiling)
{
track.x = config.X.Value;
}
if (config.Angle.Active)
{
track.angle = config.Angle.Value;
}
if (config.Width.Active && !tiling)
{
track.width = config.Width.Value;
}
if (config.Speed.Active)
{
track.speed = config.Speed.Value;
}
if (config.StageIndex.Active)
{
track.stageIndex = config.StageIndex.Value;
}
if (config.HasTray.Active)
{
track.hasTray = config.HasTray.Value == 1;
}
if (!config.Motion_X)
{
track.xs.Clear();
}
if (!config.Motion_Angle)
{
track.angles.Clear();
}
if (!config.Motion_Width)
{
track.widths.Clear();
}
if (!config.Motion_Color)
{
track.colors.Clear();
}
}
}
private static bool GetTrackActive(Beatmap.Track data, int trackIndex) => Solo.active ? trackIndex == Solo.track : MusicTime >= data.Time && MusicTime <= data.Time + data.Duration;
public static float GetTrackAngle(Beatmap.Track data) => Mathf.LerpAngle(
data.Angle + Evaluate(data.Angles, MusicTime - data.Time),
0f,
Abreast.value
);
public static float GetTrackAlpha(Beatmap.Track data) => MusicPlaying?Mathf.Clamp01(
VanishDuration < FLOAT_GAP? 1f : Mathf.Min(MusicTime - data.Time, data.Time + data.Duration - MusicTime) / VanishDuration
) : 1f;
public static Color GetTrackColor(Beatmap.Track data) => EvaluateColor(data.Colors, MusicTime - data.Time, PaletteColor(data.Color));
public static float GetTrackX(Beatmap.Track data) => data.X + Evaluate(data.Xs, MusicTime - data.Time);
public static float GetTrackWidth_Motion(Beatmap.Track data) => Evaluate(data.Widths, MusicTime - data.Time, 1f);
public static float GetTrackWidth(Beatmap.Track data) => Mathf.Max(
data.Width * Evaluate(data.Widths, MusicTime - data.Time, 1f), 0f
);
public static void UpdateCache(Beatmap.Track data, bool stageActive, int trackIndex, bool timerActive, float parentSpeed)
{
data._Active = stageActive && GetTrackActive(data, trackIndex);
data._SpeedMuti = parentSpeed * data.Speed;
data._TimerActive = timerActive;
}
private void Update_Movement(Beatmap.Stage linkedStage, Beatmap.Track linkedTrack, Beatmap.Note noteData, Beatmap.Note linkedNote)
{
var stagePos = Stage.GetStagePosition(linkedStage, linkedTrack.StageIndex);
float stageWidth = Stage.GetStageWidth(linkedStage);
float stagePivotY = Stage.GetStagePivotY(linkedStage);
float stageHeight = Stage.GetStageHeight(linkedStage);
float stageRotZ = Stage.GetStageWorldRotationZ(linkedStage);
float trackX = Track.GetTrackX(linkedTrack);
float trackWidth = Track.GetTrackWidth(linkedTrack);
float trackAngle = Track.GetTrackAngle(linkedTrack);
float gameOffset = GetGameDropOffset(noteData.TimingID, noteData._SpeedMuti);
float noteY01 = MusicTime < Time ? (noteData._NoteDropStart - gameOffset) : 0f;
float noteSizeY = noteData._NoteDropEnd - gameOffset - noteY01;
var(zoneMin, zoneMax, zoneSize, _) = ZoneMinMax;
bool isLink = linkedNote != null;
bool activeSelf = GetNoteActive(noteData, null, noteData._AppearTime);
float alpha = Stage.GetStageAlpha(linkedStage) * Track.GetTrackAlpha(linkedTrack) * Mathf.Clamp01(16f - noteY01 * 16f);
bool highlighing = MusicTime > Time && MusicTime < Time + Duration;
float noteZ = GetNoteZ(noteData);
var tint = highlighing ? HighlightTints[(int)SkinType.Note] : WHITE_32;
if (TintNote)
{
tint *= linkedTrack.c_Tint;
}
// Movement
var noteZonePos = Track.LocalToZone(
noteData.X, noteY01, noteZ,
stagePos, stageWidth, stageHeight, stagePivotY, stageRotZ,
trackX, trackWidth, trackAngle
);
var noteRot = Quaternion.Euler(0f, 0f, stageRotZ) * Quaternion.Euler(trackAngle, 0f, 0f);
var noteWorldPos = Util.Vector3Lerp3(zoneMin, zoneMax, noteZonePos.x, noteZonePos.y, noteZonePos.z);
// Size
var noteSize = GetRectSize(SkinType.Note, noteData.ItemType);
float minHeight = GetMinHeight(SkinType.Note, noteData.ItemType);
float noteScaleX = noteSize.x < 0f ? stageWidth * trackWidth * noteData.Width : noteSize.x;
float noteScaleY_scaler = Mathf.Max(noteSizeY * stageHeight, minHeight);
float noteScaleY = Mathf.Max(noteSizeY * stageHeight + minHeight, 0f);
Vector3 zoneNoteScale = new Vector3(
zoneSize * noteScaleX,
zoneSize * noteScaleY,
1f
);
Vector3 zoneNoteScale_scaler = new Vector3(
zoneSize * noteScaleX,
zoneSize * noteScaleY_scaler,
1f
);
// Transform
transform.position = Late_NoteWorldPos = noteWorldPos;
ColRot = MainRenderer.transform.rotation = noteRot;
ColSize = MainRenderer.transform.localScale = zoneNoteScale;
m_Scaler.localScale = zoneNoteScale_scaler;
m_Scaler.rotation = noteRot;
// Renderer
MainRenderer.RendererEnable = !isLink || activeSelf;
MainRenderer.ItemType = noteData.ItemType;
MainRenderer.Tint = tint;
MainRenderer.Alpha = alpha;
MainRenderer.Duration = Duration;
MainRenderer.Scale = new Vector2(noteScaleX, noteScaleY);
MainRenderer.SetSortingLayer(
Duration <= FLOAT_GAP ? SortingLayerID_Note : SortingLayerID_Note_Hold,
GetSortingOrder()
);
}
