Sharing same textures of different gltf PagedLODs

[avilkinnick]

Currently I load my gltf models through pagedLODs, but even if they have the same uri, renderdoc shows that the texture is loaded into memory as many times as the number of gltf files that contain the path to that texture. options->sharedObjects is created, but it doesn't help. How to load each texture only one time?
I thought about vsg::External, but I haven't seen in examples how to set it up and attach to root scene node

[robertosfield]

Ideally you'd want the vsg::DescriptorImage associated texture shared across the subgraphs. In principle the vsgXchange::assimp loader should attempt to find duplicates and then share the first instance that matches if you have the vsg::SharedObjects setup.

Whether you've set things up correctly, whether the textures are fully compatible and whether there might be issue in SharedObjects/vsgXchange::assimp is something I can't provide any guidance on as I simply don't know enough about your specific set of models and how you have set up and use the VSG.

[avilkinnick]

I have such folder structure for every route (it is railway simulator):

route_name
____models
________model1.gltf
________model1.bin
________model2.gltf
________model2.bin
____textures
________texture1.tga
________texture2.bmp

model1.gltf and model2.gltf both in image field have uri: "../textures/texture1.tga"

Next, in my program, I write:

options->sharedObjects = vsg::SharedObjects::create();
options->add(vsgXchange::all::create());

And later, to load objects of specified route:

for (auto& [label, transform] : route.transforms)
{
    auto found_it = route.object_ref.find(label);
    if (found_it == route.object_ref.end())
    {
        continue;
    }

    auto pagedLOD = vsg::PagedLOD::create();
    pagedLOD->bound = vsg::dsphere(vsg::dvec3(0.0, 0.0, 0.0), 200.0);
    pagedLOD->filename = route_dir_path + found_it->second;
    pagedLOD->options = options;

    auto matrix = vsg::MatrixTransform::create();
    matrix->matrix = transform;
    matrix->addChild(pagedLOD);

    root->addChild(matrix);
}

Same models with same .gltf path and filename seem to be shared, but multiple .gltf with same image "uri" create new texture for each of them

[robertosfield]

In principle what you are trying to do should be possible, but even with these extra details it's not possible to know what part is preventing the sharing.

Is you work open sourced? I'm not currently in the position to review code but perhaps others can, or later down the line when I have more time available could have a look.

[avilkinnick]

Yes, it is open-source, here is the link to file that I was shared code from: https://github.com/avilkinnick/RRS/blob/ANI4/viewer2/src/RouteViewer.cpp

[avilkinnick]

It seems that problem is inside VulkanSceneGraph/src/vsg/utils/GraphicsPipelineConfigurator.cpp in method DescriptorConfigurator::assignTexture:

bool DescriptorConfigurator::assignTexture(const std::string& name, ref_ptr<Data> textureData, ref_ptr<Sampler> sampler, uint32_t dstArrayElement)
{
    if (auto& textureBinding = shaderSet->getDescriptorBinding(name))
    {
        assigned.insert(name);

        // set up bindings
        if (!textureBinding.define.empty()) defines.insert(textureBinding.define);
        if (!sampler) sampler = Sampler::create();

        if (textureData)
        {
            if (textureBinding.coordinateSpace == vsg::CoordinateSpace::sRGB)
                textureData->properties.format = vsg::uNorm_to_sRGB(textureData->properties.format);
            else if (textureBinding.coordinateSpace == vsg::CoordinateSpace::LINEAR)
                textureData->properties.format = vsg::sRGB_to_uNorm(textureData->properties.format);
        }

        // create texture image and associated DescriptorSets and binding
        return assignDescriptor(textureBinding.set, textureBinding.binding, textureBinding.descriptorType, textureBinding.descriptorCount, textureBinding.stageFlags,
                                DescriptorImage::create(sampler, textureData ? textureData : textureBinding.data, textureBinding.binding, dstArrayElement, textureBinding.descriptorType));
    }
    return false;
}

Even though textureData is really shared, every time it creates a new DescriptorImage and so, it makes new copy of texture in graphics memory

[robertosfield]

Calls to vsg::SharedObjects after the DescriptorImage on the subgraph has been created should be able to spot the duplication and share it. While this should have possible in principle there may be code paths where this isn't happening.

What happens above the DescriptorConfigurator::assignTexture() is what will determine where the DescriptorImage can be shared.

[ArepMM]

I found why the same Image Descriptor already available in SharedObjects is not being used.
As already mentioned, we load multiple .gltf models with one texture file at their uri. When vsgXchange does the second image loading, Data from SharedObjects is successfully used.
Then new Image, Image Info, and DescriptorImage are created and checked for duplicates by share(). SharedObjects contains a duplicate, but it is different because it has already been compiled. Specifically, the Image parameters mipLevels and usage are different. Thus, the Image::compare() fails, and a new copy of the DescriptorImage is used, and a new copy of texture loaded into the GPU memory.

I found that mipLevels and usage are changed during compiling by ImageInfo::computeNumMipMapLevels(). So I fix the problem adding call this method before share: vsg-dev/vsgXchange#217