JsAmbientCGLoader.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 { Writable } = require('stream');
const { createGunzip } = require('zlib');
const { parse } = require('csv-parse/sync');
 
class AmbientCGLoader {
    constructor() {
        if (AmbientCGLoader.instance) {
            return AmbientCGLoader.instance;
        }
 
        this.logger = console;
        this.database = {};
        this.assets = {};
        this.materials = null;
        this.materialNames = [];
        this.csvMaterials = null;
        this.downloadMaterial = null;
        this.downloadMaterialFileName = '';
 
        // Cache the instance
        AmbientCGLoader.instance = this;
    }
 
    loadMaterialsFromCache() {
        const MATERIALS_CACHE_FILE = 'ambientcg_materials.json';
        if (fs.existsSync(MATERIALS_CACHE_FILE)) {
            try {
                const data = fs.readFileSync(MATERIALS_CACHE_FILE, 'utf8');
                this.materials = JSON.parse(data);
                this.logger.info(`Loaded AmbientCG materials from cache: ${MATERIALS_CACHE_FILE}`);
            } catch (e) {
                this.logger.warn(`Failed to load AmbientCG materials cache: ${e.message}`);
            }
        }
    }
 
    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}`;
    }
 
    splitDownloadAttribute(downloadAttribute) {
        const parts = downloadAttribute.split('-');
    }
 
    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];
        console.log('>>>> URL:', url, 'Filename:', this.downloadMaterialFileName);
 
        try {
            const response = await fetch(url);
            if (!response.ok) {
                throw new Error(`HTTP error! Status: ${response.status}`);
            }
        
            // Get the response as an ArrayBuffer
            const arrayBuffer = await response.arrayBuffer();
        
            // Convert ArrayBuffer to Buffer
            this.downloadMaterial = Buffer.from(arrayBuffer);
            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 MATERIALS_CACHE_FILE = 'ambientcg_materials.json';
        // 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);
                this.logger.info(`Loaded AmbientCG materials from cache: ${MATERIALS_CACHE_FILE}`);
                return this.materials;
            } catch (e) {
                this.logger.warn(`Failed to load AmbientCG materials cache: ${e.message}`);
            }
        }
 
        // 2. If not in cache, fetch from network
        const headers = { Accept: 'application/csv' };
        const url = new URL('https://ambientCG.com/api/v2/downloads_csv');
        url.searchParams.append('method', 'PBRPhotogrammetry');
        url.searchParams.append('type', 'Material');
        url.searchParams.append('sort', 'Alphabet');
 
        this.logger.info('Downloading materials CSV list from network...');
        try {
            const response = await fetch(url, { headers });
            if (response.status === 200) {
                const csvContent = await response.text();
                this.csvMaterials = csvContent;
                this.materials = parse(csvContent, { columns: true });
                this.logger.info('Downloaded CSV material list as JSON.');
                // Save to cache file after fetching
                try {
                    fs.writeFileSync(MATERIALS_CACHE_FILE, JSON.stringify(this.materials, null, 2));
                    this.logger.info(`Saved AmbientCG materials to cache: ${MATERIALS_CACHE_FILE}`);
                } catch (e) {
                    this.logger.warn(`Failed to write AmbientCG materials cache: ${e.message}`);
                }
            } 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 = new AmbientCGLoader();