Sync3DReceive

Navigation: Programming with ADLX → ADLX Samples → C++ Samples → Receiving Events Notifications

Demonstrates how to receive notifications of changes in 3D settings using ADLX.

To receive the event, another application must be used to change these settings, such as the

AntiLag.

Sample Path

/Samples/CPP/ReceivingEventsNotifications/Sync3DReceive

C++

Code

C++

//
// Copyright Advanced Micro Devices, Inc. All rights reserved.
//
//-------------------------------------------------------------------------------------------------

/// \file mainSync3DReceive.cpp
/// \brief Demonstrates how to receive notifications of changes in 3D settings using ADLX.

#include "SDK/ADLXHelper/Windows/Cpp/ADLXHelper.h"
#include "SDK/Include/I3DSettings.h"
#include "SDK/Include/I3DSettings1.h"
#include "SDK/Include/I3DSettings2.h"
#include "conio.h"
#include <iostream>
#include <string>
#include <map>
#include <thread>

// Use ADLX namespace.
using namespace adlx;

// ADLXHelper instance.
// No outstanding interfaces from ADLX must exist when ADLX is destroyed.
// Use global variables to ensure validity of the interface.
static ADLXHelper g_ADLXHelp;

// Block event to verify call back.
HANDLE blockEvent = nullptr;
HANDLE quitEvent = nullptr;

// AnisotropicFiltering level map
static const std::map<ADLX_ANISOTROPIC_FILTERING_LEVEL, const char*> levelMap =
{
    {AF_LEVEL_INVALID, "Invalid"},
    {AF_LEVEL_X2, "2X"},
    {AF_LEVEL_X4, "4X"},
    {AF_LEVEL_X8, "8X"},
    {AF_LEVEL_X16, "16X"} };

// WaitForVerticalRefresh mode
static const std::map<ADLX_WAIT_FOR_VERTICAL_REFRESH_MODE, const char*> vsyncMode =
{
    {WFVR_ALWAYS_OFF, "Always off"},
    {WFVR_OFF_UNLESS_APP_SPECIFIES, "Off, unless application specifies"},
    {WFVR_ON_UNLESS_APP_SPECIFIES, "On, unless application specifies"},
    {WFVR_ALWAYS_ON, "Always on"} };

// antiAliasing mode
static const std::map<ADLX_ANTI_ALIASING_MODE, const char*> antiAliasingMode =
{
    {AA_MODE_USE_APP_SETTINGS, "Use application settings"},
    {AA_MODE_ENHANCE_APP_SETTINGS, "Enhance application settings"},
    {AA_MODE_OVERRIDE_APP_SETTINGS, "Override application settings"} };

// antiAliasing method
static const std::map<ADLX_ANTI_ALIASING_METHOD, const char*> antiAliasingMethod =
{
    {AA_METHOD_MULTISAMPLING, "Muti-Sampling"},
    {AA_METHOD_ADAPTIVE_MULTISAMPLING, "Adaptive Muti-Sampling"},
    {AA_METHOD_SUPERSAMPLING, "Super Sampling"} };

// antiAliasing level
static const std::map<ADLX_ANTI_ALIASING_LEVEL, const char*> antiAliasingLevel =
{
    {AA_LEVEL_INVALID, "Level Invalid"},
    {AA_LEVEL_2X, "2X"},
    {AA_LEVEL_2XEQ, "2XEQ"},
    {AA_LEVEL_4X, "4X"},
    {AA_LEVEL_4XEQ, "4XEQ"},
    {AA_LEVEL_8X, "8X"},
    {AA_LEVEL_8XEQ, "8XEQ"} };

// TessellationMode mode
static const std::map<ADLX_TESSELLATION_MODE, const char*> Modes =
{
    {T_MODE_AMD_OPTIMIZED, "AMD optimized"},
    {T_MODE_USE_APP_SETTINGS, "Use application settings"},
    {T_MODE_OVERRIDE_APP_SETTINGS, "Override application settings"} };

// TessellationMode level
static const std::map<ADLX_TESSELLATION_LEVEL, const char*> Levels =
{
    {T_LEVEL_OFF, "Off"},
    {T_LEVEL_2X, "2X"},
    {T_LEVEL_4X, "4X"},
    {T_LEVEL_6X, "6X"},
    {T_LEVEL_8X, "8X"},
    {T_LEVEL_16X, "16X"},
    {T_LEVEL_32X, "32X"},
    {T_LEVEL_64X, "64X"} };

// Get the GPU unique name
void GPUUniqueName(IADLXGPUPtr gpu, char* uniqueName);

// Call back to handl changed events
class CallBack3DSettingsChanged : public IADLX3DSettingsChangedListener
{
public:
    adlx_bool ADLX_STD_CALL On3DSettingsChanged(IADLX3DSettingsChangedEvent* p3DSettingsChangedEvent) override
    {
        // Get 3DSettings service
        IADLX3DSettingsServicesPtr d3dSettingSrv;
        g_ADLXHelp.GetSystemServices()->Get3DSettingsServices(&d3dSettingSrv);
        IADLX3DSettingsServices1Ptr d3dSettingSrv1 (d3dSettingSrv);
        IADLX3DSettingsServices2Ptr d3dSettingSrv2(d3dSettingSrv);

        IADLX3DSettingsChangedEvent1Ptr p3DSettingsChangedEvent1(p3DSettingsChangedEvent);
        if (p3DSettingsChangedEvent1 == nullptr)
        {
            std::cout << "3DSettingsChangedEvent1 not supported" << std::endl;
        }

        IADLX3DSettingsChangedEvent2Ptr p3DSettingsChangedEvent2 (p3DSettingsChangedEvent);
        if (p3DSettingsChangedEvent2 == nullptr)
        {
            std::cout << "3DSettingsChangedEvent2 not supported" << std::endl;
        }

        // Get the GPU interface
        IADLXGPUPtr gpu;
        p3DSettingsChangedEvent->GetGPU(&gpu);
        //RadeonSuperResolution is a global feature (the GPU interface is nullptr); skip printing its name
        if (!p3DSettingsChangedEvent->IsRadeonSuperResolutionChanged())
        {
            char uniqueName[128] = "Unknown";
            GPUUniqueName(gpu, uniqueName);
            std::cout << "GPU: " << uniqueName << ", Get sync event, 3D settings changed event was fired" << std::endl;
        }
        ADLX_SYNC_ORIGIN origin = p3DSettingsChangedEvent->GetOrigin();
        if (origin == SYNC_ORIGIN_EXTERNAL)
        {
            if (p3DSettingsChangedEvent->IsAntiLagChanged())
            {
                // Get AntiLag interface
                IADLX3DAntiLagPtr d3dAntiLag;
                d3dSettingSrv->GetAntiLag(gpu, &d3dAntiLag);
                adlx_bool enabled;
                d3dAntiLag->IsEnabled(&enabled);
                std::cout <<"\tAntiLag changed\n\tIsEnabled: " << enabled << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsChillChanged())
            {
                // Get Chill interface
                IADLX3DChillPtr d3dChill;
                d3dSettingSrv->GetChill(gpu, &d3dChill);
                adlx_bool enabled;
                d3dChill->IsEnabled(&enabled);
                adlx_int minFPS, maxFPS;
                d3dChill->GetMinFPS(&minFPS);
                d3dChill->GetMaxFPS(&maxFPS);
                std::cout << "\tChill changed\n\tIsEnabled: " << enabled << " , FPS: [ " << minFPS << " , " << maxFPS << " ]" << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsBoostChanged())
            {
                // Get Boost interface
                IADLX3DBoostPtr d3dBoost;
                d3dSettingSrv->GetBoost(gpu, &d3dBoost);
                adlx_bool enabled;
                d3dBoost->IsEnabled(&enabled);
                adlx_int minRes;
                d3dBoost->GetResolution(&minRes);
                std::cout << "\tBoost changed\n\tIsEnabled: " << enabled << " , minResolution: " << minRes << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsImageSharpeningChanged())
            {
                // Get ImageSharpen interface
                IADLX3DImageSharpeningPtr d3dImageSharpen;
                d3dSettingSrv->GetImageSharpening(gpu, &d3dImageSharpen);
                adlx_bool enabled;
                d3dImageSharpen->IsEnabled(&enabled);
                adlx_int min;
                d3dImageSharpen->GetSharpness(&min);
                std::cout << "\tImageSharpening changed\n\tIsEnabled: " << enabled << " , Sharpness: " << min << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsEnhancedSyncChanged())
            {
                // Get EnhancedSync interface
                IADLX3DEnhancedSyncPtr d3dEnhancedSync;
                d3dSettingSrv->GetEnhancedSync(gpu, &d3dEnhancedSync);
                adlx_bool enabled;
                d3dEnhancedSync->IsEnabled(&enabled);
                std::cout << "\tEnhancedSync changed\n\tIsEnabled: " << enabled << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsWaitForVerticalRefreshChanged())
            {
                // Get Vsync interface
                IADLX3DWaitForVerticalRefreshPtr vsync;
                d3dSettingSrv->GetWaitForVerticalRefresh(gpu, &vsync);
                adlx_bool enabled;
                vsync->IsEnabled(&enabled);
                ADLX_WAIT_FOR_VERTICAL_REFRESH_MODE mode = WFVR_ALWAYS_OFF;
                vsync->GetMode(&mode);
                std::cout << "\tWaitForVerticalRefresh changed\n\tIsEnabled: " << enabled << " , Mode: " << vsyncMode.find(mode)->second << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsFrameRateTargetControlChanged())
            {
                // Get FRTC interface
                IADLX3DFrameRateTargetControlPtr frtc;
                d3dSettingSrv->GetFrameRateTargetControl(gpu, &frtc);
                adlx_bool enabled;
                frtc->IsEnabled(&enabled);
                adlx_int fps;
                frtc->GetFPS(&fps);
                std::cout << "\tFRTC changed\n\tIsEnabled: " << enabled << " , fps: " << fps << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsAntiAliasingChanged())
            {
                // Get AntiAliasing interface
                IADLX3DAntiAliasingPtr antiAliasing;
                d3dSettingSrv->GetAntiAliasing(gpu, &antiAliasing);
                ADLX_ANTI_ALIASING_MODE mode;
                antiAliasing->GetMode(&mode);
                ADLX_ANTI_ALIASING_METHOD method;
                antiAliasing->GetMethod(&method);
                ADLX_ANTI_ALIASING_LEVEL level;
                antiAliasing->GetLevel(&level);
                std::cout << "\tAntiAliasing changed\n" << std::endl
                << "\tMode: " << antiAliasingMode.find(mode)->second << std::endl
                << "\tMethod: " << antiAliasingMethod.find(method)->second << std::endl
                << "\tLevel: " << antiAliasingLevel.find(level)->second << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsMorphologicalAntiAliasingChanged())
            {
                // Get MorphologicAntiAliasing interface
                IADLX3DMorphologicalAntiAliasingPtr mAntiAliasing;
                d3dSettingSrv->GetMorphologicalAntiAliasing(gpu, &mAntiAliasing);
                adlx_bool enabled;
                mAntiAliasing->IsEnabled(&enabled);
                std::cout << "\tMorphologicalAntiAliasing changed\n\tIsEnabled: " << enabled << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsAnisotropicFilteringChanged())
            {
                // Get AnisotropicFilteringPtr interface
                IADLX3DAnisotropicFilteringPtr anisotropicFiltering;
                d3dSettingSrv->GetAnisotropicFiltering(gpu, &anisotropicFiltering);
                adlx_bool enabled;
                anisotropicFiltering->IsEnabled(&enabled);
                ADLX_ANISOTROPIC_FILTERING_LEVEL level;
                anisotropicFiltering->GetLevel(&level);
                std::cout << "\tAnisotropicFiltering changed\n\tIsEnabled: " << enabled << std::endl
                << "\tLevel: " << levelMap.find(level)->second << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsTessellationModeChanged())
            {
                // Get IADLX3DTessellation interface
                IADLX3DTessellationPtr tessellation;
                d3dSettingSrv->GetTessellation(gpu, &tessellation);
                ADLX_TESSELLATION_MODE mode;
                tessellation->GetMode(&mode);
                ADLX_TESSELLATION_LEVEL level;
                tessellation->GetLevel(&level);
                std::cout << "\tTessellationMode changed\n" << std::endl
                << "\tMode: " << Modes.find(mode)->second << std::endl
                << "\tLevel: " << Levels.find(level)->second << std::endl;
            }
            else if (p3DSettingsChangedEvent->IsResetShaderCache())
            {
                std::cout << "\tResetShaderCache" << std::endl;
            }

            else if (p3DSettingsChangedEvent2->IsImageSharpenDesktopChanged())
            {
                // Get ImageSharpen interface
                IADLX3DImageSharpenDesktopPtr d3dImageSharpenDesktop;
                d3dSettingSrv2->GetImageSharpenDesktop(gpu, &d3dImageSharpenDesktop);
                adlx_bool enabled;
                d3dImageSharpenDesktop->IsEnabled(&enabled);
                std::cout << "\tImage Sharpeing 2 changed\n\tIsEnabled: " << enabled << std::endl;
             }
        }

        if (origin == SYNC_ORIGIN_UNKNOWN)
        {
            if (p3DSettingsChangedEvent->IsRadeonSuperResolutionChanged())
            {
                // Get IADLX3DRadeonSuperResolution interface
                IADLX3DRadeonSuperResolutionPtr rsr;
                d3dSettingSrv->GetRadeonSuperResolution(&rsr);
                adlx_bool enabled = false;
                rsr->IsEnabled(&enabled);
                adlx_int sharpness;
                rsr->GetSharpness(&sharpness);
                std::cout << "\tRSR changed\n\tIsEnabled: " << enabled << " , Sharpness: " << sharpness <<  std::endl;
            }
            else if (p3DSettingsChangedEvent1->IsAMDFluidMotionFramesChanged())
            {
                // Get AMDFluidMotionFrames interface
                IADLX3DAMDFluidMotionFramesPtr d3dAfmd;
                d3dSettingSrv1->GetAMDFluidMotionFrames(&d3dAfmd);
                adlx_bool enabled;
                d3dAfmd->IsEnabled(&enabled);
                std::cout << "\tAMDFluidMotionFrmes changed\n\tIsEnabled: " << enabled << std::endl;
            }
        }

        SetEvent(blockEvent);

        // Return true for ADLX to continue notifying the next listener, or false to stop notification
        return true;
    }
};

// Wait for quit signal
void QuitWait(adlx_bool* loopFlag)
{
    while (true)
    {
        // Non-blocking checking if the I/O cache has characters
        if (_kbhit())
        {
            char c;
            if ((c = getchar()) == 'q' || c == 'Q')
            {
                *loopFlag = false;
                SetEvent(quitEvent);
                break;
            }
        }
        Sleep(100);
    }
}

int main()
{
    // Define return code
    ADLX_RESULT res = ADLX_FAIL;

    // Initialize ADLX
    res = g_ADLXHelp.Initialize();
    if (ADLX_SUCCEEDED(res))
    {
        // Create block event
        blockEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        // Create quit event
        quitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
        // Create event array
        HANDLE eventArray[] = { blockEvent, quitEvent };

        // Get 3DSettings service
        IADLX3DSettingsServicesPtr d3dSettingSrv;
        res = g_ADLXHelp.GetSystemServices()->Get3DSettingsServices(&d3dSettingSrv);

        if (ADLX_SUCCEEDED(res))
        {
            // Get Change handle
            IADLX3DSettingsChangedHandlingPtr changeHandle;
            res = d3dSettingSrv->Get3DSettingsChangedHandling(&changeHandle);
            if (ADLX_SUCCEEDED(res))
            {
                // Create call back
                IADLX3DSettingsChangedListener* call = new CallBack3DSettingsChanged;

                // Add call back
                changeHandle->Add3DSettingsEventListener(call);

                // Create a thread to check quit event
                bool loopFlag = true;
                std::thread t{ QuitWait, &loopFlag};

                std::cout << "\nWaiting for 3DSetting change event... Press Q/q to quit" << std::endl;
                while (true)
                {
                    // Wait for change event or request to quit
                    DWORD waitRet = WaitForMultipleObjects(2, eventArray, FALSE, INFINITE);
                    if (!loopFlag)
                    {
                        if (t.joinable())
                        {
                            t.join();
                        }
                        break;
                    }
                    ResetEvent(blockEvent);
                }

                // Remove call back
                changeHandle->Remove3DSettingsEventListener(call);

                // Delete call back
                delete call;
                call = nullptr;
            }
        }
        else
        {
            std::cout << "Failed to get the 3DSettings Services" << std::endl;
        }
    }
    else
    {
        std::cout << "ADLX initialization failed" << std::endl;
        return 0;
    }

    // Destroy ADLX
    res = g_ADLXHelp.Terminate();
    std::cout << "Destroy ADLX res: " << res << std::endl;

    // Close event
    if (blockEvent)
        CloseHandle(blockEvent);
    if (quitEvent)
        CloseHandle(quitEvent);

    // Pause to see the print out
    system("pause");

    return 0;
}

void GPUUniqueName(IADLXGPUPtr gpu, char* uniqueName)
{
    if (nullptr != gpu && nullptr != uniqueName)
    {
        const char* gpuName = nullptr;
        gpu->Name(&gpuName);
        adlx_int id;
        gpu->UniqueId(&id);
        sprintf_s(uniqueName, 128, "name:%s, id:%d", gpuName, id);
    }
}