JsGPUOpenMaterialLoader.js

 
 
// Use global fetch if available (Node.js v18+), otherwise use node-fetch
const fetch =
    typeof globalThis.fetch === 'function'
        ? globalThis.fetch
        : (...args) => import('node-fetch').then(({ default: fetch }) => fetch(...args));
const fs = require('fs');
const MATERIALS_CACHE_FILE = 'gpuopen_materials.json';
const MATERIALS_PREVIEW_FILE = 'gpuopen_previews.json';
 
class JsGPUOpenMaterialLoader {
 
    constructor() {
        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;
    }
 
    loadMaterialsFromCache() {
        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}`);
            }
        }
    }
    
    getMaterialList() {
        // 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;
    }

    getMaterialPreviews() {
        // 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;
    }

    getMaterialNames() {
        return this.materialNames;
    }
 
    async getPreviews() {
    
        // 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;
    }

    async getMaterials(batchSize = 50) {
        // 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;
    }
 
    async downloadPackage(listNumber, materialNumber, packageId = 0) {
        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];
    }

    findMaterialsByName(materialName) 
    {
        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;
    }

    async downloadPackageByExpression(searchExpr, packageId = 0) {
        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;
    }
}
 
// Export a singleton instance of the class
module.exports = new JsGPUOpenMaterialLoader();