Unloading and Reloading materials

Kulodo133 · March 13, 2021, 11:14pm

I have been doing some investigations into scene management (inspired by the same reasons in the discussion linked at the end )

There might be a bug in the following use case:
If the same textures are used on different materials
and one of the materials is unloaded and then one of the shared textures is loaded
then the bound _onTextureLoad() method is called for the unloaded material causing an error.
eg “TypeError: Cannot set property ‘emissiveMap’ of undefined”

Here is a project that displays the issue, and in assetHelper.js there is a potential workaround.

https://playcanvas.com/editor/scene/1109860
https://playcanvas.com/editor/code/774292?tabs=44122974,44122980

Kulodo133 · March 14, 2021, 10:17am

Here are some more details on the issue. I think this is what is happening.

When the material’s asset references are created these callbacks are set:

github.com

playcanvas/engine/blob/master/src/resources/material.js#L238


// iterate through all texture parameters
for (i = 0; i < TEXTURES.length; i++) {
    name = TEXTURES[i];
    assetReference = material._assetReferences[name];
    // data[name] contains an asset id for a texture
    if (data[name] && !(data[name] instanceof Texture)) {
        if (!assetReference) {
            assetReference = new AssetReference(name, materialAsset, assets, {
                load: this._onTextureLoad,
                add: this._onTextureAdd,
                remove: this._onTextureRemove
            }, this);
            material._assetReferences[name] = assetReference;
        }
        if (pathMapping) {
            // texture paths are measured from the material directory
            assetReference.url = materialAsset.getAbsoluteUrl(data[name]);

When the material is unloaded the callbacks for the assetReferences aren’t removed:

github.com

playcanvas/engine/blob/master/src/resources/material.js#L135


    // patch the name of the asset over the material name property
    asset.data.name = asset.name;
    asset.resource.name = asset.name;
    this._bindAndAssignAssets(asset, assets);
    asset.off('unload', this._onAssetUnload, this);
    asset.on('unload', this._onAssetUnload, this);
}
_onAssetUnload(asset) {
    // remove the parameter block we created which includes texture references
    delete asset.data.parameters;
    delete asset.data.chunks;
    delete asset.data.name;
}
_assignTexture(parameterName, materialAsset, texture) {
    materialAsset.data[parameterName] = texture;
    materialAsset.resource[parameterName] = texture;
}

So when a texture from the assetReference is subsequently loaded the callback is called for the now unloaded material asset:

github.com

playcanvas/engine/blob/master/src/resources/material.js#L163


        this._createPlaceholders();
    }
    var placeholder = PLACEHOLDER_MAP[parameterName];
    var texture = this._placeholderTextures[placeholder];
    materialAsset.resource[parameterName] = texture;
}
_onTextureLoad(parameterName, materialAsset, textureAsset) {
    this._assignTexture(parameterName, materialAsset, textureAsset.resource);
    materialAsset.resource.update();
}
_onTextureAdd(parameterName, materialAsset, textureAsset) {
    this._assets.load(textureAsset);
}
_onTextureRemove(parameterName, materialAsset, textureAsset) {
    var material = materialAsset.resource;
    if (material) {

and this causes the error as the material asset is undefined.

github.com

playcanvas/engine/blob/master/src/resources/material.js#L143


}
_onAssetUnload(asset) {
    // remove the parameter block we created which includes texture references
    delete asset.data.parameters;
    delete asset.data.chunks;
    delete asset.data.name;
}
_assignTexture(parameterName, materialAsset, texture) {
    materialAsset.data[parameterName] = texture;
    materialAsset.resource[parameterName] = texture;
}
// assign a placeholder texture while waiting for one to load
// placeholder textures do not replace the data[parameterName] value
// in the asset.data thus preserving the final asset id until it is loaded
_assignPlaceholderTexture(parameterName, materialAsset) {
    // create placeholder textures on-demand
    if (!this._placeholderTextures) {
        this._createPlaceholders();

So you probably want to either remove the callbacks, which is what I did in my hack workaround ( but then they need to be recreated later when the material is reloaded) or check that the material is not undefined in these callbacks.

There is another related engine bug.

Kulodo133 · March 28, 2021, 7:41pm

I got around the issue by patching the MaterialHandler. I also made an AssetHelper class that will download all the scene’s json files and parse to get all the asset dependencies per scene. It’s work in progress ( Javascript is not my first language )

https://playcanvas.com/editor/code/779957?tabs=45050271,45050274
https://playcanvas.com/editor/scene/1120670

this._materialHandler._onTextureLoad = function(parameterName, materialAsset, textureAsset) {

    // Fixes bug where materialAsset is not loaded.
    if (materialAsset.loaded) {
        _this._originalOnTextureLoad(parameterName, materialAsset, textureAsset);
    }
};

yaustar · March 28, 2021, 10:23pm

Thanks for investigating into this and glad that you had found a workaround, I will add this to our internal tracker and try to schedule an engine level fix

eproasim · March 31, 2021, 1:23pm

Just ran into this issue and found this thread. Will this be tracked on the engine issue log? I don’t want to pester in the thread if not necessary.

yaustar · March 31, 2021, 1:33pm

Chris · April 1, 2021, 2:26am

Oh cool, nice job tracking this down. In my project I unload models and textures, but don’t unload materials because of this. Wasn’t a blocker, but cool to see someone was able to figure this one out.

eproasim · April 1, 2021, 1:49pm

Good morning,

So it looks like with the latest engine release, the app no longer crashes when unloading assets on scene destroy and then reloading them on reload, but I am getting a bit of strange behavior.

Now when returning to the scene, it seems that none of my textures actually get applied to the material. The runtime lightmaps still appear to work, but none of the other maps appear to load. Looking at the console, I’m getting a warning of:

Ignoring unsupported input property to standard material: validated

for each material with a texture that gets loaded.

I made a repro of the behavior, but strangely, the warning doesn’t appear in the repro, so I could be doing something wrong in general.

Here is the repro:

and the project:

https://playcanvas.com/project/781274/overview/unload-reload-material-repro

To see the behavior, just click to go to scene 2 then scene 1 then scene 2 once more. You will see that the material unloaded from the Earth Sphere, does not get applied on reload. The moon’s textures get unloaded, but the material does not.

Also, one more observation. It appears that the same unloading and reloading material issue also applies to cubemaps that get unloaded. The app crashes and presents the error:

facetextures[0] undefined

Simply not unloading the cubemap prevents crashing even when textures are unloaded.

yaustar · April 1, 2021, 1:53pm

@ray is this something you can have a look over please?

mvaligursky · April 1, 2021, 2:59pm

this error only displays when using the debug version of the engine … so maybe in the repro you have not ticked “debug” or similar?

Kulodo133 · April 1, 2021, 3:03pm

My test project has similar issues. Go to scene 2 and back to scene1 and see the console errors.

https://playcanvas.com/project/779957/overview/asset-helper

eproasim · April 1, 2021, 3:18pm

That was right! Checking debug also reproduced the warning. Thank you!

ray · April 1, 2021, 3:48pm

I will look into this and update when I have more info.

Kulodo133 · April 1, 2021, 6:12pm

On line 235 when reloading the material, data[name] is a Texture (from the previous load I think) and so the IF test fails and the code to assign textures doesn’t get executed. In a previous test when I forced data[name] to be the id of the texture asset it did force the texture to load. Could be something related to this.

github.com

playcanvas/engine/blob/master/src/resources/material.js#L235


const TEXTURES = standardMaterialTextureParameters;
let i, name, assetReference;
// iterate through all texture parameters
for (i = 0; i < TEXTURES.length; i++) {
    name = TEXTURES[i];
    assetReference = material._assetReferences[name];
    // data[name] contains an asset id for a texture
    if (data[name] && !(data[name] instanceof Texture)) {
        if (!assetReference) {
            assetReference = new AssetReference(name, materialAsset, assets, {
                load: this._onTextureLoad,
                add: this._onTextureAdd,
                remove: this._onTextureRemove
            }, this);
            material._assetReferences[name] = assetReference;
        }

Kulodo133 · April 2, 2021, 2:50pm

Here is an example that might assist in finding the proper solution. When a material is unloaded, I reset the material asset’s data texture references back to the texture assets ID.
https://playcanvas.com/project/779957/overview/asset-helper
https://playcanvas.com/editor/code/779957?tabs=45050271

ray · April 9, 2021, 11:07am

@Kulodo133 - thanks for the additional information - I have submitted a engine fix PR here: https://github.com/playcanvas/engine/pull/3074

Kulodo133 · April 9, 2021, 12:05pm

@ray is it possible for me to test the branch using this mechanism?

https://developer.playcanvas.com/en/user-manual/scripting/custom_engine/

yaustar · April 9, 2021, 12:34pm

You would have to build the engine locally, host it (using something like python http server) and use the link above to run with it in the launch tab.

Kulodo133 · April 9, 2021, 2:04pm

I built the engine locally and checked out Ray’s branch and it does fix the issue https://playcanvas.com/project/779957/overview/asset-helper