The easiest way, is to use the GDImage WGL_CreateWindow API that is available in both 32 and 64-bit.
It takes care of all the complex PIXELFORMATDESCRIPTOR details, and moreover GDImage has advanced texture support.

Here is the GDImage code for WGL_CreateWindow

FUNCTION WGL_CreateWindow ALIAS "WGL_CreateWindow" (BYVAL dwExStyle AS DWORD, _
                                                    BYVAL dwStyle AS DWORD, _
                                                    BYVAL x AS LONG, BYVAL y AS LONG, _
                                                    BYVAL nWidth AS LONG, BYVAL nHeight AS LONG, _
                                                    BYVAL hWndParent AS DWORD, _
                                                    BYVAL CtrlID AS DWORD) EXPORT AS DWORD

    LOCAL IsInitialized, wcStyle, glDC, glRC AS LONG
    LOCAL hWnd, hTemp AS DWORD
    LOCAL wc     AS WndClassEx
    LOCAL zClass AS ASCIIZ * 16
    zClass = "GL_CHARTCTRL"

    ' Create a temporary window for initializing OpenGL context
    hTemp = CreateWindowEx(dwExStyle, $GLImageClassName, "", dwStyle, _
                           0, 0, 0, 0, hWndParent, CtrlID, zInstance(), BYVAL 0)
    IF hTemp THEN
       ' Get device context and rendering context properties from the temporary window
       glDC = ZI_GetProperty(hTemp, %ZI_GLDC)
       glRC = ZI_GetProperty(hTemp, %ZI_GLRC)

       LOCAL pfd AS PIXELFORMATDESCRIPTOR

       ' Set up the PIXELFORMATDESCRIPTOR structure
       pfd.nSize              = SIZEOF(pfd)
       pfd.nVersion           = 1
       pfd.dwFlags            = %PFD_DRAW_TO_WINDOW OR %PFD_SUPPORT_OPENGL OR %PFD_DOUBLEBUFFER OR %PFD_SUPPORT_GDI
       pfd.iPixelType         = 0 ' PFD_TYPE_RGBA
       pfd.cColorBits         = 32
       pfd.cRedBits           = 0
       pfd.cRedShift          = 0
       pfd.cGreenBits         = 0
       pfd.cGreenShift        = 0
       pfd.cBlueBits          = 0
       pfd.cBlueShift         = 0
       pfd.cAlphaBits         = 1
       pfd.cAlphaShift        = 0
       pfd.cAccumBits         = 0
       pfd.cAccumRedBits      = 0
       pfd.cAccumGreenBits    = 0
       pfd.cAccumBlueBits     = 0
       pfd.cAccumAlphaBits    = 0
       pfd.cDepthBits         = 24 ' Depth buffer
       pfd.cStencilBits       = 0
       pfd.cAuxBuffers        = 0
       pfd.iLayerType         = 0 ' %PFD_MAIN_PLANE
       pfd.bReserved          = 0
       pfd.dwLayerMask        = 0
       pfd.dwVisibleMask      = 0
       pfd.dwDamageMask       = 0

       ' Initialize multisampling
       InitMultisample(glDC, pfd)

       IF gn_arbMultisampleFormat THEN
          ' Set up the window class for the OpenGL control
          wcStyle = %CS_HREDRAW OR %CS_VREDRAW OR %CS_DBLCLKS OR %CS_OWNDC
          wc.cbSize = SIZEOF(wc)
          IsInitialized = GetClassInfoEx(zInstance(), zClass, wc)
          IF IsInitialized = 0 THEN
             wc.cbSize        = SIZEOF(wc)
             wc.style         = wcStyle
             wc.lpfnWndProc   = CODEPTR(GL_WindowProc)
             wc.cbClsExtra    = 0
             wc.cbWndExtra    = %Extend_cbWndExtra * 4
             wc.hInstance     = zInstance()
             wc.hIcon         = %NULL
             wc.hCursor       = LoadCursor(%NULL, BYVAL %IDC_ARROW)
             wc.hbrBackground = %NULL ' Don't paint the class window background
             wc.lpszMenuName  = %NULL
             wc.lpszClassName = VARPTR(zClass)
             wc.hIconSm       = %NULL
             IF RegisterClassEx(wc) THEN IsInitialized = %TRUE
          END IF

          IF IsInitialized THEN
             ' Create the OpenGL control window
             hWnd = CreateWindowEx(dwExStyle, _
                                   zClass, _         ' Make it an OpenGL control
                                   "", _             ' Currently not used
                                   dwStyle, _        ' window style
                                   x, _              ' initial x position
                                   y, _              ' initial y position
                                   nWidth, _         ' Calculate Window Width
                                   nHeight, _        ' Calculate Window Height
                                   hWndParent, _     ' parent window handle
                                   CtrlID, _         ' ControlID
                                   zInstance(), _    ' program instance handle
                                   BYVAL 0)          ' creation parameters
             IF hWnd THEN
                ' Get device context and set pixel format
                glDC = GetDC(hWnd)
                IF SetPixelFormat(glDC, gn_arbMultisampleFormat, pfd) THEN
                   ' Destroy the temporary window and create the OpenGL context
                   DestroyWindow(hTemp)
                   glRC = wglCreateContext(glDC)
                   wglMakeCurrent(glDC, glRC)
                   ZI_SetProperty(hWnd, %ZI_GLDC, glDC)
                   ZI_SetProperty(hWnd, %ZI_GLRC, glRC)
                ELSE
                   ' Fallback: use the temporary window
                   DestroyWindow(hWnd)
                   MoveWindow(hTemp, x, y, nWidth, nHeight, 0)
                   hWnd = hTemp
                END IF
             END IF

          END IF
       ELSE
          ' Fallback: use the temporary window
          MoveWindow(hTemp, x, y, nWidth, nHeight, 0)
          hWnd = hTemp
       END IF
    END IF
    FUNCTION = hWnd
END FUNCTION


The whole project has been updated with new plugins.

The purpose of this VS2022 application is to switch easily from one plugin to another to check the OpenGL FPO effects transposed to 64-bit.
Most of them inherit from the original 32-bit version written long ago in PowerBASIC.



To navigate from one plugin to another move the cursor to the left or right edge of the window, and click on the auto/hide arrow.

Use drag & drop to play a specific audio file, and see how the effects interact with it.

Here is the BBP API to use to communicate with the plugin DLL.
See in the WM_TIMER message the gl_DrawScene() code using BBP_RenderOpenGL to pass the wimdata pointer to the DLL.

#pragma once
typedef ULONGLONG QWORD;

const int BBP_RENDER       = 1;       // Render the scene.
const int BBP_CREATE       = 2;       // Retrieve Title, Name, Version, Render mode.
const int BBP_INIT         = 3;       // Init the OpenGL.
const int BBP_SIZE         = 4;       // The size of the control has changed.
const int BBP_KEYBOARD     = 5;       // All keyborad message.
const int BBP_MOUSE        = 6;       // All mouse messages.
const int BBP_DESTROY      = 7;       // Free Up resources.
const int BBP_NEWSOUND     = 8;       // We are playing a new sound file.

const int BBP_GDIPLUS      = 0;       // GDImage GDIPLUS compatible mode.
const int BBP_OPENGL       = 1;       // OpenGL mode.
const int BBP_DIRECTX      = 2;       // DirectX mode (for future extension).

const int BBP_SUCCESS      = 0;
const int BBP_ERROR        = -1;

typedef struct {
    UINT msg;                   // The plugin's message (see above constant list).
    HWND parent;                // The parent window handle.
    HDC dc;                     // The parent window DC (while in play mode).
    HGLRC rc;                   // The parent OpenGL RC (while in play mode).
    WORD lpeak;                 // The left audio channel peak value (while in play mode).
    WORD rpeak;                 // The right audio channel peak value (while in play mode).
    char title[32];             // Plugin's name or title.
    char author[64];            // Plugin's author name.
    DWORD version;              // LOWRD major, HIWRD minor.
    long renderto;              // BBP_GDIPLUS, BBP_OPENGL, BBP_DIRECTX.
    long backargb;              // Default ARGB color background.
    float* fftdata;             // dword pointer to the FFT() as single array.
    WORD fftsize;               // Size of the FFT array.

    UINT winmsg;                // True Windows message.
    WPARAM wparam;              // wParam
    LPARAM lparam;              // lParam

    short* wimdata;             // dword pointer to the wave MM_WIM_DATA.
    QWORD medialength;          // Media length.
    QWORD mediapos;             // Media pos.

    char reserved[50];          // Reserved for future extension.
} BBPLUGIN;

static FARPROC BBP_ProcHandle(IN FARPROC hProc, IN long RW) {
    static FARPROC WasHproc;
    if (RW) WasHproc = hProc;
    return WasHproc;
}

static long BBP_Plugin(OUT BBPLUGIN &BBP) {
    long nRet = BBP_ERROR;
    if (IsWindow(gP.hGL)) {
        HGLRC glRC = (HGLRC) (ZI_GetProperty(gP.hGL, ZI_GLRC));
        if (glRC) {
            long_proc (BBPLUGIN*);
            zProc hProc = (zProc) BBP_ProcHandle(0, 0);
            if (hProc) { nRet = hProc(&BBP); }
        }
    }
    return nRet;
}

static WCHAR* BBP_ActivePlugin(IN WCHAR* sPluginName, IN long RW) {
    static WCHAR sWasPluginName[MAX_PATH];
    if (RW) { wcscopy(sWasPluginName, sPluginName); }
    return sWasPluginName;
}

static void MarqueeUpdate() {
    WCHAR drive[_MAX_DRIVE]; ClearMemory(drive, sizeof(drive));
    WCHAR dir[_MAX_DIR]; ClearMemory(dir, sizeof(dir));
    WCHAR fname[_MAX_FNAME]; ClearMemory(fname, sizeof(fname));
    WCHAR ext[_MAX_EXT]; ClearMemory(ext, sizeof(ext));
    wsplitpath(gB.audiofile, drive, dir, fname, ext);
    ClearMemory(gP.plugintitle, sizeof(gP.plugintitle));
    wcscopy(gP.plugintitle, gP.title, MAX_PATH * 2);
    Add_Str(gP.plugintitle, gP.version);
    Add_Str(gP.plugintitle, L" by "); Add_Str(gP.plugintitle, gP.author);
    Add_Str(gP.plugintitle, L", playing \""); Add_Str(gP.plugintitle, fname); Add_Str(gP.plugintitle, ext); Add_Str(gP.plugintitle, L"\"");
    ZD_SetObjectText(ID_COPYRIGHT, gP.plugintitle);
}

static void BBP_Reset() {
    BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));
    BBP.msg = BBP_CREATE;
    BBP_Plugin(BBP);

    ClearMemory(gP.title, sizeof(gP.title));
    wcscopy(gP.title, cswconv(BBP.title), strSize(gP.title));// C string to WCHAR
    ClearMemory(gP.author, sizeof(gP.author));
    wcscopy(gP.author, cswconv(BBP.author), strSize(gP.author));// C string to WCHAR

    BYTE majorVersion = (BYTE)(BBP.version & 0xFF);
    BYTE minorVersion = (BYTE)((BBP.version >> 8) & 0xFF);
    ClearMemory(gP.version, sizeof(gP.version));
    swprintf(gP.version, strSize(gP.version), L" (%d.%d)", majorVersion, minorVersion);

    MarqueeUpdate();

    //BBProc(BBP);
    if (BBP.renderto == BBP_OPENGL) {

        glDisable(GL_BLEND);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_LIGHT0);
        glDisable(GL_LIGHT1);
        glDisable(GL_LIGHT2);
        glDisable(GL_LIGHT3);
        glDisable(GL_LIGHT4);
        glDisable(GL_LIGHT5);
        glDisable(GL_LIGHT6);
        glDisable(GL_LIGHT7);
        glDisable(GL_LIGHTING);
        glDisable(GL_COLOR_MATERIAL);
        glDisable(GL_ALPHA_TEST);
        glDisable(GL_NORMALIZE);

        glDisable(GL_LINE_SMOOTH);

        glGetError();

    }
}

//long BBProc (OUT BBPLUGIN &BBP);
static void BBP_Detached(IN HWND hWnd, OUT HMODULE &hLib) {
    BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));
    if (hLib) {
        BBP.msg = BBP_DESTROY;
        BBP.parent = hWnd;
        BBP_Plugin(BBP);
        //BBProc(BBP);

        // use brute force to delete any existing texture
        long Tmax = 64;
        long* DT = new long[Tmax]; memset(DT, 0, Tmax);
        for (long K = 0; K < Tmax; K++) { DT[K] = K; }
        glDeleteTextures(Tmax, (GLuint*)&DT[0]);
        delete[] DT;

        BBP_ProcHandle(0, 1); FreeLibrary(hLib); hLib = 0;
    }
}

static void BBP_ResizeOpenGL() {
    if (IsWindow(gP.hGL)) {
        BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));
        BBP.msg          = BBP_SIZE;
        BBP.parent       = gP.hGL;
        BBP_Plugin(BBP);
        //BBProc(BBP);
    }
}

// Load/unload plugin DLL to/from memory
static long BBP_LoadPlugin(IN HWND hWnd, IN WCHAR* zPlugin) {
    long nDone = BBP_ERROR;
    long nLen = lstrlen(zPlugin);
    if ((nLen) && (_wcsicmp(zPlugin, BBP_ActivePlugin(0,0)) != 0)) {
        if (FileExist(zPlugin)) {
            if (gP.hLib) BBP_Detached(hWnd, gP.hLib);
            gP.hLib = LoadLibrary(zPlugin);
            if (gP.hLib) {
                FARPROC hProc = GetProcAddress(gP.hLib, "BBProc");
                if (hProc) {
                    BBP_ProcHandle(hProc, 1);
                    BBP_ActivePlugin(zPlugin, 1);
                    // Reset plugin to default
                    BBP_Reset();
                    nDone = BBP_SUCCESS;
                }
            }
        }
    } else if (nLen == 0) {
        if (gP.hLib) BBP_Detached(hWnd, gP.hLib);
    }
    return nDone;
}

static long BBP_AttachPlugin(WCHAR* zPlugin) {
    gP.pluginloaded = 0;
    if (IsWindow(gP.hGL)) {
        if (BBP_LoadPlugin(gP.hGL, zPlugin) == BBP_SUCCESS) {
            gP.pluginloaded = -1;
            BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));
            BBP.msg          = BBP_INIT;
            BBP.parent       = gP.hGL;
            BBP.dc           = (HDC) ZI_GetProperty(gP.hGL, ZI_GLDC);
            BBP.rc           = (HGLRC) ZI_GetProperty(gP.hGL, ZI_GLRC);
            BBP.backargb     = 0;
            BBP_Plugin(BBP);

            //if (IsWindowVisible(gP.hGL)) { SetMetadataText(ID_VIDEO_SIZE, gB.plugintitle); }

            BBP.msg          = BBP_SIZE;
            BBP_Plugin(BBP);

            wcscopy(gP.bin.lastplugin, zPlugin);

            gP.pluginloaded = -1;
        }
    }
    return gP.pluginloaded;
}

static void BBP_RenderOpenGL(IN DWORD nLevel, IN short* pInt) {

    BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));

    HDC glDC = (HDC) (ZI_GetProperty(gP.hGL, ZI_GLDC));
    HGLRC glRC = (HGLRC) (ZI_GetProperty(gP.hGL, ZI_GLRC));
    if (glRC) {

        BBP.msg          = BBP_RENDER;
        BBP.parent       = gP.hGL;
        BBP.dc           = glDC;
        BBP.rc           = glRC;
        BBP.lpeak        = SolvePeak(LOWORD(nLevel), 128);
        BBP.rpeak        = SolvePeak(HIWORD(nLevel), 128);
        BBP.backargb     = 0;
        BBP.fftdata      = (float*) BassChannelGetData();
        BBP.fftsize      = 256;
        BBP.medialength  = gB.medialength;
        BBP.mediapos     = gB.mediapos;
        BBP.wimdata      = pInt;

        BBP_Plugin(BBP);
        //BBProc(BBP);

        // Refresh display
        SwapBuffers(glDC);

        InvalidateRect(gP.hGL, NULL, 0);
        UpdateWindow(gP.hGL);
    }
    ReleaseDC(gP.hGL, glDC);
}

static void BBP_NewSound() {
    BBPLUGIN BBP; ClearMemory(&BBP, sizeof(BBP));
    BBP.msg = BBP_NEWSOUND;
    BBP_Plugin(BBP);
}

If you are familiar with OpenGL programming, the VS2022 source code of each plugin is also attached in the Plugins_dll.7z

ShaderPlay is derivated from ORV64.
Its purpose is to play ShaderToy static animations.



It is written in C/C++ with VS2022, and does use TClib.lib to produce a tiny 15 Kb binary.
Each schader file is stored in a distinct subfolder, under the 3D_models parent folder.

The shader code file is using the .fs extension, it is sligthy different from the original ShaderToy to match the OR (ObjReader) specifications.

For the purpose of ShaderPlay, each project is provided with a specific sound track to shut down automatically the shader once audio comes to full completion (except when playing in loop mode).

This is version 2.00.

It has been reworked to match the CPU processor percentage computation used in Windows 11.

On previous Windows 10, they were using "Processor(_Total)\\% Processor Time"

The solution is to use PDH (Performance Data Helper) and the Processor Utility request
nStatus = PdhAddEnglishCounter(cpuQuery, L"\\Processor Information(_Total)\\% Processor Utility", NULL, &cpuTotal);

\\Processor Information(_Total)\\% Processor Utility

• Description: This counter measures the percentage of processor utility across all processors.
  
• Utility: It provides a more detailed and modern view of processor usage, taking into account various factors like the efficiency of processing and modern CPU architectures.
  
• Availability: This counter is generally available on newer systems with modern processors. It can give a more accurate representation of CPU utilization in multi-core and hyper-threaded environments.
  

\\Processor(_Total)\\% Processor Time

• Description: This counter measures the percentage of time the processor is busy executing a non-idle thread.
  
• Utility: It is a more traditional counter that has been available in Windows for a long time. It reflects the CPU load by measuring the active time versus the idle time of the CPU.
  
• Availability: This counter is widely available across different versions of Windows and provides a consistent measure of CPU usage.
  

Note:
The project use TCLib.lib to produce a tiny 29 Kb binary executable.