Is there a solution to disable file splitting when running the command?

[Zego92]

Hello
I tried to optimize my gltf files using the next command
gltf-transform optimize input/first.gltf output/first.gltf --compress draco --texture-compress ktx2
as a result, I have separated specific files with the next formats:

• .ktx2 files
• bin files
• gltf file

Is there any way to avoid creating these additional files and have them included in a single gltf format file?

Thanks for help!

[donmccurdy]

Hi @Zego92!

If you'd like self-contained output with textures and other resources embedded, you can write to a .glb file instead of .gltf:

gltf-transform optimize input/first.gltf output/first.glb --compress draco --texture-compress ktx2

[Zego92]

Hello @donmccurdy
yeah, I know that decision
but it doesn't work for me.
in these case, I need only gltf format

[donmccurdy]

I see! In that case, no, the CLI does not offer a way to write .gltf files with textures and other resources embedded. It always uses external resources for .gltf extensions.

[Zego92]

Thanks for clarification
Lets take a look in another case
A have a script
Could you please share information how I can modify these file to combine all executed files while script has been executed
Maybee install specific libraries or something else
Ofc if it possible

`
const fs = require('fs');
const path = require('path');
const { exec } = require('child_process');
const { promisify } = require('util');
const { NodeIO } = require('@gltf-transform/core');
const { KHRONOS_EXTENSIONS } = require('@gltf-transform/extensions');
const draco3d = require('draco3d');

const readdir = promisify(fs.readdir);
const mkdir = promisify(fs.mkdir);
const writeFile = promisify(fs.writeFile);
const execAsync = promisify(exec);

const inputDir = path.join(__dirname, 'input');
const outputDir = path.join(__dirname, 'output');

async function convertTextureToKtx2(inputPath, outputPath) {
await execAsync(toktx --t2 --uastc --uastc_rdo_l 0.5 ${outputPath} ${inputPath});
}

async function convertGltfToKtx2(gltfFilePath, outputFilePath) {
const io = new NodeIO()
.registerExtensions(KHRONOS_EXTENSIONS)
.registerDependencies({
'draco3d.decoder': await draco3d.createDecoderModule(),
'draco3d.encoder': await draco3d.createEncoderModule(),
});

const document = await io.read(gltfFilePath);

const textures = document.getRoot().listTextures();

const modelName = path.basename(gltfFilePath, path.extname(gltfFilePath));
const modelOutputDir = path.join(outputDir, modelName);
if (!fs.existsSync(modelOutputDir)) {
    fs.mkdirSync(modelOutputDir, { recursive: true });
}

for (const texture of textures) {
    const textureName = texture.getName() || `texture_${texture.getURI() || 'embedded'}`;
    let inputTexturePath;

    if (texture.getURI()) {
        inputTexturePath = path.join(path.dirname(gltfFilePath), texture.getURI());
    } else {
        const textureData = texture.getImage();
        if (!textureData) {
            console.warn(`Texture ${textureName} has no image data. Skipping...`);
            continue;
        }

        inputTexturePath = path.join(modelOutputDir, `${textureName}.png`);
        await writeFile(inputTexturePath, textureData);
    }

    const outputTexturePath = path.join(modelOutputDir, `${textureName}.ktx2`);
    console.log({ textureName, inputTexturePath, outputTexturePath });

    console.log(`Converting texture ${textureName} to KTX2...`);
    await convertTextureToKtx2(inputTexturePath, outputTexturePath);

    texture.setURI(`${textureName}.ktx2`);

    if (!texture.getURI() && inputTexturePath.endsWith('.png')) {
        await fs.unlinkSync(inputTexturePath);
        console.log(`Deleted temporary file: ${inputTexturePath}`);
    }
}

await io.write(path.join(modelOutputDir, path.basename(outputFilePath)), document);

}

async function main() {
try {
const files = await readdir(inputDir);

    if (!fs.existsSync(outputDir)) {
        await mkdir(outputDir);
    }

    for (const file of files) {
        if (path.extname(file).toLowerCase() === '.gltf' || path.extname(file).toLowerCase() === '.glb') {
            const inputFilePath = path.join(inputDir, file);
            const outputFilePath = path.join(outputDir, file);

            console.log(`Converting ${file}...`);
            await convertGltfToKtx2(inputFilePath, outputFilePath);
            console.log(`Converted ${file} successfully!`);
        }
    }
} catch (error) {
    console.error('Error:', error);
}

}

main();
`
🙏

[Zego92]

@donmccurdy 🙏

[donmccurdy]

@Zego92 it's certainly possible to bundle the files into a .gltf with resources embedded. I would start by writing a .gltf with external resources first, then read the .gltf file into memory (it's JSON) and inspect the .images and .buffers arrays in that JSON. For each URI in the images or textures you'd need to read that file from disk, encode it as a Data URL, replace the URI in the JSON with that Data URL, and then write the final JSON to disk as a .gltf file. Shouldn't need any additional libraries for that, languages like JavaScript can read/write JSON and Data URIs without dependencies.