Precision issue with r49

I updated my Three lib to r49 but i’m dealing with many precision issue when rendering my old scene (it was working fine with r48).

The issues only occur when rendering far away from the world origin (further than 2 000 000 on some axis).

1st : my ground is formed of many Meshs built with PlaneGeometry and i now have some 1 pixel width holes between my meshs when moving the camera.

2nd : i’m dealing with a strong precision issue (>50 world unit error) when using projector and Matrix / Vector multiplication.

I tried to revert the Matrix optimization stuff but i didn’t manage to get it working with all the function change in this release 😕

[mshopf]

@m-schuetz: Thanks for your analysis - I had the same issue with in a similar setting. I was already thinking about more complex solutions (like in http://github.prideout.net/emulating-double-precision ), but it doesn’t seem to be required in my case as well.

I’d just suggest to use a local conversion Float32Array, so that you don’t need to create a new Object every time; also I think the use of || is wrong in your code (I might have missunderstood it, though):

 +    var convert32Array16= new Float32Array(16);
 [...]
      function setValue4fm( gl, v ) {
 -       gl.uniformMatrix4fv( this.addr, false, v.elements || v );
 +        convert32Array16.set (v.elements || v);
 +       gl.uniformMatrix4fv( this.addr, false, convert32Array16 );
      }

[m-schuetz]

@cipri-tom

In Matrix4.js, replace

this.elements = new Float32Array( [

with

this.elements = new Float64Array( [

and in WebGLUniforms.js replace

gl.uniformMatrix4fv( this.addr, false, v.elements || v );

with

gl.uniformMatrix4fv( this.addr, false, new Float32Array(v.elements) || v );

Seems to work for me. The matrices are converted to single precision float for the shaders which is fine because the translational terms of the world and the view matrices tend to cancel each other out. Make sure to use the combined “modelViewMatrix” in your shader.

On a related note, I’m just now switching to using Float64Array for the matrices in order to avoid confusing floating origin transformations. I can do a comparison for my use case when I’m done. Kind of glad to see that you just have to modify 2 lines to get double precision math on the CPU side.