Hardware Platforms

HOOPS Luminate is a hybrid engine, running both on the CPU and GPU of the host system. HOOPS Luminate runs on a wide range of GPUs that have a very broad range of capabilities. Therefore, GPU identification and support can be a challenge for an application that wishes to run on all types of hardware. HOOPS Luminate provides built-in services to help applications manage hardware detection.

The GPU and driver management services include:

A hardware identification API

A graphic driver detection API

HOOPS Luminate has a number of specific hardware features that can be available on some hardware classes and not on some others. See this page: GPU Functional Level to learn everything on hardware and on the functional level of each hardware class.

Finally, this chapter also discusses a few known hardware issues that apply mostly to legacy hardware. See here: Known Hardware Issues.

Common Hardware Issues

Besides pure hardware issues that may be problematic too, we generally refer to ‘hardware issue’ as any kind of display problem seen using an application rendering images with a GPU. As with any other graphic application, so called hardware issues may arise. The flow of software commands needed to display something on screen interferes with several pieces of software, stacked together. Among them, the most relevant for us are:

The operating system

The graphic driver

HOOPS Luminate

The operating system may contain bugs, as well as the graphic driver software and HOOPS Luminate of course. Besides that we have four kinds of problems that arise:

End users unaware of their system and how to manage it (for instance end-users not knowing how to install a driver for the GPU, or even not knowing what a GPU is)

Error codes returned from the API (a RED_DRV_FAIL error for instance is a good catch) using the application, eventually crashes in HOOPS Luminate

Application crashes at the driver level

Corrupted graphics showing up on screen

Each type of problem requires specific management and HOOPS Luminate delivers a few services that may be helpful:

In the case of an end user unfamiliar with graphics systems, the RED::IGraphicDevice interface can help identify the installed GPU and driver

Either the return code is documented and the application has made a mistake in using HOOPS Luminate, or this indicates a HOOPS Luminate problem and a bug should be submitted to Tech Soft 3D for fixing

Updating the system driver to the latest version provided by the operating system or GPU vendor may improve the reliability of the system and solve graphics corruption

Same as 3

Hardware Identification API

The hardware identification API allows you to get the list of GPUs available on the target system:

Identifying a Computer’s GPU

// Access the cluster's resource manager:
RED::Object* resmgr = RED::Factory::CreateInstance( CID_REDResourceManager );
// Get it's graphic device interface:
RED::IGraphicDevice* idevice = resmgr->As< RED::IGraphicDevice >();

// Query the list of all GPUs on the system:
RED::Vector< RED::GPUID > gpulist;
RC_TEST( idevice->GetLocalGPUs( gpulist, false ) );

// Displaying all found GPU names:
for( int i = 0; i < (int)gpulist.size(); i++ )
{
    int asicID = gpulist[i]._asicID;
    int vendorID = gpulist[i]._vendorID;
    RED::String name( gpulist[i]._name );
    // Do whatever appropriate here!
}

The RED::IGraphicDevice::GetLocalGPUs method retrieves all installed GPUs on the target computer. Note that some GPUs may not be found in HOOPS Luminate’s internal database. All GPUs newer than the release date of HOOPS Luminate are unknown to it. This means that HOOPS Luminate may not know the name of a GPU; however HOOPS Luminate knows the asicID and vendorID of the hardware, among other parameters, so it can uniquely identify it.

The RED::GPUID data structure provides information about each detected GPU, including its vendor ID, ASIC ID, and name when available.

Driver Identification API

The driver installed for a given GPU can be retrieved using the RED::IGraphicDevice interface:

A GPU’s Installed Driver

// Access the cluster's resource manager:
RED::Object* resmgr = RED::Factory::CreateInstance( CID_REDResourceManager );
// Get it's graphic device interface:
RED::IGraphicDevice* idevice = resmgr->As< RED::IGraphicDevice >();

// Query the list of all GPUs on the system:
RED::Vector< RED::GPUID > gpulist;
RC_TEST( idevice->GetLocalGPUs( gpulist, false ) );

// Retrieve the installed driver for the first GPU:
RED::String drivername, driverdll;
bool newer, older;
RC_TEST( idevice->GetLocalGPUDriver( drivername, driverdll, newer, older, gpulist[0]) );

The RED::IGraphicDevice::GetLocalGPUDriver looks for the driver installed for the specified GPU. Note that the GPU must be present on the local computer (therefore, it should have been retrieved by a RED::IGraphicDevice::GetLocalGPUs).

This allows applications to identify the currently installed driver for diagnostic and informational purposes.

Driver Update Guideline

For optimal compatibility and performance, users should rely on drivers provided by their operating system or GPU vendor. Key considerations:

Handling Driver Installation Failures

Note

Even if a GPU is not explicitly known to HOOPS Luminate, HOOPS Luminate should be able to use it. Simply start HOOPS Luminate normally, and see if the RED::Factory::CreateREDWindow call works. If it returns RED_DRV_UNSUPPORTED_GPU, then HOOPS Luminate cannot use that GPU. Otherwise, HOOPS Luminate should be working.