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 🙏