Adding to arrays C++

Question

just wondering how I would go about adding ints to an array in the following way;

I am getting average framerate for my game, but from what I understand if I create an int array of [10], I have no native way of just adding a number to the start of the array.

I want to do this.

myInt[0] = 60
myInt[1] = 59
myInt[2] = 61

I want to add, say, 30, to myInt[0], and have it move the current myInt[0] to [1] and [1] to [2], so it just moves everything along one and drops the last integer from the array.

What I've tried to do so far just changes [0], making my average calculations useless. Also, I'm using SDL_GetTicks() to snag the current elapsed time.

Is there a better way to do average framerate?

Answer 1

sounds like you want a circular queue. I would investigate the operator "%" with a frame counter. Your frame counter always goes up, you update myInt[frame_counter % MY_INT_LENGTH], then map reduce myInt and divide by MY_INT_LENGTH.

I would suggest storing the last 8 or 16 frame rates instead of 10. This makes the mod operator a bit mask.

EDIT

If you want an average frame rate what you should really do is check delta_frames / delta_time

In your render thread or an observer increment a counter each frame render. then ask how many frames and divide by the time difference. You can poll the average frame rate asynchronously and reset the frame counter on poll.

Answer 2

std::vector is what you should be using instead of arrays, although std::queue in this case.

Quick/messy code showing how that would work:

int sum = 0; // should be wrapped in a class or something
const int max_size = 10;

void add(std::queue<int>& q, int fps) {
  q.push(fps);
  if(q.size() > max_size) {
    sum -= q.front();
    q.pop();
  }
  sum += fps;
}

int avg(std::queue<int>& q) {
  return sum / q.size();
}

//...

std::queue<int> myQ;
add(myQ, 60);
add(myQ, 61);
add(myQ, 50);
std::cout << avg(myQ);

You should be able to see the method as you seem to understand it in your original code.

Answer 3

Is there a better way to do average framerate?

Why yes....

Here is some code that I have used before to keep track of "frame rate" for a video rendering application. It was written for a Windows app. If you aren't using Windows, then replace all the "DWORD" types below with "unsigned int". And replace the GetTickCount call with SDL_getticks() function. It's pretty straightforward. Call OnFrame every time you render a new frame. Call GetFrameRate whenever you want to know it.

class CFrameRateMonitor
{
private:
    static const DWORD DEFAULT_INTERVAL = 2000;
    bool m_fFirstFrame;
    DWORD m_dwInterval;  // how often we recompute the average
    DWORD m_dwFrames;
    DWORD m_dwStartTime;
    DWORD m_dwComputedRate;
public:
    CFrameRateMonitor();

    void Reset();
    void OnFrame();
    DWORD GetFrameRate();
    void SetInterval(DWORD dwInterval);
};



CFrameRateMonitor::CFrameRateMonitor()
{
    Reset();
    m_dwInterval = DEFAULT_INTERVAL;
}

void CFrameRateMonitor::SetInterval(DWORD dwInterval)
{
    m_dwInterval = dwInterval;
}

void CFrameRateMonitor::Reset()
{
    m_dwFrames = 0;
    m_dwStartTime = 0;
    m_dwComputedRate = 0;
    m_fFirstFrame = true;
}

DWORD CFrameRateMonitor::GetFrameRate()
{
    return m_dwComputedRate;
}

void CFrameRateMonitor::OnFrame()
{
    DWORD dwCurrentTime = GetTickCount();
    DWORD dwActualInterval = dwCurrentTime - m_dwStartTime;

    if (m_fFirstFrame)
    {
        m_dwStartTime = dwCurrentTime;
        m_fFirstFrame = false;
    }
    else
    {
        m_dwFrames++;
        if (dwActualInterval >= m_dwInterval)
        {
            // enough time has passed to compute a new interval
            // + 500 to "round up"
            m_dwComputedRate = (m_dwFrames * 1000 + 500) / dwActualInterval; 
            // reset counting
            m_dwStartTime = dwCurrentTime;
            m_dwFrames = 0;
        }
    }
}