コード例 #1
0
        public override SizeF GetNoteRadius(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var timeRemaining   = note.HitTime - now;
            var timePoints      = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
            var timeTransformed = NoteTimeTransform((float)timeRemaining / timePoints.Duration);
            var endRadius       = noteMetrics.EndRadius;

            if (timeTransformed < 0.75f)
            {
                if (timeTransformed < 0f)
                {
                    return(endRadius);
                }
                else
                {
                    var r = 1 - (float)timeTransformed * 0.933333333f;
                    return(new SizeF(endRadius.Width * r, endRadius.Height * r));
                }
            }
            else
            {
                if (timeTransformed < 1f)
                {
                    var r = (1 - (float)timeTransformed) * 1.2f;
                    return(new SizeF(endRadius.Width * r, endRadius.Height * r));
                }
                else
                {
                    return(SizeF.Empty);
                }
            }
        }
コード例 #2
0
        public override float GetNoteY(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var timePoints    = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
            var onStageStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, timePoints);

            float y;

            switch (onStageStatus)
            {
            case OnStageStatus.Incoming:
                y = animationMetrics.Top;
                break;

            case OnStageStatus.Visible:
                y = GetNoteOnStageY(note, now, timePoints, animationMetrics);
                break;

            case OnStageStatus.Passed:
                y = animationMetrics.Bottom;
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(y);
        }
コード例 #3
0
        public override float GetSpecialNoteX(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var leftRatio  = animationMetrics.NoteEndXRatios[0];
            var rightRatio = animationMetrics.NoteEndXRatios[animationMetrics.TrackCount - 1];
            var xRatio     = (leftRatio + rightRatio) / 2;

            return(animationMetrics.Width * xRatio);
        }
コード例 #4
0
        public override float GetNoteY(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            if (now >= note.HitTime)
            {
                return(animationMetrics.Bottom);
            }

            var transformedTime = GetTransformedTime(note, now, animationMetrics);

            return(GetNoteYByTransformedTime(transformedTime, animationMetrics));
        }
コード例 #5
0
        public override Vector2 GetNoteRadius(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var onStageStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);

            switch (onStageStatus)
            {
            case OnStageStatus.Incoming:
                return(Vector2.Zero);

            case OnStageStatus.Passed:
                return(noteMetrics.EndRadius);
            }

            var timeRemaining   = note.HitTime - now;
            var timePoints      = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
            var timeTransformed = NoteTimeTransform(timeRemaining / timePoints.Duration);
            var endRadius       = noteMetrics.EndRadius;

            if (timeTransformed < 0.75f)
            {
                if (timeTransformed < 0f)
                {
                    return(endRadius);
                }
                else
                {
                    var r = 1 - timeTransformed * 0.933333333f;
                    return(new Vector2(endRadius.X * r, endRadius.Y * r));
                }
            }
            else
            {
                if (timeTransformed < 1f)
                {
                    var r = (1 - timeTransformed) * 1.2f;
                    return(new Vector2(endRadius.X * r, endRadius.Y * r));
                }
                else
                {
                    return(Vector2.Zero);
                }
            }
        }
コード例 #6
0
        public override float GetNoteX(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var trackCount       = animationMetrics.TrackCount;
            var trackXRatioStart = animationMetrics.NoteEndXRatios[0];
            var trackXRatioEnd   = animationMetrics.NoteEndXRatios[trackCount - 1];

            var endXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (note.EndX / (trackCount - 1));

            var   onStage = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
            float xRatio;

            switch (onStage)
            {
            case OnStageStatus.Incoming:
                if (note.HasPrevHold())
                {
                    xRatio = GetIncomingNoteXRatio(note.PrevHold, note, now, noteMetrics, animationMetrics);
                }
                else if (note.HasPrevSlide())
                {
                    xRatio = GetIncomingNoteXRatio(note.PrevSlide, note, now, noteMetrics, animationMetrics);
                }
                else
                {
                    xRatio = endXRatio;
                }
                break;

            case OnStageStatus.Passed when note.HasNextSlide():
                var destXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (note.NextSlide.EndX / (trackCount - 1));

                var nextPerc = (float)(now - note.HitTime) / (float)(note.NextSlide.HitTime - note.HitTime);
                xRatio = MathHelper.Lerp(endXRatio, destXRatio, nextPerc);
                break;

            default:
                xRatio = endXRatio;
                break;
            }

            return(animationMetrics.Width * xRatio);
        }
コード例 #7
0
        public override float GetNoteX(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            if (note.IsSlide() && note.HasNextSlide())
            {
                var thisStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
                if (thisStatus >= OnStageStatus.Passed)
                {
                    var nextSlide  = note.NextSlide;
                    var nextStatus = NoteAnimationHelper.GetOnStageStatusOf(nextSlide, now, animationMetrics);
                    if (nextStatus < OnStageStatus.Passed)
                    {
                        var x1 = GetEndXByNotePosition(note.EndX, animationMetrics);
                        var x2 = GetEndXByNotePosition(nextSlide.EndX, animationMetrics);
                        return((float)((now - note.HitTime) / (nextSlide.HitTime - note.HitTime)) * (x2 - x1) + x1);
                    }
                }
            }

            var transformedTime = GetTransformedTime(note, now, animationMetrics);

            return(GetNoteXByTransformedTime(note, transformedTime, animationMetrics));
        }
コード例 #8
0
        public override Vector2 GetNoteRadius(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var timePoints    = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
            var onStageStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, timePoints);

            switch (onStageStatus)
            {
            case OnStageStatus.Incoming:
                return(noteMetrics.StartRadius);

            case OnStageStatus.Visible:
                var passed = now - timePoints.Enter;
                var perc   = passed / timePoints.Duration;
                var w      = MathHelperEx.Lerp(noteMetrics.StartRadius.X, noteMetrics.EndRadius.X, perc);
                var h      = MathHelperEx.Lerp(noteMetrics.StartRadius.Y, noteMetrics.EndRadius.Y, perc);
                return(new Vector2(w, h));

            case OnStageStatus.Passed:
                return(noteMetrics.EndRadius);

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
コード例 #9
0
        private static float GetIncomingNoteXRatio([NotNull] RuntimeNote prevNote, RuntimeNote thisNote, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var trackCount       = animationMetrics.TrackCount;
            var trackXRatioStart = animationMetrics.NoteEndXRatios[0];
            var trackXRatioEnd   = animationMetrics.NoteEndXRatios[trackCount - 1];

            var thisXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (prevNote.EndX / (trackCount - 1));
            var nextXRatio = trackXRatioStart + (trackXRatioEnd - trackXRatioStart) * (thisNote.EndX / (trackCount - 1));

            var thisTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(prevNote, animationMetrics);
            var nextTimePoints = NoteAnimationHelper.CalculateNoteTimePoints(thisNote, animationMetrics);

            var perc = (float)(now - thisTimePoints.Enter) / (float)(nextTimePoints.Enter - thisTimePoints.Enter);

            return(MathHelper.Lerp(thisXRatio, nextXRatio, perc));
        }
コード例 #10
0
 public override Vector2 GetSpecialNoteRadius(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(GetNoteRadius(note, now, noteMetrics, animationMetrics));
 }
コード例 #11
0
        protected override void OnDraw(GameTime gameTime, RenderContext context)
        {
            base.OnDraw(gameTime, context);

            var settings = Program.Settings;

            var motionIcon = settings.Style.SlideMotionIcon;

            if (motionIcon == SlideMotionIcon.None)
            {
                return;
            }

            if (_score == null)
            {
                return;
            }

            var notes       = _score.Notes;
            var theaterDays = Game.AsTheaterDays();

            var syncTimer = theaterDays.FindSingleElement <SyncTimer>();

            if (syncTimer == null)
            {
                return;
            }

            var tapPoints = theaterDays.FindSingleElement <TapPoints>();

            if (tapPoints == null)
            {
                throw new InvalidOperationException();
            }

            var notesLayer = theaterDays.FindSingleElement <NotesLayer>();

            if (notesLayer == null)
            {
                throw new InvalidOperationException();
            }

            var gamingArea = theaterDays.FindSingleElement <GamingArea>();

            if (gamingArea == null)
            {
                throw new InvalidOperationException();
            }

            var now              = syncTimer.CurrentTime.TotalSeconds;
            var tapPointsLayout  = settings.UI.TapPoints.Layout;
            var notesLayerLayout = settings.UI.NotesLayer.Layout;
            var clientSize       = context.ClientSize;

            var traceCalculator = notesLayer.TraceCalculator;

            var commonNoteMetrics = new NoteMetrics {
                StartRadius = gamingArea.ScaleResults.Note.Start,
                EndRadius   = gamingArea.ScaleResults.Note.End
            };

            var animationMetrics = new NoteAnimationMetrics {
                GlobalSpeedScale = notesLayer.GlobalSpeedScale,
                Width            = clientSize.Width,
                Height           = clientSize.Height,
                Top              = notesLayerLayout.Y.IsPercentage ? notesLayerLayout.Y.Value * clientSize.Height : notesLayerLayout.Y.Value,
                Bottom           = tapPointsLayout.Y.IsPercentage ? tapPointsLayout.Y.Value * clientSize.Height : tapPointsLayout.Y.Value,
                NoteStartXRatios = tapPoints.StartXRatios,
                NoteEndXRatios   = tapPoints.EndXRatios,
                TrackCount       = tapPoints.EndXRatios.Length
            };

            context.Begin2D();

            foreach (var note in notes)
            {
                if (!note.IsSlide() || !note.HasNextSlide())
                {
                    continue;
                }

                var thisStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
                if (thisStatus < OnStageStatus.Passed)
                {
                    continue;
                }

                var nextStatus = NoteAnimationHelper.GetOnStageStatusOf(note.NextSlide, now, animationMetrics);
                if (nextStatus >= OnStageStatus.Passed)
                {
                    continue;
                }

                var x = traceCalculator.GetNoteX(note, now, commonNoteMetrics, animationMetrics);
                var y = traceCalculator.GetNoteY(note, now, commonNoteMetrics, animationMetrics);

                SizeF imageSize;
                switch (motionIcon)
                {
                case SlideMotionIcon.None:
                    // Not possible.
                    throw new InvalidOperationException();

                case SlideMotionIcon.Tap:
                    if (_tapPointImage != null)
                    {
                        imageSize = gamingArea.ScaleResults.TapPoint.Start;
                        context.DrawBitmap(_tapPointImage, x - imageSize.Width / 2, y - imageSize.Height / 2, imageSize.Width, imageSize.Height);
                    }
                    break;

                case SlideMotionIcon.Slide:
                    if (_noteImages?[0] != null)
                    {
                        var(imageIndex, _) = NotesLayer.GetImageIndex(NoteType.Slide, NoteSize.Small, FlickDirection.None, false, false, false, false);
                        imageSize          = gamingArea.ScaleResults.Note.End;
                        context.DrawImageStripUnit(_noteImages[0], imageIndex, x - imageSize.Width / 2, y - imageSize.Height / 2, imageSize.Width, imageSize.Height);
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            context.End2D();
        }
コード例 #12
0
 public abstract RibbonParameters GetSlideRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics);
コード例 #13
0
 public abstract float GetSpecialNoteY(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics);
コード例 #14
0
        public override RibbonParameters GetHoldRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var t1   = (float)GetTransformedTime(startNote, now, animationMetrics);
            var t2   = (float)GetTransformedTime(endNote, now, animationMetrics);
            var tmid = (t1 + t2) * 0.5f;

            var x1   = GetNoteXByTransformedTime(startNote, t1, animationMetrics);
            var x2   = GetNoteXByTransformedTime(endNote, t2, animationMetrics);
            var xmid = GetNoteXByTransformedTime(endNote, tmid, animationMetrics);

            var y1   = GetNoteYByTransformedTime(t1, animationMetrics);
            var y2   = GetNoteYByTransformedTime(t2, animationMetrics);
            var ymid = GetNoteYByTransformedTime(tmid, animationMetrics);

            var(controlX1, controlX2) = GetBezierFromQuadratic(x1, xmid, x2);
            var(controlY1, controlY2) = GetBezierFromQuadratic(y1, ymid, y2);

            return(new RibbonParameters(x1, y1, controlX1, controlY1, controlX2, controlY2, x2, y2));
        }
コード例 #15
0
ファイル: SlideMotion.cs プロジェクト: KinoMyu/MilliSim
        protected override void OnDraw(GameTime gameTime)
        {
            base.OnDraw(gameTime);

            var config = ConfigurationStore.Get <SlideMotionConfig>();

            var motionIcon = config.Data.Icon;

            if (motionIcon == SlideMotionConfig.SlideMotionIcon.None)
            {
                return;
            }

            var theaterDays = Game.ToBaseGame();

            var score = theaterDays.FindSingleElement <ScoreLoader>()?.RuntimeScore;

            if (score == null)
            {
                return;
            }

            var notes = score.Notes;

            var syncTimer = theaterDays.FindSingleElement <SyncTimer>();

            if (syncTimer == null)
            {
                return;
            }

            var tapPoints = theaterDays.FindSingleElement <TapPoints>();

            if (tapPoints == null)
            {
                throw new InvalidOperationException();
            }

            var notesLayer = theaterDays.FindSingleElement <NotesLayer>();

            if (notesLayer == null)
            {
                throw new InvalidOperationException();
            }

            var scalingResponder = theaterDays.FindSingleElement <MltdStageScalingResponder>();

            if (scalingResponder == null)
            {
                throw new InvalidOperationException();
            }

            var now = (float)syncTimer.CurrentTime.TotalSeconds;

            var tapPointsConfig  = ConfigurationStore.Get <TapPointsConfig>();
            var notesLayerConfig = ConfigurationStore.Get <NotesLayerConfig>();
            var tapPointsLayout  = tapPointsConfig.Data.Layout;
            var notesLayerLayout = notesLayerConfig.Data.Layout;
            var clientSize       = theaterDays.GraphicsDevice.Viewport;

            var animationCalculator = notesLayer.AnimationCalculator;

            var commonNoteMetrics = new NoteMetrics {
                StartRadius = scalingResponder.ScaleResults.Note.Start,
                EndRadius   = scalingResponder.ScaleResults.Note.End
            };

            var animationMetrics = new NoteAnimationMetrics {
                GlobalSpeedScale = notesLayer.GlobalSpeedScale,
                Width            = clientSize.Width,
                Height           = clientSize.Height,
                Top              = notesLayerLayout.Y.IsPercentage ? notesLayerLayout.Y.Value * clientSize.Height : notesLayerLayout.Y.Value,
                Bottom           = tapPointsLayout.Y.IsPercentage ? tapPointsLayout.Y.Value * clientSize.Height : tapPointsLayout.Y.Value,
                NoteStartXRatios = tapPoints.StartXRatios,
                NoteEndXRatios   = tapPoints.EndXRatios,
                TrackCount       = tapPoints.EndXRatios.Length
            };

            var spriteBatch = theaterDays.SpriteBatch;

            spriteBatch.Begin();

            foreach (var note in notes)
            {
                if (!note.IsSlide() || !note.HasNextSlide())
                {
                    continue;
                }

                var thisStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
                if (thisStatus < OnStageStatus.Passed)
                {
                    continue;
                }

                var nextStatus = NoteAnimationHelper.GetOnStageStatusOf(note.NextSlide, now, animationMetrics);
                if (nextStatus >= OnStageStatus.Passed)
                {
                    continue;
                }

                var x = animationCalculator.GetNoteX(note, now, commonNoteMetrics, animationMetrics);
                var y = animationCalculator.GetNoteY(note, now, commonNoteMetrics, animationMetrics);

                Vector2 imageSize;
                switch (motionIcon)
                {
                case SlideMotionConfig.SlideMotionIcon.None:
                    // Not possible.
                    throw new InvalidOperationException();

                case SlideMotionConfig.SlideMotionIcon.TapPoint:
                    if (_tapPointImage != null)
                    {
                        imageSize = scalingResponder.ScaleResults.TapPoint.Start;
                        spriteBatch.Draw(_tapPointImage, RectHelper.RoundToRectangle(x - imageSize.X / 2, y - imageSize.Y / 2, imageSize.X, imageSize.Y));
                    }
                    break;

                case SlideMotionConfig.SlideMotionIcon.SlideStart:
                case SlideMotionConfig.SlideMotionIcon.SlideMiddle:
                case SlideMotionConfig.SlideMotionIcon.SlideEnd:
                    var isStart = motionIcon == SlideMotionConfig.SlideMotionIcon.SlideStart;
                    var isEnd   = motionIcon == SlideMotionConfig.SlideMotionIcon.SlideEnd;
                    if (_noteImages?[0] != null)
                    {
                        var(imageIndex, _) = NotesLayer.GetImageIndex(NoteType.Slide, NoteSize.Small, FlickDirection.None, false, false, isStart, isEnd);
                        imageSize          = scalingResponder.ScaleResults.Note.End;
                        spriteBatch.Draw(_noteImages[0], imageIndex, RectHelper.RoundToRectangle(x - imageSize.X / 2, y - imageSize.Y / 2, imageSize.X, imageSize.Y));
                    }
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }

            spriteBatch.End();
        }
コード例 #16
0
 public override RibbonParameters GetFlickRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(new RibbonParameters {
         Visible = false
     });
 }
コード例 #17
0
 public override float GetSpecialNoteY(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(GetNoteY(note, now, noteMetrics, animationMetrics));
 }
コード例 #18
0
        public override RibbonParameters GetSlideRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var x1 = GetNoteX(startNote, now, noteMetrics, animationMetrics);
            var y1 = GetNoteY(startNote, now, noteMetrics, animationMetrics);
            var x2 = GetNoteX(endNote, now, noteMetrics, animationMetrics);
            var y2 = GetNoteY(endNote, now, noteMetrics, animationMetrics);

            return(new RibbonParameters(x1, y1, x2, y2));
        }
コード例 #19
0
 public override SizeF GetSpecialNoteRadius(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(GetNoteRadius(note, now, noteMetrics, animationMetrics));
 }
コード例 #20
0
        public override RibbonParameters GetSlideRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var startStatus = NoteAnimationHelper.GetOnStageStatusOf(startNote, now, animationMetrics);

            if (startNote.IsSlideEnd() || startStatus < OnStageStatus.Passed)
            {
                return(GetHoldRibbonParameters(startNote, endNote, now, noteMetrics, animationMetrics));
            }

            var startX1 = GetEndXByNotePosition(startNote.EndX, animationMetrics);
            var startX2 = GetEndXByNotePosition(endNote.EndX, animationMetrics);

            var y1 = animationMetrics.Bottom;
            var x1 = (float)((now - startNote.HitTime) / (endNote.HitTime - startNote.HitTime)) * (startX2 - startX1) + startX1;

            var t1   = GetTransformedTime(startNote, now, animationMetrics);
            var t2   = GetTransformedTime(endNote, now, animationMetrics);
            var tmid = (t1 + t2) * 0.5f;

            var x2   = GetNoteXByTransformedTime(endNote, t2, animationMetrics);
            var xmid = GetNoteXByTransformedTime(endNote, tmid, animationMetrics);

            var y2   = GetNoteYByTransformedTime(t2, animationMetrics);
            var ymid = GetNoteYByTransformedTime(tmid, animationMetrics);

            var(controlX1, controlX2) = GetBezierFromQuadratic(x1, xmid, x2);
            var(controlY1, controlY2) = GetBezierFromQuadratic(y1, ymid, y2);

            return(new RibbonParameters(x1, y1, controlX1, controlY1, controlX2, controlY2, x2, y2));
        }
コード例 #21
0
        public override RibbonParameters GetHoldRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var tp1 = NoteAnimationHelper.CalculateNoteTimePoints(startNote, animationMetrics);
            var tp2 = NoteAnimationHelper.CalculateNoteTimePoints(endNote, animationMetrics);

            var t1    = GetTransformedTime(startNote, now, tp1);
            var t2    = GetTransformedTime(endNote, now, tp2);
            var tperc = startNote.IsHold() ? 0.5 : 0.4;
            var tm    = MathHelperEx.Lerp(t1, t2, tperc);

            var x1 = GetNoteX(startNote, now, noteMetrics, animationMetrics);
            var x2 = GetNoteX(endNote, now, noteMetrics, animationMetrics);

            var   startStatus = NoteAnimationHelper.GetOnStageStatusOf(startNote, now, tp1);
            float y1;

            if (startStatus == OnStageStatus.Passed)
            {
                y1 = animationMetrics.Bottom;
            }
            else
            {
                y1 = GetNoteOnStageY(t1, animationMetrics);
            }

            var   endStatus = NoteAnimationHelper.GetOnStageStatusOf(endNote, now, tp2);
            float y2;

            if (endStatus == OnStageStatus.Incoming)
            {
                y2 = animationMetrics.Top;
            }
            else
            {
                y2 = GetNoteOnStageY(t2, animationMetrics);
            }

            // CGSS-like
            //var xm = GetNoteOnStageX(endNote.StartX, endNote.EndX, tm, animationMetrics);
            // Naive guess
            //var xm = (x1 + x2) / 2;
            var xm = MathHelperEx.Lerp(x1, x2, 0.5f);

            if (startNote.IsSlide())
            {
                if (endNote.EndX < startNote.EndX)
                {
                    xm -= animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
                }
                else if (endNote.EndX > startNote.EndX)
                {
                    xm += animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
                }
            }
            var ym = GetNoteOnStageY(tm, animationMetrics);

            var(cx1, cx2) = GetBezierFromQuadratic(x1, xm, x2);
            var(cy1, cy2) = GetBezierFromQuadratic(y1, ym, y2);
            return(new RibbonParameters(x1, y1, cx1, cy1, cx2, cy2, x2, y2));
        }
コード例 #22
0
 public override SizeF GetNoteRadius(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(noteMetrics.EndRadius);
 }
コード例 #23
0
        public override RibbonParameters GetSlideRibbonParameters(RuntimeNote startNote, RuntimeNote endNote, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var tp1        = NoteAnimationHelper.CalculateNoteTimePoints(startNote, animationMetrics);
            var thisStatus = NoteAnimationHelper.GetOnStageStatusOf(startNote, now, tp1);

            if (thisStatus < OnStageStatus.Passed)
            {
                return(GetHoldRibbonParameters(startNote, endNote, now, noteMetrics, animationMetrics));
            }

            var tp2 = NoteAnimationHelper.CalculateNoteTimePoints(endNote, animationMetrics);

            var t1    = GetTransformedTime(startNote, now, tp1);
            var t2    = GetTransformedTime(endNote, now, tp2);
            var tperc = startNote.IsHold() ? 0.5 : 0.4;
            var tm    = MathHelperEx.Lerp(t1, t2, tperc);

            var trackCount       = animationMetrics.TrackCount;
            var leftMarginRatio  = animationMetrics.NoteEndXRatios[0];
            var rightMarginRatio = animationMetrics.NoteEndXRatios[trackCount - 1];
            var startXRatio      = leftMarginRatio + (rightMarginRatio - leftMarginRatio) * (startNote.EndX / (trackCount - 1));
            var endXRatio        = leftMarginRatio + (rightMarginRatio - leftMarginRatio) * (endNote.EndX / (trackCount - 1));

            var perc    = (now - startNote.HitTime) / (endNote.HitTime - startNote.HitTime);
            var x1Ratio = MathHelperEx.Lerp(startXRatio, endXRatio, perc);

            var x1 = animationMetrics.Width * x1Ratio;
            var y1 = animationMetrics.Bottom;
            var x2 = GetNoteX(endNote, now, noteMetrics, animationMetrics);
            var y2 = GetNoteOnStageY(t2, animationMetrics);

            // CGSS-like
            //var xm = GetNoteOnStageX(endNote.StartX, endNote.EndX, tm, animationMetrics);
            // Naive guess
            //var xm = (x1 + x2) / 2;
            var xm = MathHelperEx.Lerp(x1, x2, 0.5f);

            if (startNote.IsSlide())
            {
                if (endNote.EndX < startNote.EndX)
                {
                    xm -= animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
                }
                else if (endNote.EndX > startNote.EndX)
                {
                    xm += animationMetrics.Width * 0.02f * ((tp2.Leave - now) / (tp2.Leave - tp1.Enter));
                }
            }
            var ym = GetNoteOnStageY(tm, animationMetrics);

            var(cx1, cx2) = GetBezierFromQuadratic(x1, xm, x2);
            var(cy1, cy2) = GetBezierFromQuadratic(y1, ym, y2);
            return(new RibbonParameters(x1, y1, cx1, cy1, cx2, cy2, x2, y2));
        }
コード例 #24
0
        protected override void OnDraw(GameTime gameTime, RenderContext context)
        {
            base.OnDraw(gameTime, context);

            if (_score == null)
            {
                return;
            }

            var notes       = _score.Notes;
            var theaterDays = Game.AsTheaterDays();

            var syncTimer = theaterDays.FindSingleElement <SyncTimer>();

            if (syncTimer == null)
            {
                return;
            }

            var tapPoints = theaterDays.FindSingleElement <TapPoints>();

            if (tapPoints == null)
            {
                throw new InvalidOperationException();
            }

            var notesLayer = theaterDays.FindSingleElement <NotesLayer>();

            if (notesLayer == null)
            {
                throw new InvalidOperationException();
            }

            var gamingArea = theaterDays.FindSingleElement <GamingArea>();

            if (gamingArea == null)
            {
                throw new InvalidOperationException();
            }

            var settings         = Program.Settings;
            var now              = syncTimer.CurrentTime.TotalSeconds;
            var tapPointsLayout  = settings.UI.TapPoints.Layout;
            var notesLayerLayout = settings.UI.NotesLayer.Layout;
            var clientSize       = context.ClientSize;

            var traceCalculator = notesLayer.TraceCalculator;

            var animationMetrics = new NoteAnimationMetrics {
                GlobalSpeedScale = notesLayer.GlobalSpeedScale,
                Width            = clientSize.Width,
                Height           = clientSize.Height,
                Top              = notesLayerLayout.Y.IsPercentage ? notesLayerLayout.Y.Value * clientSize.Height : notesLayerLayout.Y.Value,
                Bottom           = tapPointsLayout.Y.IsPercentage ? tapPointsLayout.Y.Value * clientSize.Height : tapPointsLayout.Y.Value,
                NoteStartXRatios = tapPoints.StartXRatios,
                NoteEndXRatios   = tapPoints.EndXRatios,
                TrackCount       = tapPoints.EndXRatios.Length
            };

            var topYRatio    = _ribbonTopYRatio;
            var bottomYRatio = _ribbonBottomYRatio;

            _textureEffect.CurrentTime = (float)now;

            // Enable depth buffer to allow drawing in layers.
            // However the depth comparison always passes, and Z always decreases (see below), so the results looks like
            // "later-drawn-on-top" inside this visual element.
            // We are using Begin3DFast() here, so the states are specified in effect file (simple_texture.fx). Please
            // open that file to see which settings we are selecting.
            context.Begin3DFast(_posTexLayout, PrimitiveTopology.TriangleList);

            // Z value should be decreasing to achieve this effect:
            // when two ribbons cross, the one with the start note on the right is above the other.
            var z = 0f;

            var smallNoteMetrics = new NoteMetrics {
                StartRadius = gamingArea.ScaleResults.VisualNoteSmall.Start,
                EndRadius   = gamingArea.ScaleResults.VisualNoteSmall.End
            };
            var largeNoteMetrics = new NoteMetrics {
                StartRadius = gamingArea.ScaleResults.VisualNoteLarge.Start,
                EndRadius   = gamingArea.ScaleResults.VisualNoteLarge.End
            };

            foreach (var note in notes)
            {
                OnStageStatus thisStatus, nextStatus;
                RuntimeNote   nextNote;
                NoteMetrics   visualNoteMetrics;

                if (note.HasNextHold())
                {
                    thisStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);

                    if (thisStatus == OnStageStatus.Incoming)
                    {
                        continue;
                    }

                    nextNote   = note.NextHold;
                    nextStatus = NoteAnimationHelper.GetOnStageStatusOf(nextNote, now, animationMetrics);

                    if ((int)thisStatus * (int)nextStatus > 0)
                    {
                        continue;
                    }

                    var firstHoldInGroup = note;
                    while (firstHoldInGroup.HasPrevHold())
                    {
                        firstHoldInGroup = firstHoldInGroup.PrevHold;
                    }
                    visualNoteMetrics = firstHoldInGroup.IsFlick() || firstHoldInGroup.Size == NoteSize.Large ? largeNoteMetrics : smallNoteMetrics;

                    var ribbonParams = traceCalculator.GetHoldRibbonParameters(note, nextNote, now, visualNoteMetrics, animationMetrics);

                    if (ribbonParams.Visible)
                    {
                        using (var mesh = new RibbonMesh(context.Direct3DDevice, SliceCount, topYRatio, bottomYRatio, z, new[] { ribbonParams }, traceCalculator, now, new[] { (note, note.NextHold) }, visualNoteMetrics, animationMetrics)) {
コード例 #25
0
        public override float GetNoteX(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
        {
            var trackCount          = animationMetrics.TrackCount;
            var endLeftMarginRatio  = animationMetrics.NoteEndXRatios[0];
            var endRightMarginRatio = animationMetrics.NoteEndXRatios[trackCount - 1];

            var endXRatio = endLeftMarginRatio + (endRightMarginRatio - endLeftMarginRatio) * (note.EndX / (trackCount - 1));

            var   onStage = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);
            float xRatio;

            switch (onStage)
            {
            case OnStageStatus.Incoming:
                if (note.HasPrevHold())
                {
                    xRatio = GetIncomingNoteXRatio(note.PrevHold, note, now, animationMetrics);
                }
                else if (note.HasPrevSlide())
                {
                    xRatio = GetIncomingNoteXRatio(note.PrevSlide, note, now, animationMetrics);
                }
                else
                {
                    xRatio = endXRatio;
                }
                break;

            case OnStageStatus.Passed:
                if (note.HasNextSlide())
                {
                    var destXRatio = endLeftMarginRatio + (endRightMarginRatio - endLeftMarginRatio) * (note.NextSlide.EndX / (trackCount - 1));
                    var nextPerc   = (now - note.HitTime) / (note.NextSlide.HitTime - note.HitTime);
                    xRatio = MathHelperEx.Lerp(endXRatio, destXRatio, nextPerc);
                }
                else
                {
                    xRatio = endXRatio;
                }
                break;

            default:
                var startLeftMarginRatio  = animationMetrics.NoteStartXRatios[0];
                var startRightMarginRatio = animationMetrics.NoteStartXRatios[trackCount - 1];

                float whichStartToTake;
                if (note.IsSlide())
                {
                    whichStartToTake = note.EndX;
                }
                else
                {
                    if (note.StartX < 0)
                    {
                        whichStartToTake = note.StartX * 0.5f;
                    }
                    else if (note.StartX > trackCount - 1)
                    {
                        whichStartToTake = (trackCount - 1) + (note.StartX - (trackCount - 1)) * 0.5f;
                    }
                    else
                    {
                        whichStartToTake = note.StartX;
                    }
                }

                var startXRatio = startLeftMarginRatio + (startRightMarginRatio - startLeftMarginRatio) * (whichStartToTake / (trackCount - 1));

                var timePoints = NoteAnimationHelper.CalculateNoteTimePoints(note, animationMetrics);
                var perc       = (now - timePoints.Enter) / timePoints.Duration;

                xRatio = MathHelperEx.Lerp(startXRatio, endXRatio, perc);
                break;
            }

            return(animationMetrics.Width * xRatio);
        }
コード例 #26
0
 public abstract SizeF GetSpecialNoteRadius(RuntimeNote note, double now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics);
コード例 #27
0
ファイル: RibbonsLayer.cs プロジェクト: KinoMyu/MilliSim
        protected override void OnDraw(GameTime gameTime)
        {
            base.OnDraw(gameTime);

            var theaterDays = Game.ToBaseGame();
            var scoreLoader = theaterDays.FindSingleElement <ScoreLoader>();

            var score = scoreLoader?.RuntimeScore;

            if (score == null)
            {
                return;
            }

            var notes = score.Notes;

            var syncTimer = theaterDays.FindSingleElement <SyncTimer>();

            if (syncTimer == null)
            {
                return;
            }

            var tapPoints = theaterDays.FindSingleElement <TapPoints>();

            if (tapPoints == null)
            {
                throw new InvalidOperationException();
            }

            var notesLayer = theaterDays.FindSingleElement <NotesLayer>();

            if (notesLayer == null)
            {
                throw new InvalidOperationException();
            }

            var scalingResponder = theaterDays.FindSingleElement <MltdStageScalingResponder>();

            if (scalingResponder == null)
            {
                throw new InvalidOperationException();
            }

            var now = (float)syncTimer.CurrentTime.TotalSeconds;

            var tapPointsConfig  = ConfigurationStore.Get <TapPointsConfig>();
            var notesLayerConfig = ConfigurationStore.Get <NotesLayerConfig>();
            var tapPointsLayout  = tapPointsConfig.Data.Layout;
            var notesLayerLayout = notesLayerConfig.Data.Layout;
            var clientSize       = theaterDays.GraphicsDevice.Viewport;

            var traceCalculator = notesLayer.AnimationCalculator;

            var animationMetrics = new NoteAnimationMetrics {
                GlobalSpeedScale = notesLayer.GlobalSpeedScale,
                Width            = clientSize.Width,
                Height           = clientSize.Height,
                Top              = notesLayerLayout.Y.IsPercentage ? notesLayerLayout.Y.Value * clientSize.Height : notesLayerLayout.Y.Value,
                Bottom           = tapPointsLayout.Y.IsPercentage ? tapPointsLayout.Y.Value * clientSize.Height : tapPointsLayout.Y.Value,
                NoteStartXRatios = tapPoints.StartXRatios,
                NoteEndXRatios   = tapPoints.EndXRatios,
                TrackCount       = tapPoints.EndXRatios.Length
            };

            var topYRatio    = _ribbonTopYRatio;
            var bottomYRatio = _ribbonBottomYRatio;

            var ribbonEffect = theaterDays.EffectManager.Get <RibbonEffect>();

            ribbonEffect.CurrentTime = now;

            var graphics = theaterDays.GraphicsDevice;

            // Enable depth buffer to allow drawing in layers.
            // However the depth comparison always passes, and Z always decreases (see below), so the results looks like
            // "later-drawn-on-top" inside this visual element.
            // We are using Begin3DFast() here, so the states are specified in effect file (simple_texture.fx). Please
            // open that file to see which settings we are selecting.

            // Z value should be decreasing to achieve this effect:
            // when two ribbons cross, the one with the start note on the right is above the other.
            var z = ZTop;

            var smallNoteMetrics = new NoteMetrics {
                StartRadius = scalingResponder.ScaleResults.VisualNoteSmall.Start,
                EndRadius   = scalingResponder.ScaleResults.VisualNoteSmall.End
            };
            var largeNoteMetrics = new NoteMetrics {
                StartRadius = scalingResponder.ScaleResults.VisualNoteLarge.Start,
                EndRadius   = scalingResponder.ScaleResults.VisualNoteLarge.End
            };

            var viewProjection = _viewMatrix * _projectionMatrix;

            foreach (var note in notes)
            {
                OnStageStatus          thisStatus, nextStatus;
                RuntimeNote            nextNote;
                NoteMetrics            visualNoteMetrics;
                RibbonMeshCreateParams rmcp;

                if (note.HasNextHold())
                {
                    thisStatus = NoteAnimationHelper.GetOnStageStatusOf(note, now, animationMetrics);

                    if (thisStatus == OnStageStatus.Incoming)
                    {
                        continue;
                    }

                    nextNote   = note.NextHold;
                    nextStatus = NoteAnimationHelper.GetOnStageStatusOf(nextNote, now, animationMetrics);

                    if (AreTwoNotesOnTheSameSide(thisStatus, nextStatus))
                    {
                        continue;
                    }

                    var firstHoldInGroup = note;
                    while (firstHoldInGroup.HasPrevHold())
                    {
                        firstHoldInGroup = firstHoldInGroup.PrevHold;
                    }
                    visualNoteMetrics = firstHoldInGroup.IsFlick() || firstHoldInGroup.Size == NoteSize.Large ? largeNoteMetrics : smallNoteMetrics;

                    var ribbonParams = traceCalculator.GetHoldRibbonParameters(note, nextNote, now, visualNoteMetrics, animationMetrics);

                    if (ribbonParams.Visible)
                    {
                        rmcp = new RibbonMeshCreateParams(graphics, SliceCount, topYRatio, bottomYRatio, z, LayerDepth, new[] { ribbonParams }, traceCalculator, now, new[] { (note, note.NextHold) }, visualNoteMetrics, animationMetrics);
コード例 #28
0
 public override Vector2 GetNoteRadius(RuntimeNote note, float now, NoteMetrics noteMetrics, NoteAnimationMetrics animationMetrics)
 {
     return(noteMetrics.EndRadius);
 }