JsGPUOpenMaterialLoader Class Reference

Class to download MaterialX materials from the GPUOpen material database. More...

Public Member Functions
	constructor ()
	Constructor for the JsGPUOpenMaterialLoader class.
	loadMaterialsFromCache ()
	getMaterialList ()
	Return downloaded material list.
	getMaterialNames ()
	Return downloaded material names.
async	getMaterials (batchSize=50)
	Get lists of materials from the GPUOpen material database.
async	downloadPackage (listNumber, materialNumber, packageId=0)
	findMaterialsByName (materialName)
	Find materials by name.
async	downloadPackageByExpression (searchExpr, packageId=0)
	Download a material package by string expression.

Detailed Description

Class to download MaterialX materials from the GPUOpen material database.

The class provides methods to fetch materials and download material packages. The class uses the fetch API to make HTTP requests. The class is intended to be used in a Node.js environment.

Definition at line 18 of file JsGPUOpenMaterialLoader.js.

Member Function Documentation

constructor()

JsGPUOpenMaterialLoader::constructor

(

)

Constructor for the JsGPUOpenMaterialLoader class.

Definition at line 23 of file JsGPUOpenMaterialLoader.js.

                  {
        if (JsGPUOpenMaterialLoader.instance) {
            return JsGPUOpenMaterialLoader.instance;
        }
 
        this.rootUrl = 'https://api.matlib.gpuopen.com/api';
        this.url = `${this.rootUrl}/materials`;
        this.packageUrl = `${this.rootUrl}/packages`;
        this.materials = null;
        this.materialNames = null;
 
        this.logger = console;
 
        // Cache the instance
        JsGPUOpenMaterialLoader.instance = this;
    }

downloadPackage()

async JsGPUOpenMaterialLoader::downloadPackage	(		listNumber,
			materialNumber,
			packageId = 0 )

Definition at line 157 of file JsGPUOpenMaterialLoader.js.

                                                                     {
        if (this.materials === null || this.materials.length === 0) {
            return [null, null];
        }
 
        const jsonData = this.materials[listNumber];
        if (!jsonData) {
            return [null, null];
        }
 
        let jsonResults = null;
        let jsonResult = null;
        if ('results' in jsonData) {
            jsonResults = jsonData['results'];
            if (jsonResults.length <= materialNumber) {
                return [null, null];
            } else {
                jsonResult = jsonResults[materialNumber];
            }
        }
 
        if (!jsonResult) {
            return [null, null];
        }
 
        let jsonPackages = null;
        if ('packages' in jsonResult) {
            jsonPackages = jsonResult['packages'];
        }
        if (!jsonPackages) {
            return [null, null];
        }
 
        if (jsonPackages.length <= packageId) {
            return [null, null];
        }
        const packageIdValue = jsonPackages[packageId];
 
        if (!packageIdValue) {
            return [null, null];
        }
 
        const url = `${this.packageUrl}/${packageIdValue}/download`
        const response = await fetch(url);
        const data = await response.arrayBuffer();
        const title = jsonResult['title'];
 
        console.log(`- Loader: Downloaded package: ${title} from ${url}`);
        return [data, title];
    }

downloadPackageByExpression()

async JsGPUOpenMaterialLoader::downloadPackageByExpression	(		searchExpr,
			packageId = 0 )

Download a material package by string expression.

Parameters

{string}	searchExpr - Regular expression to match the material name
{number}	packageId - Index of the package in the material

Returns

{Array} - A list of material items that match the regular expression of the form: [[data, title], [data, title], ...] where data is the package data (in zip form) and title is the material title

Definition at line 256 of file JsGPUOpenMaterialLoader.js.

                                                                 {
        const downloadList = [];
 
        const foundList = this.findMaterialsByName(searchExpr);
        if (foundList.length > 0) {
            for (const found of foundList) {
                const listNumber = found['listNumber'];
                const materialNumber = found['materialNumber'];
                const matName = found['title'];
                this.logger.info(`> Download material: ${matName} List: ${listNumber}. Index: ${materialNumber}`);
                const [data, title] = await this.downloadPackage(listNumber, materialNumber, packageId);
                downloadList.push([data, title]);
            }
        }
        return downloadList;
    }

findMaterialsByName()

JsGPUOpenMaterialLoader::findMaterialsByName

(

materialName

)

Find materials by name.

Parameters

{string}

materialName - Regular expression to match the material name.

Returns

{Array} - A list of materials that match the regular expression of the form: [{ 'listNumber': listNumber, 'materialNumber': materialNumber, 'title': title }]

Definition at line 214 of file JsGPUOpenMaterialLoader.js.

    {
        if (!this.materials) {
            return [];
        }
 
        const materialsList = [];
        let listNumber = 0;
 
        // Create a RegExp object for case-insensitive matching
        const regex = new RegExp(materialName, 'i');
 
        this.materials.forEach((materialList, materialIndex) => {
            let materialNumber = 0;
 
            materialList['results'].forEach((material) => {
 
                //console.log('testing material:', material['title'], ' with regex:', regex)
                if (regex.test(material['title'])) {
                    materialsList.push({
                        listNumber: listNumber,
                        materialNumber: materialNumber,
                        title: material['title'],
                    });
                }
                materialNumber += 1;
            });
 
            listNumber += 1;
        });
 
        return materialsList;
    }

getMaterialList()

JsGPUOpenMaterialLoader::getMaterialList

(

)

Return downloaded material list.

Returns

{Array} - List of materials

Definition at line 63 of file JsGPUOpenMaterialLoader.js.

                      {
        // Save to cache file after fetching
        try {
            fs.writeFileSync(MATERIALS_CACHE_FILE, JSON.stringify(this.materials, null, 2));
            this.logger.info(`Saved GPUOpen materials to cache: ${MATERIALS_CACHE_FILE}`);
        } catch (e) {
            this.logger.warn(`Failed to write GPUOpen materials cache: ${e.message}`);
        }
        return this.materials;
    }

getMaterialNames()

JsGPUOpenMaterialLoader::getMaterialNames

(

)

Return downloaded material names.

Returns

{Array} - List of material names

Definition at line 78 of file JsGPUOpenMaterialLoader.js.

                       {
        return this.materialNames;
    }

getMaterials()

async JsGPUOpenMaterialLoader::getMaterials

(

batchSize = 50

)

Get lists of materials from the GPUOpen material database.

Parameters

{number}

batchSize - Number of materials to fetch per batch

Returns

{Array} - List of material lists

Definition at line 87 of file JsGPUOpenMaterialLoader.js.

                                       {
        // 1. Try to load from cache file
        if (fs.existsSync(MATERIALS_CACHE_FILE)) {
            try {
                const data = fs.readFileSync(MATERIALS_CACHE_FILE, 'utf8');
                this.materials = JSON.parse(data);
                // Rebuild materialNames
                this.materialNames = [];
                for (const jsonData of this.materials) {
                    for (const material of jsonData.results) {
                        this.materialNames.push(material['title']);
                    }
                }
                this.logger.info(`Loaded GPUOpen materials from cache: ${MATERIALS_CACHE_FILE}`);
                return this.materials;
            } catch (e) {
                this.logger.warn(`Failed to load GPUOpen materials cache: ${e.message}`);
            }
        }
 
        // 2. If not in cache, fetch from network
        this.materials = [];
        this.materialNames = [];
 
        let url = this.url;
        let params = new URLSearchParams({
            limit: batchSize,
            offset: 0
        });
        if (params) {
            url += '?' + params.toString();
        }
 
        let haveMoreMaterials = true;
        while (haveMoreMaterials) {
            try {
                console.log('Fetch materials from url:', url);
                const response = await fetch(url);
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }
                const jsonData = await response.json();
                this.materials.push(jsonData);
                for (const material of jsonData.results) {
                    this.materialNames.push(material['title']);
                }
                let nextURL = jsonData.next;
                if (nextURL) {
                    url = nextURL;
                    haveMoreMaterials = true;
                } else {
                    console.log('Finished fetching materials');
                    haveMoreMaterials = false;
                    break;
                }
            } catch (error) {
                this.logger.info(`Error: ${error.message}`);
                haveMoreMaterials = true;
            }
        }
        // Save to cache file after fetching
        try {
            fs.writeFileSync(MATERIALS_CACHE_FILE, JSON.stringify(this.materials, null, 2));
            this.logger.info(`Saved GPUOpen materials to cache: ${MATERIALS_CACHE_FILE}`);
        } catch (e) {
            this.logger.warn(`Failed to write GPUOpen materials cache: ${e.message}`);
        }
        return this.materials;
    }

loadMaterialsFromCache()

JsGPUOpenMaterialLoader::loadMaterialsFromCache

(

)

Definition at line 40 of file JsGPUOpenMaterialLoader.js.

                             {
        if (fs.existsSync(MATERIALS_CACHE_FILE)) {
            try {
                const data = fs.readFileSync(MATERIALS_CACHE_FILE, 'utf8');
                this.materials = JSON.parse(data);
                // Rebuild materialNames
                this.materialNames = [];
                for (const jsonData of this.materials) {
                    for (const material of jsonData.results) {
                        this.materialNames.push(material['title']);
                    }
                }
                this.logger.info(`Loaded GPUOpen materials from cache: ${MATERIALS_CACHE_FILE}`);
            } catch (e) {
                this.logger.warn(`Failed to load GPUOpen materials cache: ${e.message}`);
            }
        }
    }

---

The documentation for this class was generated from the following file:

• JsGPUOpenMaterialLoader.js