• Advertisement
Sign in to follow this  

Animation timing. (SharpDX)

This topic is 1272 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Ok, I am doing a project using SharpDX that has evolved over time from XNA, to SlimDX and now SharpDX. For my FPS counter, I have been using the System.DateTime.Now.Ticks property to get a measure of time passed. I can't remember when I first implemented my FPS counter, but it always seemed to work. When performance was low I got low numbers and when performance was high I got high numbers.

 

Recently I have been trying to use the same mechanism to do some color animation, and it is painfully obvious that the System.DateTime class updates itself in a very sporadic way that is not suitable for animation. For example, it seems to give accurate measures of time, but frequently stops for half seconds at a time, more or less.

 

Where can I get a better measure of time so I can do animations and other camera control movements that are de-coupled from my framerate?

Share this post


Link to post
Share on other sites
Advertisement

unbird to the rescue! Thanks.

 

Works perfectly! Wow, just by fixing this I got a massive FPS boost as well! I... guess I wasn't measuring it properly.

Edited by cephalo

Share this post


Link to post
Share on other sites

Just incase someone has the same difficulties I've encountered - I've used several other Timers including Systems.Threading.Timer - but all of them were executed in a seprate Thread and led to an Thread access violation when for example changing the WinForm-Size out of the Timer-Event (yea I know I should do that in my Main-Render). I'm using System.Windows.Forms.Timer and it works flawlessly for me as it get 's the correct Thread Reference to the WinForm.

 

It 's in german but here 's a Wrapper-Class using System.Windows.Forms.Timer and QueryPerformanceCounter/Frequency (Post #4)

including some additional info (if you can read german or am able to use Google Translate):

 

http://www.mycsharp.de/wbb2/thread.php?postid=3635578

 

Cheers!

 

Edit:

 

Just in case I've translated the class from Peter Bucher in English for non-native German speakers. All credits go to him!

Excuse me if it isn't 100% accurate, I've translated it quick n' dirty and removed 1-2 comments as I didn't found them usefull/obsolete! smile.png

using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;

namespace SharpKrush.Misc
{
    /// <summary>
    /// Returns the FPS value, which is been updated at an interval/tick
    /// </summary>
    public class FrameCounter
    {
        [DllImport("kernel32.dll")]
        private static extern bool QueryPerformanceCounter(out long lpPerformanceCount);

        [DllImport("kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(out long frequency);

        private System.Windows.Forms.Timer _timer;
        private float _fps;  
        private float _avgFps;
        private float _minFps;
        private float _maxFps;

        private float _sum;
        private float _sumCount;

        private float _actFps; // current FPS (after Render Timing)
        private long _lastFrame;
        private long _freq;
        private long _currentFrame;
        private int _interval;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="interval">Interval of the FPS-Update in Milliseconds</param>
        public FrameCounter(int interval) {
            this._sum = 0f;
            this._sumCount = 0f;

            // Min- and Max-FPS values
            this._minFps = 999; 
            this._maxFps = 0;

            this._timer = new System.Windows.Forms.Timer();
            this._timer.Start();
            this._timer.Tick += new EventHandler(this.OnTick);
            this._timer.Interval = interval;
        }

        /// <summary>
        /// Returns the FPS-Value
        /// </summary>
        public float Fps {
            get { return this._fps; }
        }

        /// <summary>
        /// Returns the Average FPS
        /// </summary>
        public float AvgFps {
            get { return this._avgFps; }
        }

        /// <summary>
        /// Returns the Lowest FPS
        /// </summary>
        public float MinFps {
            get { return this._minFps; }
        }

        /// <summary>
        /// Returns the Biggest / Maximum FPS
        /// </summary>
        public float MaxFps {
            get { return this._maxFps; }
        }

        /// <summary>
        /// FPS-Update-Interval in MS
        /// </summary>
        public int Interval {
            set { this._interval = value; }
        }

        /// <summary>
        /// Start the timing
        /// </summary>
        public void Begin() {
            QueryPerformanceFrequency(out this._freq);
            QueryPerformanceCounter(out this._lastFrame);
        }

        /// <summary>
        /// Calculates the current FPS after Rendering
        /// </summary>
        public void End() {
            QueryPerformanceCounter(out this._currentFrame);
            this._actFps = this._freq / (this._currentFrame - this._lastFrame);

            // Check if FPS is lower then previous Minimum-FPS
            if (this._actFps < this._minFps) {
                this._minFps = this._actFps;
            }

            // Check if FPS is bigger then previous Maximum-FPS
            if (this._actFps > this._maxFps) {
                this._maxFps = this._actFps;
            }
        }

        /// <summary>
        /// Generates the Average FPS
        /// </summary>
        private void CalculateAvgFps() {
            if (this._sumCount <= 600) {
                this._sum += this._fps;
                this._sumCount++;

                this._avgFps = this._sum / this._sumCount;
            } else {
                this._sum = 0;
                this._avgFps = 60;
            }
        }

        /// <summary>
        /// After each Timer-Interval the FPS-Value will be generated here
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnTick(object sender, EventArgs e) {
            this._fps = this._actFps;
            this.CalculateAvgFps();
        }
    }
}
Edited by justyourimage

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement