transformMatrix not applied for quantized glb

[skywalkershen]

Hi, I get an issue that if using gltf-transform to quantize my glb files to reduce memory, the transform for mergedMesh doesn't apply for the bvh, and the bvh just stacks at the origin if with bvh helper on.

I'm loading and processing model with custom hook and apply it to primitive on ready with position/rotation/scale applied, so at this point, the mergedMesh and its bvh will be generated from the originalMesh with transfrom applied.

{ model && 
          <StaticCollider 
            key={`collider-${config.id}`}
            onPointerEnter={onMeshPointerEnter} 
            onPointerLeave={onMeshPointerLeave} 
            onPointerOver={onMeshPointerOver} 
            onClick={onMeshClick} 
            onPointerMissed={onClickMissed} 
            debug={true}
            bvhName={`bvh-${config.id}`}
          >
            <primitive 
              key={`primitive-collider-${config.id}`}
              ref={ref} 
              object={model} 
              position={position} 
              rotation={rotation} 
              scale={scale} 
              visible={false}
            >
              {children}
            </primitive>
          </StaticCollider>
      }

when the mesh is initially loaded, I'll compose a originBVHTransform with original position/rotation/scale, and when any position/rotation/scale changes, I'll calculate a currentMatrix and multiply it with originBVHTransform.invert() to get the relativeMatrix for the transform and apply to mergedMesh. This approach works fine and synchronize bvh and actual mesh transform with previous glb files not quantized, but now when using quantized mesh, it seems none transform applied to the bvh geometry. And not only the transform I added with code, the child mesh in the glb file doesn't get their transform applied.

to reproduce

• use a glb file with nested meshes(child should have transform applied)

• in code, put the loaded mesh inside staticCollider, and apply transform(position/rotation/scale) to it

• set debug = true for staticCollider, the mesh and the bvhHelper should be synced

• use same glb file, and use `gltf-transform quantize [fileName] [outputFilename] to process,

• use same code to load the quantized model

• all the bvhhelper should be stacking at origin, transform for childMesh(from the glb file) and root mesh(from code) are not applied to bvh.

I'm not familiar with gltf quantize approach and don't have a clue on this issue. Hope you can shed some light on it, thank you.

[ErdongChen-Andrew]

I’m not familiar with how gltf-transform quantize handles transforms internally. Could you provide the model, both before and after quantization? So I can try to replicate the bug on my side

[skywalkershen]

I’m not familiar with how gltf-transform quantize handles transforms internally. Could you provide the model, both before and after quantization? So I can try to replicate the bug on my side

models.zip
Please see attached for the quantized and not quantized model. They are same indoor model compressed with gltf-transform, the only difference is quantized or not, I've named them so you can tell.

And I've added screenshots for quantized and not_quantized models with bvhHelper visible, and with/without mesh visible so you can see the issue

[ErdongChen-Andrew]

The issue is that three-mesh-bvh expects the geometry’s position.array to be a Float32Array, but quantized models often store them in a smaller integer types like Int16Array. You need to convert the model’s position.array after loading:

  useEffect(() => {
    map.scene.traverse((child) => {
      if (child.isMesh) {
        const pos = child.geometry.getAttribute("position");
        if (!(pos.array instanceof Float32Array)) {
          const floatArray = new Float32Array(pos.count * pos.itemSize);
          for (let i = 0; i < pos.count; i++) {
            floatArray[i * 3 + 0] = pos.getX(i);
            floatArray[i * 3 + 1] = pos.getY(i);
            floatArray[i * 3 + 2] = pos.getZ(i);
          }
          child.geometry.setAttribute(
            "position",
            new THREE.BufferAttribute(floatArray, 3)
          );
        }
      }
    });
  }, [map]);

PS: The model’s floor and roof normals are inverted, you might want to flip them around.

[skywalkershen]

The issue is that three-mesh-bvh expects the geometry’s position.array to be a Float32Array, but quantized models often store them in a smaller integer types like Int16Array. You need to convert the model’s position.array after loading:

useEffect(() => {
map.scene.traverse((child) => {
if (child.isMesh) {
const pos = child.geometry.getAttribute("position");
if (!(pos.array instanceof Float32Array)) {
const floatArray = new Float32Array(pos.count * pos.itemSize);
for (let i = 0; i < pos.count; i++) {
floatArray[i * 3 + 0] = pos.getX(i);
floatArray[i * 3 + 1] = pos.getY(i);
floatArray[i * 3 + 2] = pos.getZ(i);
}
child.geometry.setAttribute(
"position",
new THREE.BufferAttribute(floatArray, 3)
);
}
}
});
}, [map]);
PS: The model’s floor and roof normals are inverted, you might want to flip them around.

Thanks, functional wise it works, yet this way I think I loose the compressed memory size from quantize, which makes the compression meaningless. Is there any approach to make bvh work, while keeping the memory low for the geometry data.

Thank you.

[ErdongChen-Andrew]

I suppose that’s just how bvh is generated with three-mesh-bvh. Hopefully they’ll add a better way to handle quantized models in the future.