[SOLVED] J3MLoader always generates mips ignoring MinFilter [Bug]

zzuegg · December 23, 2022, 10:23am

Does it change the behavior if nothing is specified in the j3m file?

If i followed your flow trough the loader i assume prior to this patch BilinearNoMips was expected but the result was trilinear.
After your fix the result would be BilinearNoMips?

Ali_RS · December 23, 2022, 10:26am

Yes, it is a breaking change rendering-wise.

Correct

Yes, if nothing is specified.

zzuegg · December 23, 2022, 11:00am

Then i suggest the specs should be changed and default to trilinear when nothing is specified and don’t generate the mips when explicitely specified

Ali_RS · December 23, 2022, 11:57am

Do you mean to change the default min filter to Trilinear in Texture?

github.com

jMonkeyEngine/jmonkeyengine/blob/ceb356462aeedf7769dced52e1d5572b01deca31/jme3-core/src/main/java/com/jme3/texture/Texture.java#L319


      
           * The image stored in the texture
           */
          private Image image = null;
          
          
/**
           * The texture key allows to reload a texture from a file
           * if needed.
           */
          private TextureKey key = null;
          
          
private MinFilter minificationFilter = MinFilter.BilinearNoMipMaps;
          private MagFilter magnificationFilter = MagFilter.Bilinear;
          private ShadowCompareMode shadowCompareMode = ShadowCompareMode.Off;
          private int anisotropicFilter;
          
          
/**
           * @return A cloned Texture object.
           */
          @Override
          public Texture clone(){
              try {

zzuegg · December 23, 2022, 1:26pm

It depends if/how the other methods of loading a texture are affected.
I also do not know enough on how currently models/textures are exported, if they are impacted or not. My concern is that changing default behavior is potentially affecting lots of people.

It’s not my call in the end.

Ali_RS · December 23, 2022, 1:42pm

IMO it is affecting in a good way, not a bad way though!

They expected to load with BilinearNoMipMaps and now it loads with BilinearNoMipMaps with this patch instead of Trilinear. Trying to keep the wrong behavior seems odd to me in this case and might need to add some hack, but yeah it’s not either my call in the end as well, I would like to hear @pspeed and @sgold ideas as well.

zzuegg · December 23, 2022, 1:53pm

That depends, not using mips creates problems too. there is a reason usually they are used.

If i had to make a bet i suspect you have issues with alpha discard by not using a correctly processed texture in the first place. In my opinion bilinearNoMips saves a little bit of vram at the cost of higher bandwith, more cache misses, worse aliasing. So i dont see the upgrade when used on regular models.

Ali_RS · December 23, 2022, 2:10pm

Yes, of course. Note that, if someone previously exported a J3M file with any min filter using mipmapping (like Trilinear, NearestLinearMipMap, BilinearNearestMipMap, NearestNearestMipMap) they would be pretty much unaffected by this change.

Right, using a higher alpha discard on transparent objects like tree leaves was causing them to dissolve/disappear when looking from far.

zzuegg · December 23, 2022, 2:18pm

then i am less concerned. Even more if the other model importers set trilinear by default.

https://asawicki.info/articles/alpha_test.php5

might intrest you.

Ali_RS · December 23, 2022, 2:55pm

Yes, for example, the materials I have exported from converting Gltf models are all set to use Trilinear by default.

Thanks

Ali_RS · December 25, 2022, 2:24pm

Ok, sorry, I was wrong about Trilinear.

If I export a j3m while using a Trilinear min filter and textureKey.setGenerateMips(true) then the min filter name won’t be written into the j3m file.

That’s because of this line of code in J3MOutputCapsule:

github.com

jMonkeyEngine/jmonkeyengine/blob/ceb356462aeedf7769dced52e1d5572b01deca31/jme3-plugins/src/main/java/com/jme3/material/plugin/export/material/J3MOutputCapsule.java#L142-L149


      
          //Min and Mag filter
          Texture.MinFilter def = Texture.MinFilter.BilinearNoMipMaps;
          if (tex.getImage().hasMipmaps() || (key != null && key.isGenerateMips())) {
              def = Texture.MinFilter.Trilinear;
          }
          if (tex.getMinFilter() != def) {
              ret.append("Min").append(tex.getMinFilter().name()).append(" ");
          }

Both BilinearNoMipMaps and Trilinear can be the default, and thus non of them would be exported. That is stupid!

But it works in the case of Gltf models. This means if you export material from a model loaded with GltfLoader and it is using Trilinear min filter, then it will be exported to J3M file. I can confirm this as I can see MinTrilinear in all of my materials exported from gltf models.

The reason is GltfLoader never sets generateMips flag on TextureKey. So it would be false by default.

github.com

jMonkeyEngine/jmonkeyengine/blob/f92a73f91ce1a2852645cd1bb5a4c6b597faf7af/jme3-plugins/src/gltf/java/com/jme3/scene/plugins/gltf/GltfLoader.java#L777


      
                  // base64 encoded image
                  String[] uriInfo = uri.split(",");
                  byte[] data = Base64.getDecoder().decode(uriInfo[1]);
                  String headerInfo = uriInfo[0].split(";")[0];
                  String extension = headerInfo.split("/")[1];
                  TextureKey key = new TextureKey("image" + sourceIndex + "." + extension, flip);
                  result = (Texture2D) info.getManager().loadAssetFromStream(key, new ByteArrayInputStream(data));
              } else {
                  // external file image
                  String decoded = decodeUri(uri);
                  TextureKey key = new TextureKey(info.getKey().getFolder() + decoded, flip);
                  Texture tex = info.getManager().loadTexture(key);
                  result = (Texture2D) tex;
              }
              return result;
          }
          
          public void readAnimation(int animationIndex) throws IOException {
              JsonObject animation = animations.get(animationIndex).getAsJsonObject();
              JsonArray channels = animation.getAsJsonArray("channels");
              JsonArray samplers = animation.getAsJsonArray("samplers");

it sets the min filter here:
(The blender exported Gltf models by default using Bilinear for the mag filter and Trilinear for the min filter)

github.com

jMonkeyEngine/jmonkeyengine/blob/f92a73f91ce1a2852645cd1bb5a4c6b597faf7af/jme3-plugins/src/gltf/java/com/jme3/scene/plugins/gltf/GltfLoader.java#L993-L1004


      
          JsonObject sampler = samplers.get(samplerIndex).getAsJsonObject();
          Texture.MagFilter magFilter = getMagFilter(getAsInteger(sampler, "magFilter"));
          Texture.MinFilter minFilter = getMinFilter(getAsInteger(sampler, "minFilter"));
          Texture.WrapMode wrapS = getWrapMode(getAsInteger(sampler, "wrapS"));
          Texture.WrapMode wrapT = getWrapMode(getAsInteger(sampler, "wrapT"));
          
          if (magFilter != null) {
              texture.setMagFilter(magFilter);
          }
          if (minFilter != null) {
              texture.setMinFilter(minFilter);
          }

That causes to bypass this check inside J3MOutputCapsule
and so exports the filter name.

github.com

jMonkeyEngine/jmonkeyengine/blob/ceb356462aeedf7769dced52e1d5572b01deca31/jme3-plugins/src/main/java/com/jme3/material/plugin/export/material/J3MOutputCapsule.java#L144-L146


      
          if (tex.getImage().hasMipmaps() || (key != null && key.isGenerateMips())) {
              def = Texture.MinFilter.Trilinear;
          }

As you suggested I will default it to Trilinear then when the min filter is not specified.

Edit:

Fixed