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.
	getMaterialPreviews ()
	Return downloaded material previews.
	getMaterialNames ()
	Return downloaded material names.
async	getPreviews ()
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 19 of file JsGPUOpenMaterialLoader.js.

Member Function Documentation

constructor()

JsGPUOpenMaterialLoader::constructor

(

)

Constructor for the JsGPUOpenMaterialLoader class.

Definition at line 24 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.previews = null;
 
        this.logger = console;
 
        // Cache the instance
        JsGPUOpenMaterialLoader.instance = this;
    }

downloadPackage()

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

Definition at line 205 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 304 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 262 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 74 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 104 of file JsGPUOpenMaterialLoader.js.

                       {
        return this.materialNames;
    }

getMaterialPreviews()

JsGPUOpenMaterialLoader::getMaterialPreviews

(

)

Return downloaded material previews.

Returns

{Array} - List of material previews

Definition at line 89 of file JsGPUOpenMaterialLoader.js.

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

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 135 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 2: ${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;
    }

getPreviews()

async JsGPUOpenMaterialLoader::getPreviews

(

)

Definition at line 108 of file JsGPUOpenMaterialLoader.js.

                        {
    
        // try load previews from cache file
        if (fs.existsSync(MATERIALS_PREVIEW_FILE)) {
            try {
                const data = fs.readFileSync(MATERIALS_PREVIEW_FILE, 'utf8');
                //console.log('preview data', data);
                this.previews = JSON.parse(data);
                this.logger.info(`Loaded GPUOpen material previews from cache 2: ${MATERIALS_PREVIEW_FILE}`);
                //this.logger.info(`GPUOpen material previews: ${this.previews}`);
                return this.previews;
            } catch (e) {
                this.logger.warn(`Failed to load GPUOpen material previews cache: ${e.message}`);
            }
        }
        else {
            this.logger.info(`No GPUOpen material previews cache found.`);
            this.previews = [];
        }   
        return this.previews;
    }

loadMaterialsFromCache()

JsGPUOpenMaterialLoader::loadMaterialsFromCache

(

)

Definition at line 42 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}`);
            }
        }
        if (fs.existsSync(MATERIALS_PREVIEW_FILE)) {
            try {
                const data = fs.readFileSync(MATERIALS_PREVIEW_FILE, 'utf8');
                this.previews = JSON.parse(data);
                this.logger.info(`Loaded GPUOpen material previews from cache: ${MATERIALS_PREVIEW_FILE}`);
            } catch (e) {
                this.logger.warn(`Failed to load GPUOpen material previews cache: ${e.message}`);
            }
        }
    }

---

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

• JsGPUOpenMaterialLoader.js