Well for one it looks to be deprecated for `CreateTimerQueueTimer`. In either case, you don't need a window message loop (`GetMessage` / `PeekMessage`) to use it which might be useful for some applications, as it uses it's own thread, which can also be useful over some other constructs (the main thread can be busy/blocked) but does mean dealing with all the multi-thread safety stuff.

While any message based timer executes in the message pump/window thread synchronously, which avoids multi-threading, but if your event was say some network stuff that takes 5 seconds, the window is “locked up” during that time (although you could of course then spawn a thread explicitly, or use events to get async behaviour).

Games and applications probably have a window message loop to use and in most cases would be desirable to use the same thread as the window. For example if any other windows are to be created/destroyed/updated, redrawn, etc.

In the case of games specifically, you are probably looping constantly anyway, and games don't generally worry about a very low idle CPU (if every say browser tab or other application used say 1% CPU just to exist looping around, that would be a problem). In that case a lot of timing is just done by the “game loop”. This could be in many forms, depending on if you have fixed or variable step update, if the thing you are using a fixed step, is it one frame per step (e.g. 30 or 60fps animation) or less than that (e.g. 10fps animation, but 60Hz loop).

I am glad to share how I perform timing on my 2d game engine, here is what the main loop, looks like,

 case WM_PAINT: // Paint the game
        {
            hdc = BeginPaint(hWnd,&ps);

            dw_timestart = timeGetTime(); // start timing

            ProcessInput(); // any key input
            UpdateObjects(); // update game objects
            RenderFrame(); // paint game

            dw_timestop = timeGetTime(); // stop timing

            EndPaint(hWnd,&ps);

            // store elapsed game cycle
            f_cycle_t = dw_timestop - dw_timestart;

            break;
        }

You can also the C++ timer functions which, is more portable, I'll be doing that eventually.

This is how this works,

1. dw_timestart stores the current timer

2. the game engine then does some work gets input, updates logic for objects and then renders a frame, this is called a cycle.

3. we record the time the game cycle finished.

4. the we store the elapsed time in “f_cycle_t" this is your “delta time”

You animate your sprite using the delta timer this way.

void PLAYER2D::moveleft(vector<SPRITE2D>&v_mgsprites)
// Moves the player sprite left
{
    // avoid out of bound error
    if(p_sprite->getx() < 0) return;

    // try to move the sprite
    if(p_sprite->moveleft(f_velocity*f_cycle_t,v_mgsprites))
        i_state = GE_LEFT; // update state
}

f_velocity is how fast you want your sprite to move … say .50 or something and then you multiply it by the delta timer.

Of course in your main game loop you want to run a check to monitor the delta timer because if the timer starts to increase too high, it's going to break your game, sprites will go through walls and collision system will break, so if the timer gets too high, you need to lock at it at its maximum setting and start dropping frames instead. I don't have this check currently active on the example I gave but it is something you can focus on later when your game becomes so saturated that you need to start monitoring it.

You will also deal with acceleration which, requires a different algorithm, for example, here is my jump algorithm for the player sprite.

if(b_isjumping) // Jump algorithm
    {
        i_state = GE_JUMPING; // update state

        if(b_havelink) // if we have a link
        {
            // unlink from the parent sprite
            v_mgsprites[p_sprite->getparent()].unlink(p_sprite->getid());
            b_havelink = false;
        }

        f_jmpfactor -= 0.0035 * f_cycle_t / 2; // slow down as we go up

        // move the sprite up
        if(!p_sprite->moveup(f_jmpfactor*f_cycle_t,v_mgsprites) || f_jmpfactor < 0)
        {
            // if we hit something or the jump completes
            f_jmpfactor = ct_JMPFACTOR; // reset jump factor
            f_gravity = 0; // kill the gravity
            b_isfalling = true; // now falling
            b_isjumping = false; // not jumping
        }
    }

If you're doing acceleration and animating, you have to provide the acceleration rate 0.0035 on the example above and then multiply by the delta timer and divided it by two … you then animate the sprite using that calculation by the delta timer again … failure to do this will result in different jump heights under different game loads. It took me months to figure this stuff out but happy to share it.

Feel free to ask questions, my way may not be the best way, so others may have better ways to do it.

Airbatz said:

Again, thank you for sharing your work here and taking the time to explain it! I tend to learn by taking apart working examples rather than from scratch, so this is really helpful. My program actually has very little user input required, with only a few click actions on windows. Sprite animation/movement is just there for decorative purposes as the program is a demo/intro and not a game.

Do you only have one timer for the whole thing, or seperate ones for different events? I ask because I need to spawn several instances of the same sprite, but with some having different speeds. With my current timing method, I will probably need to use several SetTimer() calls. I should also ask - What is the best/simplest way to blit multiple instances of a sprite to the screen?

The technique is the same, to make sure you get sprite animation timed correctly, just measure the length of each cycle and that is your delta time. The speed of your sprite is then multiplied by the delta time. Even if it is not a game, you should strive to standardize a practice in place to get consistent results. Burn this into your brain, make functions or classes that you can re-use in other programs.

The problem with SetTimer() for sprite animation is that it will not be accurate for animations and it will flood your Window procedure the more frequent it is. That is how I tried it first and it never worked right.

DWORD dw_timestart;
DWORD dw_timestop;
float f_cycle_t;

float sprite_speed = 0.50;
float sprite_x_position = 0;

dw_timestart = timeGetTime(); // start timing

// your program does all work even non-sprite related work here

dw_timestop = timeGetTime(); // stop timing

f_cycle_t = dw_timestop - dw_timestart; // delta time

// move the sprite
sprite_x_position = sprite_x_position + (sprite_speed * f_cycle_t);

every sprite has an x position … so if you have multiple sprites … to move all of them at different speeds you simply set different sprite speeds for each sprite but you always multiply that speed by the delta time … you see why this is better? Using multiple timers will break your animation as the message might get lost in the message loop. In your message loop to constantly force a redraw when your windows is in focus use, do this,

    // Run the message loop
    while(GetMessage(&msg,NULL,0,0))
    {
        // process messages
        TranslateMessage(&msg);
        DispatchMessage(&msg);

        // always force a redraw for the game loop
        if(GetFocus()==hWnd)InvalidateRect(hWnd,NULL,false);
    }

you could use peek but this is simpler, this is message loop on my 2d game

The only timer in my program is,

f_cycle_t = dw_timestop - dw_timestart; // delta time

The only place I use SetTimer() is in the sound engine which is pretty ridiculously simple, here is the entire program using SetTimer()

#include <tchar.h>
#include <windows.h>
#include <mmsystem.h>
#include <fstream>
#include <vector>
#include <string>

#include "resource.h"

/*
       _____                       _____       __
      / ___/____  __  ______  ____/ /__ \ ____/ /
      \__ \/ __ \/ / / / __ \/ __  /__/ // __  /
     ___/ / /_/ / /_/ / / / / /_/ // __// /_/ /
    /____/\____/\__,_/_/ /_/\__,_//____/\__,_/ (tm)

    Sound2d Interface for ChaosEffex 2d Game engine.
    Copyright (c) 2019 Rafael Perez-Santana
    Contact; misterfaosfx@gmail.com

    This application is launched as a separate process by ChaosEffex to allow mixing
    audio playback with PlaySound() the theory is that every instance of this application
    acts as an audio layer, to allow play multiple sounds with out stopping the others.

    A one minute timer ensures that no running copies of Sound2d are left running if the
    game engine quits/crashes for any reason. We do this by looking for the window every
    minute and terminating this application if we do not find it!

    The features; waveOutPause() &amp;amp;amp; waveOutRestart() do not seem to work.
*/

using namespace std;

// for sound system
#define sound2d_play 1100
#define sound2d_stop 1101
#define sound2d_volume 1102
#define sound2d_pause 1103
#define sound2d_resume 1104

#define TIMER1 1001 // timer identifier

vector<string>v_sg_sound_data; // sound index
string sg_filename; // file to open for sounds

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
TCHAR szClassName[ ] = _T("sound2d1");

int WINAPI WinMain // main entry point
(HINSTANCE hThisInstance,HINSTANCE hPrevInstance,LPSTR lpszArgument,int nCmdShow)
{
    HWND hWnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon(hThisInstance,MAKEINTRESOURCE(APP_ICON));
    wincl.hIconSm = LoadIcon(hThisInstance,MAKEINTRESOURCE(APP_ICON));
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */

    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&amp;amp;amp;wincl)) return 0;

    sg_filename = lpszArgument; // copy the argument value

    /* The class is registered, let's create the program*/
    hWnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           lpszArgument,        /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           100,100,             /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    if(!sg_filename.size())
    {
        /*  If the size of sg_filename is 0 then no argument was specified. The
            argument is the name used to set the window title so that we can find it.
            It also is an alias to the file that contains the list of sounds to play,
            so with out the argument we cannot continue. */

        MessageBox(hWnd,"No argument specified. Terminating.","Error",MB_ICONERROR);

        return 0; // cannot continue
    }

    /* Make the window visible on the screen */
    ShowWindow (hWnd,nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&amp;amp;amp;messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&amp;amp;amp;messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&amp;amp;amp;messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */
LRESULT CALLBACK WindowProcedure (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_CREATE:
        {
            // temp variables
            string sg_lineoftext; // buffer
            ifstream ssg_inputfile; // to read from file

            ssg_inputfile.open(".\\" + sg_filename + ".txt"); // open file for input

            // read in lines of text until we reach the end
            while(getline(ssg_inputfile,sg_lineoftext))v_sg_sound_data.push_back(sg_lineoftext);

            ssg_inputfile.close(); // close the file

            // set default volume
            waveOutSetVolume(NULL,(32767 << 0) + (32767 << 16));

            // create a 1 minute timer
            SetTimer(hWnd,TIMER1,60000,(TIMERPROC)NULL);

            break;
        }

        case WM_TIMER:
        {
            /*  This application is launched as a separate process by the ChaosEffex game
                engine. Every 1 minutes, we try to find the game engine window to see if it is
                active, if it is not, we terminate the sound system. This is done to make sure
                we don't end up with running copies of Sound2d shall the game engine crash
                for any reason. */

            if(wParam==TIMER1)
                // look for ChaosEffex, if we don't find it, quit.
                if(FindWindow("ChaosEffex",NULL)==NULL) PostQuitMessage(0);

            break;
        }

        case sound2d_pause: // pauses sound playback
        {
            waveOutPause(NULL);

            break;
        }

        case sound2d_resume: // resumes sound playback
        {
            waveOutRestart(NULL);

            break;
        }

        case sound2d_stop:
        {
            PlaySound(NULL,0,0); // stop play back of any sound

            break;
        }

        case sound2d_volume: // sets the volume
        {
            /// wParam = new volume
            /// lParam = ignored.

            waveOutSetVolume(NULL,(wParam << 0) + (wParam << 16));

            break;
        }

        case sound2d_play: // play a sound
        {
            /// wParam = sound index to play
            /// lParam = 0 not looped, 1 looped

            if(lParam==0)
            {
                // play a sound only once
                PlaySound(v_sg_sound_data[wParam].c_str(),NULL,SND_FILENAME|SND_ASYNC|SND_NOSTOP);
            }
            else if(lParam==1)
            {
                // play a sound looped
                PlaySound(v_sg_sound_data[wParam].c_str(),NULL,SND_FILENAME|SND_LOOP|SND_ASYNC);
            }

            break;
        }

        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;

        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hWnd, message, wParam, lParam);
    }

    return 0;
}

Have fun!

As for Blitting multiple instance of your sprite in the application window … use classes, I want to burn this in your head..if you had a sprite class like this

class spriteobject
{
   public:
   void move_x();
   void setspeed(float f_val) { f_speed = f_val; }
   void drawsprite();
   
   private:
   float f_x_position;
   float f_speed = 0.50; // default speed   
};

// to use multiple instances of the same object create them!
spriteobject sprite1;
spriteobject sprite2;
spriteobject sprite3;
spriteobject sprite4;

// set speeds!
sprite1.setspeed(.15);
sprite2.setspeed(1);
sprite3.setspeed(2);
sprite4.setspeed(.50);

// move all the sprites!
sprite1.move_x();
sprite2.move_x();
sprite3.move_x();
sprite4.move_x();

// then draw them in new positions!
sprite1.drawsprite();
sprite2.drawsprite();
sprite3.drawsprite();
sprite4.drawsprite();

// you can also use the c++ vector
vector<spriteobject> v_mysprites(4);

// now you can do this
v_mysprites[2].setspeed(.50);

// instead of calling each one, cycle through them in a for loop
for (unsigned int i = 0; i < v_mysprites.size(); i++)
{
	v_mysprites[i].move_x();
	v_mysprites[i].drawsprite();
}

Lean how to model your information in classes, it is sooo much easier.

Best;

Rafael

@Airbatz Yes you are doing it correctly! I had no idea you were working with just C I must have totally over looked that, so you're approach must be more linear as opposed to object oriented if you're using just C. It just means you'll have wayyy more functions to do certain tasks … C++ simply takes that approach and encapsulates the functions into a specific object along with some extra features.

No matter how many sprites you add now, the delta time will increase ever so slightly to keep your animation constant.

The secret to awesome performance with the Windows GDI and graphics is to use something I refer to as Quantum Indexing … if you had a 2d map with 50,000 sprites on it, you would have to cycle through all 50,000 sprites to see whether or not they were in the viewport to draw them … if you use a tile map however, you can perform a quantum leap via a co-ordinate reference.

int TILEGRID2D::getspriteindex(int i_xpos, int i_ypos)
// Gets a sprite index via the x and y, I call it; QuantumIndexing™
{
    // correct out of bound errors
    if(i_xpos < 0) i_xpos = 0; if(i_ypos < 0) i_ypos = 0;

    // does a quantum leap and directly gets the index associated
    // with the sprite located at the specified x and y co-ordinates!
    return (int)((i_ypos - i_offset_y) / 100) * i_gridwidth + (int)((i_xpos - i_offset_x) / 100);
}

So all I do is get the position of the player sprite and use that formula to find where on the tile map it is located, then a special function takes over and draws the contents of the tile map at that location,

void TILEGRID2D::drawspritegrid(HDC hdc_surface,float f_xpos, float f_ypos, int i_width, int i_height,bool b_padding)
// draws a grid of sprites at the specified x and y within the confines of width and height.
{
    // grid padding, for left and right sides.
    int i_padding = 2; if(!b_padding) i_padding = 0;

    // how many tiles are required?
    int i_x_total = (i_width / ge_tilewidth) + i_padding;
    int i_y_total = (i_height / ge_tileheight) + i_padding;

    int i_column = 0, i_row = 0; // to cycle through loop

    /// draw grid : experiment
    for(int i = getspriteindex(f_xpos,f_ypos); i_row != i_y_total; i++)
    {
        // check to see if out of bounds
        if(i >= i_gridwidth * i_gridheight) return;

        drawsprite(hdc_surface,i); // draw the sprite

        i_column++;

        if(i_column == i_x_total) { i =  i + (i_gridwidth - i_x_total); i_column = 0; i_row++; }
    }
}

drawspritegrid() is used by the viewport class to render all the different layers, this is where all the magic happens!

void VIEWPORT2D::render(int x,int y,int t,BITMAP2D&background,
BACKBUFFER2D&amp;backbuffer,DEVMODE2D&amp;devmode,vector<TILEGRID2D>&amp;v_tilegrid,vector<SPRITE2D>&amp;v_objects)
// The viewport function renders the game at the specified x and y co-ordinates using 't' to track a target sprite
// from the object sprite layer. It uses the specified backbuffer &amp; sprite vectors to render to the viewport.
{
    if(!devmode.getmode()) // if developer mode is off
    {
        // track the target sprite
        if(v_objects[t].getx() >= i_width/2)f_xbbIndex=v_objects[t].getx()+ge_tilewidth-i_width/2;
        if(v_objects[t].getx() <= i_width/2)f_xbbIndex=v_objects[t].getx()+ge_tilewidth-i_width/2;
        if(v_objects[t].gety() >= i_height/2)f_ybbIndex=v_objects[t].gety()-i_height/2;
        if(v_objects[t].gety() <= i_height/2)f_ybbIndex=v_objects[t].gety()-i_height/2;
    }

    // only render when the developer bitmap tile selector is off
    if((devmode.getmode() &amp;&amp; !devmode.tileselectorstatus()) || !devmode.getmode())
    {
        // stay within bounds of back buffer dimensions
        if(f_xbbIndex < 0) f_xbbIndex = 0; if(f_ybbIndex < 0) f_ybbIndex=0;
        if(f_xbbIndex+i_width > backbuffer.getwidth()) f_xbbIndex=backbuffer.getwidth()-i_width;
        if(f_ybbIndex+i_height > backbuffer.getheight()) f_ybbIndex=backbuffer.getheight()-i_height;

        // draw the tiles directly to the background surface.
        v_tilegrid[tB].drawspritegrid(background.getsurface(),f_xbbIndex,f_ybbIndex,i_width,i_height,true);

        // paint the background to the back buffer.
        background.paintbk(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,
                           f_xbbIndex * (background.getwidth()-i_width+1) / (backbuffer.getwidth()-i_width+1),
                           f_ybbIndex * (background.getheight()-i_height+1) / (backbuffer.getheight()-i_height+1));

        // parallax algorithm for tiled background
        //f_offset_x=f_xbbIndex-(f_xbbIndex*(v_tilegrid[tB].getpixelwidth()-i_width+1)/(backbuffer.getwidth()-i_width+1));
        //f_offset_y=f_ybbIndex-(f_ybbIndex*(v_tilegrid[tB].getpixelheight()-i_height+1)/(backbuffer.getheight()-i_height+1));
        //v_tilegrid[tB].grid_offset((int)f_offset_x,(int)f_offset_y); // offset the grid

        v_tilegrid[dS].drawspritegrid(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,true); // decoraction sprites
        v_tilegrid[bS].drawspritegrid(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,true); // background sprites

        // paint object sprites, we use 'v_renderobjects'
        for(int i=0; i < (int)v_renderobjects.size(); i++) v_objects[v_renderobjects[i]].paintsprite(backbuffer.get());

        v_tilegrid[mS].drawspritegrid(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,true); // main sprite layer
        v_tilegrid[fS].drawspritegrid(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,true); // foreground sprites
    }

    devmode.render(background,backbuffer,v_tilegrid,f_xbbIndex,f_ybbIndex); // render developer interface

    if(b_blend_effect) // special blend effects, if any
    {
        // draws a translucent box over the entire viewport
        blendeffect.blendsp(backbuffer.get(),f_xbbIndex,f_ybbIndex,i_width,i_height,0,0,byte_blend_effect);

        blend_effect_timer(); // runs the timer for special effects
    }

    // cycles per second information
    TxtOut(backbuffer.get(),f_xbbIndex+140,f_ybbIndex+i_clientheight-25," "+f_tosg((int)f_cycles_sec)+" ");

    // copy the back buffer contents to the window DC ________ lotta coffee c[_]
    BitBlt(hdc,x,y,i_width,i_height,backbuffer.get(),f_xbbIndex,f_ybbIndex,SRCCOPY);

    v_renderobjects.clear(); // clean up the render list
}

I'm actually working on my 2d game engine as we speak. I'm currently drawing the grid using windows functions and it is very slow, so I want to create an asset and render a skeleton grid on it so that I only paint a portion of it when I'm in mad edit mode to improve performance … a larger blit operation is better than many smaller blit operations you just want to make sure that what ever you are blitting is what's going to be seen otherwise it is wasted work.

You are doing great, keep us updated! I don't claim to know it all but I can share from what I have learned during my 1 year of research with the windows GDI and that year was spent working on all this stuff with countless hours of slept and tons of ideas that got tested and thrown out the window … I'm constantly experimenting to see what works and what doesn't to keep everything running smoothly.

Here is a little something to get you excited!