JsAmbientCGLoader.js

const axios = require('axios');
const fs = require('fs');
const { Writable } = require('stream');
const { createGunzip } = require('zlib');
const { parse } = require('csv-parse/sync');
 
class AmbientCGLoader {
    constructor(mxModule, mxStdlib = null) {
        this.logger = console;
        this.database = {};
        this.assets = {};
        this.materials = null;
        this.materialNames = [];
        this.csvMaterials = null;
        this.downloadMaterial = null;
        this.downloadMaterialFileName = '';
        this.mx = mxModule;
        this.stdlib = mxStdlib;
        this.supportOpenPBR = false;
 
        if (!mxModule) {
            this.logger.error('MaterialX module not specified.');
            return;
        }
 
        // Check for OpenPBR support (placeholder logic)
        const version = this.mx.getVersionIntegers();
        this.logger.info(`Using MaterialX version: ${version.join('.')}`);
        if (version[0] >= 1 && version[1] >= 39) || version[0] > 1) {
            this.logger.debug('OpenPBR shading model supported');
            this.supportOpenPBR = true;
        }
 
        // Load the MaterialX standard library if not provided
        if (!this.stdlib) {
            this.stdlib = this.mx.createDocument();
            const libFiles = this.mx.loadLibraries(this.mx.getDefaultDataLibraryFolders(), this.mx.getDefaultDataSearchPath(), this.stdlib);
            this.logger.debug(`Loaded standard library: ${libFiles}`);
        }
    }
 
    setDebugging(debug = true) {
        this.logger.level = debug ? 'debug' : 'info';
    }
 
    getMaterialNames(key = 'assetId') {
        this.materialNames = [];
        const uniqueNames = new Set();
        if (this.materials) {
            this.materials.forEach(item => uniqueNames.add(item[key]));
        }
        this.materialNames = Array.from(uniqueNames).sort();
        return this.materialNames;
    }
 
    writeMaterialList(materialList, filename) {
        this.logger.info(`Writing material list to file: ${filename}`);
        fs.writeFileSync(filename, JSON.stringify(materialList, null, 4));
    }
 
    buildDownloadAttribute(imageFormat = 'PNG', imageResolution = '1') {
        return `${imageResolution}K-${imageFormat}`;
    }
 
    getDownloadedMaterialInformation() {
        return {
            filename: this.downloadMaterialFileName,
            content: this.downloadMaterial
        };
    }
 
    clearDownloadMaterial() {
        if (this.downloadMaterial) {
            this.downloadMaterial = null;
        }
        this.downloadMaterialFileName = '';
    }
 
    writeDownloadedMaterialToFile(path = '') {
        const haveDownload = this.downloadMaterialFileName && this.downloadMaterial;
        if (!haveDownload) {
            this.logger.warning('No current material downloaded');
            return;
        }
 
        const filename = `${path}/${this.downloadMaterialFileName}`;
        fs.writeFileSync(filename, this.downloadMaterial);
        this.logger.info(`Saved downloaded material to: ${filename}`);
    }
 
    async downloadMaterialAsset(assetId, imageFormat = 'PNG', imageResolution = '1', downloadAttributeKey = 'downloadAttribute', downloadLinkKey = 'downloadLink') {
        this.clearDownloadMaterial();
 
        const items = this.findMaterial(assetId);
        const target = this.buildDownloadAttribute(imageFormat, imageResolution);
        let url = '';
        let downloadAttribute = '';
 
        items.forEach(item => {
            downloadAttribute = item[downloadAttributeKey];
            if (downloadAttribute === target) {
                url = item[downloadLinkKey];
                this.logger.info(`Found Asset: ${assetId}. Download Attribute: ${downloadAttribute} -> ${url}`);
            }
        });
 
        if (!url) {
            this.logger.error(`No download link found for asset: ${assetId}, attribute: ${target}`);
            return '';
        }
 
        this.downloadMaterialFileName = url.split('file=')[1];
 
        try {
            const response = await axios.get(url, { responseType: 'arraybuffer' });
            this.downloadMaterial = Buffer.from(response.data, 'binary');
            this.logger.info(`Material file downloaded: ${this.downloadMaterialFileName}`);
        } catch (error) {
            this.downloadMaterialFileName = '';
            this.logger.error(`Error occurred while downloading the file: ${error}`);
        }
 
        return this.downloadMaterialFileName;
    }
 
    findMaterial(assetId, key = 'assetId') {
        if (this.materials) {
            return this.materials.filter(item => item[key] === assetId);
        }
        return [];
    }
 
    loadMaterialsList(fileName) {
        this.materials = JSON.parse(fs.readFileSync(fileName, 'utf8'));
        this.logger.info(`Loaded materials list from: ${fileName}`);
        return this.materials;
    }
 
    async downloadMaterialsList() {
        const url = 'https://ambientCG.com/api/v2/downloads_csv';
        const headers = { Accept: 'application/csv' };
        const params = {
            method: 'PBRPhotogrammetry',
            type: 'Material',
            sort: 'Alphabet',
        };
 
        this.logger.info('Downloading materials CSV list...');
        try {
            const response = await axios.get(url, { headers, params });
            if (response.status === 200) {
                const csvContent = response.data;
                this.csvMaterials = csvContent;
                //this.materials = parse(csvContent, { columns: true });
                this.logger.info('Downloaded CSV material list as JSON.');
            } else {
                this.materials = null;
                this.logger.warning(`Failed to fetch the CSV material content. HTTP status code: ${response.status}`);
            }
        } catch (error) {
            this.materials = null;
            this.logger.error(`Error downloading materials list: ${error}`);
        }
 
        return this.materials;
    }
 
    getDataBase() {
        return this.database;
    }
 
    getDataBaseMaterialList() {
        return this.assets;
    }
 
    async downloadAssetDatabase() {
        this.database = {};
        this.assets = null;
 
        const url = 'https://ambientcg.com/api/v2/full_json';
        const headers = { Accept: 'application/json' };
        const params = {
            method: 'PBRPhotogrammetry',
            type: 'Material',
            sort: 'Alphabet',
        };
 
        try {
            const response = await axios.get(url, { headers, params });
            if (response.status === 200) {
                this.database = response.data;
                this.assets = this.database.foundAssets;
            } else {
                this.logger.error(`Status: ${response.status}, ${response.data}`);
            }
        } catch (error) {
            this.logger.error(`Error downloading asset database: ${error}`);
        }
 
        return this.database;
    }
 
    writeDatabaseToFile(filename) {
        if (!this.database) {
            this.logger.warning('No database to write');
            return false;
        }
 
        fs.writeFileSync(filename, JSON.stringify(this.database, null, 4));
        return true;
    }
 
    validateMaterialXDocument(doc) {
        if (!this.mx) {
            this.logger.error('MaterialX module is required');
            return [false, ''];
        }
 
        if (!doc) {
            this.logger.warning('MaterialX document is required');
            return [false, ''];
        }
 
        const valid = doc.validate();
        return [valid, valid ? '' : 'Validation failed'];
    }
 
    addComment(doc, commentString) {
        const comment = doc.addChildOfCategory('comment');
        comment.setDocString(commentString);
    }
 
    getMaterialXString(doc) {
        if (!this.mx) {
            this.logger.error('MaterialX module is required');
            return;
        }
 
        const writeOptions = this.mx.XmlWriteOptions();
        writeOptions.writeXIncludeEnable = false;
        writeOptions.elementPredicate = this.skipLibraryElement;
        return this.mx.writeToXmlString(doc, writeOptions);
    }
}
 
module.exports = AmbientCGLoader;