RENDERDOC_AnnotationValue value)

{

if(valueType == eRENDERDOC_Empty)

{

RDCERR("Invalid type of annotation to write");

return;

}

const rdcinflexiblestr types[eRENDERDOC_APIObject + 1][4] = {

// eRENDERDOC_Empty,

{""_lit, ""_lit, ""_lit, ""_lit},

// eRENDERDOC_Bool,

{"bool"_lit, "bool2"_lit, "bool3"_lit, "bool4"_lit},

// eRENDERDOC_Int32,

{"int"_lit, "int2"_lit, "int3"_lit, "int4"_lit},

// eRENDERDOC_UInt32,

{"uint"_lit, "uint2"_lit, "uint3"_lit, "uint4"_lit},

// eRENDERDOC_Int64,

{"long"_lit, "long2"_lit, "long3"_lit, "long4"_lit},

// eRENDERDOC_UInt64,

{"ulong"_lit, "ulong2"_lit, "ulong3"_lit, "ulong4"_lit},

// eRENDERDOC_Float,

{"float"_lit, "float2"_lit, "float3"_lit, "float4"_lit},

// eRENDERDOC_Double,

{"double"_lit, "double2"_lit, "double3"_lit, "double4"_lit},

// eRENDERDOC_String,

{"string"_lit, ""_lit, ""_lit, ""_lit},

// eRENDERDOC_APIObject,

{"ResourceId"_lit, ""_lit, ""_lit, ""_lit},

};

const uint32_t byteSize[eRENDERDOC_APIObject + 1] = {

// eRENDERDOC_Empty,

0,

// eRENDERDOC_Bool,

1,

// eRENDERDOC_Int32,

4,

// eRENDERDOC_UInt32,

4,

// eRENDERDOC_Int64,

8,

// eRENDERDOC_UInt64,

8,

// eRENDERDOC_Float,

4,

// eRENDERDOC_Double,

8,

// eRENDERDOC_String,

0,

// eRENDERDOC_APIObject,

8,

};

const SDBasic basetype[eRENDERDOC_APIObject + 1] = {

// eRENDERDOC_Empty,

SDBasic::Null,

// eRENDERDOC_Bool,

SDBasic::Boolean,

// eRENDERDOC_Int32,

SDBasic::SignedInteger,

// eRENDERDOC_UInt32,

SDBasic::UnsignedInteger,

// eRENDERDOC_Int64,

SDBasic::SignedInteger,

// eRENDERDOC_UInt64,

SDBasic::UnsignedInteger,

// eRENDERDOC_Float,

SDBasic::Float,

// eRENDERDOC_Double,

SDBasic::Float,

// eRENDERDOC_String,

SDBasic::String,

// eRENDERDOC_APIObject,

SDBasic::Resource,

};

if(valueVectorWidth > 1)

{

if(valueType == eRENDERDOC_APIObject)

{

RDCERR("Invalid vector width for API object");

return;

}

else if(valueType == eRENDERDOC_String)

{

RDCERR("Invalid vector width for string");

return;

}

const rdcinflexiblestr comps[] = {"1"_lit, "2"_lit, "3"_lit, "4"_lit};

obj->type.basetype = SDBasic::Struct;

obj->type.name = types[valueType][valueVectorWidth - 1];

RENDERDOC_AnnotationValue tmp = {};

for(uint32_t i = 0; i < valueVectorWidth; i++)

{

SDObject *child = obj->CreateChildByKeyPath(comps[i]);

if(byteSize[valueType] == 1)

memcpy(&tmp.boolean, &value.vector.boolean[i], sizeof(tmp.boolean));

if(byteSize[valueType] == 4)

memcpy(&tmp.uint32, &value.vector.uint32[i], sizeof(tmp.uint32));

if(byteSize[valueType] == 8)

memcpy(&tmp.uint64, &value.vector.uint64[i], sizeof(tmp.uint64));

WriteAnnotation(child, valueType, 0, tmp);

if(i == 0)

obj->type.byteSize = child->type.byteSize * valueVectorWidth;

}

return;

}

obj->type.name = types[valueType][0];

obj->type.basetype = basetype[valueType];

obj->type.byteSize = byteSize[valueType];

switch(valueType)

{

case eRENDERDOC_Empty:

case eRENDERDOC_AnnotationMax: RDCERR("Invalid annotation type"); return;

case eRENDERDOC_Bool:

{

obj->data.basic.b = value.boolean;

break;

}

case eRENDERDOC_Int32:

{

obj->data.basic.i = value.int32;

break;

}

case eRENDERDOC_UInt32:

{

obj->data.basic.u = value.uint32;

break;

}

case eRENDERDOC_Int64:

{

obj->data.basic.u = value.int64;

break;

}

case eRENDERDOC_UInt64:

{

obj->data.basic.u = value.uint64;

break;

}

case eRENDERDOC_Float:

{

obj->data.basic.d = value.float32;

break;

}

case eRENDERDOC_Double:

{

obj->data.basic.d = value.float64;

break;

}

case eRENDERDOC_String:

{

obj->type.byteSize = strlen(value.string);

obj->data.str = value.string;

break;

}

case eRENDERDOC_APIObject:

{

memcpy(&obj->data.basic.id, &value.uint64, sizeof(ResourceId));

break;

}

}

{

RDCLOG("%s API validation during replay", (opts.apiValidation ? "Enabling" : "Not enabling"));

if(opts.forceGPUVendor == GPUVendor::Unknown && opts.forceGPUDeviceID == 0 &&

opts.forceGPUDriverName.empty())

{

RDCLOG("Using default GPU replay selection algorithm");

}

else

{

RDCLOG("Overriding GPU replay selection:");

RDCLOG(" Vendor %s, device %u, driver \"%s\"", ToStr(opts.forceGPUVendor).c_str(),

opts.forceGPUDeviceID, opts.forceGPUDriverName.c_str());

}

RDCLOG("Replay optimisation level: %s", ToStr(opts.optimisation).c_str());

{

RDCCOMPILE_ASSERT(sizeof(el) == sizeof(uint64_t), "ResourceId is no longer 1:1 with uint64_t");

// below is equivalent to:

// return StringFormat::Fmt("ResourceId::%llu", el);

uint64_t num = 0;

memcpy(&num, &el, sizeof(uint64_t));

#define PREFIX "ResourceId::"

// hardcode empty/null ResourceId to both avoid special case below and fast-path a common case as

// a string literal.

if(num == 0)

return PREFIX "0"_lit;

// enough for prefix and a 64-bit value in decimal

char str[48] = {};

RDCCOMPILE_ASSERT(ARRAY_COUNT(str) > sizeof(PREFIX) + 20, "Scratch buffer is not large enough");

// ARRAY_COUNT(str) - 1 would point us at the last element, we go one further back to leave a

// trailing NUL character

char *c = str + ARRAY_COUNT(str) - 2;

// build up digits in reverse order from the end of the buffer

while(num)

{

*(c--) = char((num % 10) + '0');

num /= 10;

}

// the length is sizeof(PREFIX) - 1, the index of the last actual character is - 2. Saves us a -1

// in the loop below.

const size_t prefixlast = sizeof(PREFIX) - 2;

// add the prefix (in reverse order)

for(size_t i = 0; i <= prefixlast; i++)

*(c--) = PREFIX[prefixlast - i];

#undef PREFIX

// the loop will have stepped us to the first NULL before our string, so return c+1

return c + 1;

{

if(el.shader != ResourceId())

{

// we don't want to format as an ID, we need to encode the raw value

uint64_t num;

memcpy(&num, &el.shader, sizeof(num));

return StringFormat::Fmt("GPUAddress::%llu::%llu::%u", el.pointer, num, el.pointerTypeID);

}

else

{

return StringFormat::Fmt("GPUAddress::%llu", el.pointer);

}

{

SERIALISE_MEMBER(code);

SERIALISE_MEMBER(message);

SIZE_CHECK(16);

{

BEGIN_ENUM_STRINGISE(CaptureState);

{

STRINGISE_ENUM_CLASS(LoadingReplaying);

STRINGISE_ENUM_CLASS(ActiveReplaying);

STRINGISE_ENUM_CLASS(StructuredExport);

STRINGISE_ENUM_CLASS(BackgroundCapturing);

STRINGISE_ENUM_CLASS(ActiveCapturing);

}

END_ENUM_STRINGISE();

{

BEGIN_ENUM_STRINGISE(RDCDriver);

{

STRINGISE_ENUM_CLASS(Unknown);

STRINGISE_ENUM_CLASS(OpenGL);

STRINGISE_ENUM_CLASS(OpenGLES);

STRINGISE_ENUM_CLASS(Mantle);

STRINGISE_ENUM_CLASS(D3D12);

STRINGISE_ENUM_CLASS(D3D11);

STRINGISE_ENUM_CLASS(D3D10);

STRINGISE_ENUM_CLASS(D3D9);

STRINGISE_ENUM_CLASS(D3D8);

STRINGISE_ENUM_CLASS(Image);

STRINGISE_ENUM_CLASS(Vulkan);

STRINGISE_ENUM_CLASS(Metal);

}

END_ENUM_STRINGISE();

{

BEGIN_ENUM_STRINGISE(ReplayLogType);

{

STRINGISE_ENUM_NAMED(eReplay_Full, "Full replay including action");

STRINGISE_ENUM_NAMED(eReplay_WithoutDraw, "Replay without action");

STRINGISE_ENUM_NAMED(eReplay_OnlyDraw, "Replay only action");

}

END_ENUM_STRINGISE();

{

BEGIN_ENUM_STRINGISE(VendorExtensions);

{

STRINGISE_ENUM_CLASS(NvAPI);

STRINGISE_ENUM_CLASS_NAMED(OpenGL_Ext, "Unsupported GL extensions");

STRINGISE_ENUM_CLASS_NAMED(Vulkan_Ext, "Unsupported Vulkan extensions");

}

END_ENUM_STRINGISE();

{

char alphanumericbuf[2] = {'A', 0};

// enums map straight to ascii

if((el >= eRENDERDOC_Key_A && el <= eRENDERDOC_Key_Z) ||

(el >= eRENDERDOC_Key_0 && el <= eRENDERDOC_Key_9))

{

alphanumericbuf[0] = (char)el;

return alphanumericbuf;

}

BEGIN_ENUM_STRINGISE(RENDERDOC_InputButton);

{

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Divide, "/");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Multiply, "*");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Subtract, "-");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Plus, "+");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F1, "F1");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F2, "F2");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F3, "F3");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F4, "F4");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F5, "F5");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F6, "F6");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F7, "F7");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F8, "F8");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F9, "F9");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F10, "F10");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F11, "F11");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_F12, "F12");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Home, "Home");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_End, "End");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Insert, "Insert");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Delete, "Delete");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PageUp, "PageUp");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PageDn, "PageDn");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Backspace, "Backspace");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Tab, "Tab");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_PrtScrn, "PrtScrn");

STRINGISE_ENUM_NAMED(eRENDERDOC_Key_Pause, "Pause");

}

END_ENUM_STRINGISE();

{

BEGIN_ENUM_STRINGISE(SystemChunk);

{

STRINGISE_ENUM_CLASS_NAMED(DriverInit, "Internal::Driver Initialisation Parameters");

STRINGISE_ENUM_CLASS_NAMED(InitialContentsList, "Internal::List of Initial Contents Resources");

STRINGISE_ENUM_CLASS_NAMED(InitialContents, "Internal::Initial Contents");

STRINGISE_ENUM_CLASS_NAMED(CaptureBegin, "Internal::Beginning of Capture");

STRINGISE_ENUM_CLASS_NAMED(CaptureScope, "Internal::Frame Metadata");

STRINGISE_ENUM_CLASS_NAMED(CaptureEnd, "Internal::End of Capture");

}

END_ENUM_STRINGISE();

{

BEGIN_ENUM_STRINGISE(RENDERDOC_AnnotationType);

{

STRINGISE_ENUM_NAMED(eRENDERDOC_Bool, "bool");

STRINGISE_ENUM_NAMED(eRENDERDOC_Int32, "int32");

STRINGISE_ENUM_NAMED(eRENDERDOC_UInt32, "uint32");

STRINGISE_ENUM_NAMED(eRENDERDOC_Int64, "int64");

STRINGISE_ENUM_NAMED(eRENDERDOC_UInt64, "uint64");

STRINGISE_ENUM_NAMED(eRENDERDOC_Float, "float");

STRINGISE_ENUM_NAMED(eRENDERDOC_Double, "double");

STRINGISE_ENUM_NAMED(eRENDERDOC_String, "string");

STRINGISE_ENUM_NAMED(eRENDERDOC_APIObject, "object");

}

END_ENUM_STRINGISE();

{

if(ser.GetStructArg() == eRENDERDOC_String)

{

SERIALISE_MEMBER(string).Hidden();

}

else

{

SERIALISE_MEMBER(vector.uint64).Hidden();

}

{

SCOPED_WRITELOCK(m_ExHandlerLock);

#if ENABLED(RDOC_CRASH_HANDLER)

rdcstr exename;

FileIO::GetExecutableFilename(exename);

exename = strlower(exename);

// only create crash handler when we're not in renderdoccmd (to prevent infinite loop as

// the crash handler itself launches renderdoccmd)

if(exename.contains("renderdoccmd"))

return;

#if ENABLED(RDOC_WIN32)

// there are way too many invalid reports coming from chrome, completely disable the crash handler

// in that case.

if(exename.find("chrome.exe") &&

(GetModuleHandleA("chrome_elf.dll") || GetModuleHandleA("chrome_child.dll")))

{

RDCWARN("Disabling crash handling server due to detected chrome.");

return;

}

// some people use vivaldi which is just chrome

if(exename.find("vivaldi.exe") &&

(GetModuleHandleA("vivaldi_elf.dll") || GetModuleHandleA("vivaldi_child.dll")))

{

RDCWARN("Disabling crash handling server due to detected chrome.");

return;

}

// ditto opera

if(exename.find("opera.exe") && GetModuleHandleA("opera_browser.dll"))

{

RDCWARN("Disabling crash handling server due to detected chrome.");

return;

}

// ditto edge

if(exename.find("msedge.exe") && GetModuleHandleA("msedge.dll"))

{

RDCWARN("Disabling crash handling server due to detected chrome.");

return;

}

#endif

m_ExHandler = new CrashHandler(m_ExHandler);

m_ExHandler->RegisterMemoryRegion(this, sizeof(RenderDoc));

#endif

{

SCOPED_WRITELOCK(m_ExHandlerLock);

if(!m_ExHandler)

return;

m_ExHandler->UnregisterMemoryRegion(this);

SAFE_DELETE(m_ExHandler);

{

SCOPED_READLOCK(m_ExHandlerLock);

if(m_ExHandler)

m_ExHandler->RegisterMemoryRegion(mem, size);

{

SCOPED_READLOCK(m_ExHandlerLock);

if(m_ExHandler)

m_ExHandler->UnregisterMemoryRegion(mem);

{

m_CaptureFileTemplate = "";

m_MarkerIndentLevel = 0;

m_CapturesActive = 0;

m_RemoteIdent = 0;

m_RemoteThread = 0;

m_Replay = false;

m_Cap = 0;

m_FocusKeys.clear();

m_FocusKeys.push_back(eRENDERDOC_Key_F11);

m_CaptureKeys.clear();

m_CaptureKeys.push_back(eRENDERDOC_Key_F12);

m_CaptureKeys.push_back(eRENDERDOC_Key_PrtScrn);

m_ExHandler = NULL;

m_Overlay = eRENDERDOC_Overlay_Default;

m_VulkanCheck = NULL;

m_VulkanInstall = NULL;

m_TargetControlThreadShutdown = false;

m_ControlClientThreadShutdown = false;

ClearTrackedFiles();

{

Callstack::Init();

Network::Init();

Threading::Init();

#if !RENDERDOC_STABLE_BUILD

Superluminal::Init();

#endif

m_RemoteIdent = 0;

m_RemoteThread = 0;

m_TimeBase = 0;

m_TimeFrequency = 1.0;

if(!IsReplayApp())

{

m_TimeBase = Timing::GetTick();

m_TimeFrequency = Timing::GetTickFrequency() / 1000.0;

Process::ApplyEnvironmentModification();

uint32_t port = RenderDoc_FirstTargetControlPort;

Network::Socket *sock = Network::CreateServerSocket("0.0.0.0", port & 0xffff, 4);

while(sock == NULL)

{

port++;

if(port > RenderDoc_LastTargetControlPort)

{

m_RemoteIdent = 0;

break;

}

sock = Network::CreateServerSocket("0.0.0.0", port & 0xffff, 4);

}

if(sock)

{

m_RemoteIdent = port;

m_TargetControlThreadShutdown = false;

m_RemoteThread = Threading::CreateThread([sock]() { TargetControlServerThread(sock); });

RDCLOG("Listening for target control on %u", port);

}

else

{

RDCWARN("Couldn't open socket for target control");

}

}

// set default capture log - useful for when hooks aren't setup

// through the UI (and a log file isn't set manually)

{

rdcstr capture_filename;

const rdcstr base = IsReplayApp() ? "RenderDoc" : "RenderDoc_app";

FileIO::GetDefaultFiles(base, capture_filename, m_LoggingFilename, m_Target);

if(m_CaptureFileTemplate.empty())

SetCaptureFileTemplate(capture_filename);

RDCLOGFILE(m_LoggingFilename.c_str());

}

const char *platform =

#if ENABLED(RDOC_WIN32)

"Windows";

#elif ENABLED(RDOC_LINUX)

"Linux";

#elif ENABLED(RDOC_ANDROID)

"Android";

#elif ENABLED(RDOC_APPLE)

"macOS";

#else

"Unknown";

#endif

RDCLOG("RenderDoc v%s %s %s %s (%s) %s", MAJOR_MINOR_VERSION_STRING, platform,

sizeof(uintptr_t) == sizeof(uint64_t) ? "64-bit" : "32-bit",

ENABLED(RDOC_RELEASE) ? "Release" : "Development", GitVersionHash,

IsReplayApp() ? "loaded in replay application" : "capturing application");

#if defined(DISTRIBUTION_VERSION)

RDCLOG("Packaged for %s (%s) - %s", DISTRIBUTION_NAME, DISTRIBUTION_VERSION, DISTRIBUTION_CONTACT);

#endif

#if defined(RENDERDOC_HOOK_DLSYM)

RDCWARN("dlsym() hooking enabled!");

#endif

if(!IsReplayApp())

{

if(m_RemoteIdent == 0)

RDCWARN("Couldn't open socket for target control");

else

RDCDEBUG("Listening for target control on %u", m_RemoteIdent);

}

Keyboard::Init();

m_FrameTimer.InitTimers();

m_ExHandler = NULL;

ClearTrackedFiles();

RecreateCrashHandler();

// begin printing to stdout/stderr after this point, earlier logging is debugging

// cruft that we don't want cluttering output.

// However we don't want to print in captured applications, since they may be outputting important

// information to stdout/stderr and being piped around and processed!

if(IsReplayApp())

RDCLOGOUTPUT();

if(IsReplayApp())

{

for(auto it = m_EnvSetups.begin(); it != m_EnvSetups.end(); ++it)

(*it)();

m_EnvSetups.clear();

}

ProcessConfig();

{

if(m_ExHandler)

{

UnloadCrashHandler();

}

if(m_RemoteThread)

{

// explicitly wait for thread to shutdown, this call is not from module unloading and

// we want to be sure everything is gone before we remove our module & hooks

m_TargetControlThreadShutdown = true;

Threading::JoinThread(m_RemoteThread);

Threading::CloseThread(m_RemoteThread);

m_RemoteThread = 0;

}

{

if(!IsReplayApp())

{

RDCERR(

"Initialising replay within non-replaying app. Did you properly export replay marker in "

"host executable or library, or are you trying to replay directly with a self-hosted "

"capture build?");

}

m_GlobalEnv = env;

#if ENABLED(RDOC_LINUX) && ENABLED(RDOC_XLIB)

if(!m_GlobalEnv.xlibDisplay)

m_GlobalEnv.xlibDisplay = XOpenDisplay(NULL);

#endif

rdcstr exename;

FileIO::GetExecutableFilename(exename);

RDCLOG("Replay application '%s' launched", exename.c_str());

if(!args.empty())

{

for(size_t i = 0; i < args.size(); i++)

RDCLOG("Parameter [%u]: %s", (uint32_t)i, args[i].c_str());

}

if(args.contains("--crash"))

UnloadCrashHandler();

else

RecreateCrashHandler();

if(env.enumerateGPUs)

{

m_AvailableGPUThread = Threading::CreateThread([this]() {

rdcarray<rdcstr> driverFilePaths;

for(GraphicsAPI api : {GraphicsAPI::D3D11, GraphicsAPI::D3D12, GraphicsAPI::Vulkan})

{

RDCDriver driverType = RDCDriver::Unknown;

switch(api)

{

case GraphicsAPI::D3D11: driverType = RDCDriver::D3D11; break;

case GraphicsAPI::D3D12: driverType = RDCDriver::D3D12; break;

case GraphicsAPI::OpenGL: break;

case GraphicsAPI::Vulkan: driverType = RDCDriver::Vulkan; break;

}

if(driverType == RDCDriver::Unknown || !HasReplayDriver(driverType))

continue;

IReplayDriver *driver = NULL;

RDResult result = m_ReplayDriverProviders[driverType](NULL, ReplayOptions(), &driver);

if(result == ResultCode::Succeeded)

{

rdcarray<GPUDevice> gpus = driver->GetAvailableGPUs();

#if ENABLED(RDOC_WIN32)

for(const char *driverDLL : {

"amdvlk32.dll", "amdvlk64.dll", "atiadlxx.dll", "atig6pxx.dll",

"atig6txx.dll", "atigktxx.dll", "atiglpxx.dll", "atimuixx.dll",

"atio6axx.dll", "atioglxx.dll", "ControlLib.dll", "ControlLib32.dll",

"igd10iumd32.dll", "igd10iumd64.dll", "igd12umd32.dll", "igd12umd64.dll",

"igc32.dll", "igc64.dll", "igvk32.dll", "igvk64.dll",

"igxelpgicd32.dll", "igxelpgicd64.dll", "igxelpicd32.dll", "igxelpicd32.dll",

"igxelpicd64.dll", "igxelpicd64.dll", "nvoglv32.dll", "nvoglv64.dll",

"nvwgf2um.dll", "nvwgf2umx.dll",

})

{

HMODULE mod = GetModuleHandleA(driverDLL);

if(mod)

{

wchar_t curFile[512] = {0};

GetModuleFileNameW(mod, curFile, 511);

rdcstr path = StringFormat::Wide2UTF8(curFile);

if(!driverFilePaths.contains(path))

driverFilePaths.push_back(path);

}

}

#endif

for(const GPUDevice &newgpu : gpus)

{

bool addnew = true;

for(GPUDevice &oldgpu : m_AvailableGPUs)

{

// if we have this GPU listed already, just add its API to the previous list

if(oldgpu == newgpu)

{

oldgpu.apis.push_back(api);

addnew = false;

}

}

if(addnew)

m_AvailableGPUs.push_back(newgpu);

}

}

else

{

RDCWARN("Couldn't create proxy replay driver for %s: %s", ToStr(driverType).c_str(),

ResultDetails(result).Message().c_str());

}

if(driver)

driver->Shutdown();

}

// we now have a list of GPUs, however we might have some duplicates if some APIs have

// multiple drivers for a single device. To compact this list, for each GPU with no driver

// we find all matching multi-drive GPUs and merge it into all matching copies.

bool hasDriverNames = false;

for(size_t i = 0; i < m_AvailableGPUs.size(); i++)

hasDriverNames |= !m_AvailableGPUs[i].driver.empty();

if(hasDriverNames)

{

for(size_t i = 0; i < m_AvailableGPUs.size();)

{

bool applied = false;

if(!m_AvailableGPUs[i].driver.empty())

{

i++;

continue;

}

// scan all subsequent GPUs, if we find a duplicate, merge the APIs

for(size_t j = i + 1; j < m_AvailableGPUs.size(); j++)

{

if(m_AvailableGPUs[i].vendor == m_AvailableGPUs[j].vendor &&

m_AvailableGPUs[i].deviceID == m_AvailableGPUs[j].deviceID)

{

RDCASSERT(!m_AvailableGPUs[j].driver.empty());

for(GraphicsAPI a : m_AvailableGPUs[i].apis)

{

if(m_AvailableGPUs[j].apis.indexOf(a) == -1)

m_AvailableGPUs[j].apis.push_back(a);

}

applied = true;

}

}

// we "applied" this GPU to all its driver-based duplicates, so we can remove it now

if(applied)

{

m_AvailableGPUs.erase(i);

}

else

{

i++;

}

}

}

// sort the APIs list in each GPU, and sort the GPUs

std::sort(m_AvailableGPUs.begin(), m_AvailableGPUs.end());

for(GPUDevice &dev : m_AvailableGPUs)

{

std::sort(dev.apis.begin(), dev.apis.end());

RDCLOG("GPU: %s - %s (driver: %s)", ToStr(dev.vendor).c_str(), dev.name.c_str(),

dev.driver.empty() ? "--" : dev.driver.c_str());

}