physics support to stop meshes from falling through heightmaps?

[BeRightBack]

Is there a way in babylonjs/ts to prevent meshes from falling through a map made with GroundFromHeightMap? meshes's physics seems to work only with flat ground tho the camera's gravity recognize height maps so what am' I missing?, in my searches, I've read that it was not support in Babylonjs, If so I would like to know and perhaps try other libraries tho I'm getting use to this one, which is very intuitive and usually find my own way.

since my meshes are floating on water, i guess it could be made with shaders but yet to heavy for my understanding so far, any hint to get me started would be appreciated.

[GameMonetize]

We are using cannonjs for now as unique physics provider. After many discussions we decided to move our current model to a plugin oriented model for physics. This will allow us to have many physics providers (amno.js for instance)

 

But in your specific case do you need only an imprecise collisions (in this case the picking engine can be enough)?

[Wingnut]

Sorry to interrupt, but, is ANY webGL library or anyone... doing full physics on heightmaps?  I don't think I have ever seen a sphere rolling up and down a heightMap mountain yet, nor a box tumbling down a heightmap mountain... in any webGL demo, so far.  That's some rather intense calculations, I suspect. 

 

I HAVE bounced some cannonballs off of mountains in a game called Serious Sam, though.  But that's got a little faster language than JS... under its hood.  *shrug*.   I'm not very educated in these matters.

[BeRightBack]

Thanks for your answers, "sphere rolling up and down a heightMap mountain" is exactly what i'm looking for, ammo.js seems to support it : see example 8   http://lo-th.github.io/Ammo.lab/  it's using noise generation,, I also found an interesting code which I'm studiyng right now

 

'use strict';

// Ported from Stefan Gustavson's java implementation

// http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf

// Read Stefan's excellent paper for details on how this code works.

//

// Sean McCullough [email protected]

 

/**

 * You can pass in a random number generator object if you like.

 * It is assumed to have a random() method.

 */

var SimplexNoise = (function() {

var SimplexNoise = function® {

if (r == undefined) r = Math;

 this.grad3 = [[1,1,0],[-1,1,0],[1,-1,0],[-1,-1,0], 

                                [1,0,1],[-1,0,1],[1,0,-1],[-1,0,-1], 

                                [0,1,1],[0,-1,1],[0,1,-1],[0,-1,-1]]; 

 this.p = [];

 for (var i=0; i<256; i++) {

 this.p = Math.floor(r.random()*256);

 }

 // To remove the need for index wrapping, double the permutation table length 

 this.perm = []; 

 for(var i=0; i<512; i++) {

this.perm=this.p[i & 255];

} 

 

 // A lookup table to traverse the simplex around a given point in 4D. 

 // Details can be found where this table is used, in the 4D noise method. 

 this.simplex = [ 

   [0,1,2,3],[0,1,3,2],[0,0,0,0],[0,2,3,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,2,3,0], 

   [0,2,1,3],[0,0,0,0],[0,3,1,2],[0,3,2,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,3,2,0], 

   [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0], 

   [1,2,0,3],[0,0,0,0],[1,3,0,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,3,0,1],[2,3,1,0], 

   [1,0,2,3],[1,0,3,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,0,3,1],[0,0,0,0],[2,1,3,0], 

   [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0], 

   [2,0,1,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,0,1,2],[3,0,2,1],[0,0,0,0],[3,1,2,0], 

   [2,1,0,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,1,0,2],[0,0,0,0],[3,2,0,1],[3,2,1,0]]; 

};

 

SimplexNoise.prototype.dot = function(g, x, y) { 

return g[0]*x + g[1]*y;

};

 

SimplexNoise.prototype.noise = function(xin, yin) { 

 var n0, n1, n2; // Noise contributions from the three corners 

 // Skew the input space to determine which simplex cell we're in 

 var F2 = 0.5*(Math.sqrt(3.0)-1.0); 

 var s = (xin+yin)*F2; // Hairy factor for 2D 

 var i = Math.floor(xin+s); 

 var j = Math.floor(yin+s); 

 var G2 = (3.0-Math.sqrt(3.0))/6.0; 

 var t = (i+j)*G2; 

 var X0 = i-t; // Unskew the cell origin back to (x,y) space 

 var Y0 = j-t; 

 var x0 = xin-X0; // The x,y distances from the cell origin 

 var y0 = yin-Y0; 

 // For the 2D case, the simplex shape is an equilateral triangle. 

 // Determine which simplex we are in. 

 var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords 

 if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1) 

 else {i1=0; j1=1;}      // upper triangle, YX order: (0,0)->(0,1)->(1,1) 

 // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and 

 // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where 

 // c = (3-sqrt(3))/6 

 var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords 

 var y1 = y0 - j1 + G2; 

 var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords 

 var y2 = y0 - 1.0 + 2.0 * G2; 

 // Work out the hashed gradient indices of the three simplex corners 

 var ii = i & 255; 

 var jj = j & 255; 

 var gi0 = this.perm[ii+this.perm[jj]] % 12; 

 var gi1 = this.perm[ii+i1+this.perm[jj+j1]] % 12; 

 var gi2 = this.perm[ii+1+this.perm[jj+1]] % 12; 

 // Calculate the contribution from the three corners 

 var t0 = 0.5 - x0*x0-y0*y0; 

 if(t0<0) n0 = 0.0; 

 else { 

   t0 *= t0; 

   n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0);  // (x,y) of grad3 used for 2D gradient 

 } 

 var t1 = 0.5 - x1*x1-y1*y1; 

 if(t1<0) n1 = 0.0; 

 else { 

   t1 *= t1; 

   n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1); 

 }

 var t2 = 0.5 - x2*x2-y2*y2; 

 if(t2<0) n2 = 0.0; 

 else { 

   t2 *= t2; 

   n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2); 

 } 

 // Add contributions from each corner to get the final noise value. 

 // The result is scaled to return values in the interval [-1,1]. 

 return 70.0 * (n0 + n1 + n2); 

};

 

// 3D simplex noise 

SimplexNoise.prototype.noise3d = function(xin, yin, zin) { 

 var n0, n1, n2, n3; // Noise contributions from the four corners 

 // Skew the input space to determine which simplex cell we're in 

 var F3 = 1.0/3.0; 

 var s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D 

 var i = Math.floor(xin+s); 

 var j = Math.floor(yin+s); 

 var k = Math.floor(zin+s); 

 var G3 = 1.0/6.0; // Very nice and simple unskew factor, too 

 var t = (i+j+k)*G3; 

 var X0 = i-t; // Unskew the cell origin back to (x,y,z) space 

 var Y0 = j-t; 

 var Z0 = k-t; 

 var x0 = xin-X0; // The x,y,z distances from the cell origin 

 var y0 = yin-Y0; 

 var z0 = zin-Z0; 

 // For the 3D case, the simplex shape is a slightly irregular tetrahedron. 

 // Determine which simplex we are in. 

 var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords 

 var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords 

 if(x0>=y0) { 

   if(y0>=z0) 

     { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order 

     else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order 

     else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order 

   } 

 else { // x0<y0 

   if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order 

   else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order 

   else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order 

 } 

 // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), 

 // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and 

 // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where 

 // c = 1/6.

 var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords 

 var y1 = y0 - j1 + G3; 

 var z1 = z0 - k1 + G3; 

 var x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords 

 var y2 = y0 - j2 + 2.0*G3; 

 var z2 = z0 - k2 + 2.0*G3; 

 var x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords 

 var y3 = y0 - 1.0 + 3.0*G3; 

 var z3 = z0 - 1.0 + 3.0*G3; 

 // Work out the hashed gradient indices of the four simplex corners 

 var ii = i & 255; 

 var jj = j & 255; 

 var kk = k & 255; 

 var gi0 = this.perm[ii+this.perm[jj+this.perm[kk]]] % 12; 

 var gi1 = this.perm[ii+i1+this.perm[jj+j1+this.perm[kk+k1]]] % 12; 

 var gi2 = this.perm[ii+i2+this.perm[jj+j2+this.perm[kk+k2]]] % 12; 

 var gi3 = this.perm[ii+1+this.perm[jj+1+this.perm[kk+1]]] % 12; 

 // Calculate the contribution from the four corners 

 var t0 = 0.6 - x0*x0 - y0*y0 - z0*z0; 

 if(t0<0) n0 = 0.0; 

 else { 

   t0 *= t0; 

   n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0, z0); 

 }

 var t1 = 0.6 - x1*x1 - y1*y1 - z1*z1; 

 if(t1<0) n1 = 0.0; 

 else { 

   t1 *= t1; 

   n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1, z1); 

 } 

 var t2 = 0.6 - x2*x2 - y2*y2 - z2*z2; 

 if(t2<0) n2 = 0.0; 

 else { 

   t2 *= t2; 

   n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2, z2); 

 } 

 var t3 = 0.6 - x3*x3 - y3*y3 - z3*z3; 

 if(t3<0) n3 = 0.0; 

 else { 

   t3 *= t3; 

   n3 = t3 * t3 * this.dot(this.grad3[gi3], x3, y3, z3); 

 } 

 // Add contributions from each corner to get the final noise value. 

 // The result is scaled to stay just inside [-1,1] 

 return 32.0*(n0 + n1 + n2 + n3); 

};

 

return SimplexNoise;

})();

 

NoiseGen = new SimplexNoise;

 

        ground_geometry = new THREE.PlaneGeometry(75, 75, 50, 50);

        for (var i = 0; i < ground_geometry.vertices.length; i++) {

            var vertex = ground_geometry.vertices;

            vertex.z = NoiseGen.noise(vertex.x / 10, vertex.y / 10) * 2;

        }

[gwenael]

'use strict';// Ported from Stefan Gustavson's java implementation// http://staffwww.itn....implexnoise.pdf// Read Stefan's excellent paper for details on how this code works.//// Sean McCullough [email protected] /** * You can pass in a random number generator object if you like. * It is assumed to have a random() method. */var SimplexNoise = (function() {var SimplexNoise = function® {if (r == undefined) r = Math; this.grad3 = [[1,1,0],[-1,1,0],[1,-1,0],[-1,-1,0],                                 [1,0,1],[-1,0,1],[1,0,-1],[-1,0,-1],                                 [0,1,1],[0,-1,1],[0,1,-1],[0,-1,-1]];  this.p = []; for (var i=0; i<256; i++) { this.p[i] = Math.floor(r.random()*256); } // To remove the need for index wrapping, double the permutation table length  this.perm = [];  for(var i=0; i<512; i++) {this.perm[i]=this.p[i & 255];}   // A lookup table to traverse the simplex around a given point in 4D.  // Details can be found where this table is used, in the 4D noise method.  this.simplex = [    [0,1,2,3],[0,1,3,2],[0,0,0,0],[0,2,3,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,2,3,0],    [0,2,1,3],[0,0,0,0],[0,3,1,2],[0,3,2,1],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,3,2,0],    [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],    [1,2,0,3],[0,0,0,0],[1,3,0,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,3,0,1],[2,3,1,0],    [1,0,2,3],[1,0,3,2],[0,0,0,0],[0,0,0,0],[0,0,0,0],[2,0,3,1],[0,0,0,0],[2,1,3,0],    [0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],    [2,0,1,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,0,1,2],[3,0,2,1],[0,0,0,0],[3,1,2,0],    [2,1,0,3],[0,0,0,0],[0,0,0,0],[0,0,0,0],[3,1,0,2],[0,0,0,0],[3,2,0,1],[3,2,1,0]]; }; SimplexNoise.prototype.dot = function(g, x, y) { return g[0]*x + g[1]*y;}; SimplexNoise.prototype.noise = function(xin, yin) {  var n0, n1, n2; // Noise contributions from the three corners  // Skew the input space to determine which simplex cell we're in  var F2 = 0.5*(Math.sqrt(3.0)-1.0);  var s = (xin+yin)*F2; // Hairy factor for 2D  var i = Math.floor(xin+s);  var j = Math.floor(yin+s);  var G2 = (3.0-Math.sqrt(3.0))/6.0;  var t = (i+j)*G2;  var X0 = i-t; // Unskew the cell origin back to (x,y) space  var Y0 = j-t;  var x0 = xin-X0; // The x,y distances from the cell origin  var y0 = yin-Y0;  // For the 2D case, the simplex shape is an equilateral triangle.  // Determine which simplex we are in.  var i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords  if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)  else {i1=0; j1=1;}      // upper triangle, YX order: (0,0)->(0,1)->(1,1)  // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and  // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where  // c = (3-sqrt(3))/6  var x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords  var y1 = y0 - j1 + G2;  var x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords  var y2 = y0 - 1.0 + 2.0 * G2;  // Work out the hashed gradient indices of the three simplex corners  var ii = i & 255;  var jj = j & 255;  var gi0 = this.perm[ii+this.perm[jj]] % 12;  var gi1 = this.perm[ii+i1+this.perm[jj+j1]] % 12;  var gi2 = this.perm[ii+1+this.perm[jj+1]] % 12;  // Calculate the contribution from the three corners  var t0 = 0.5 - x0*x0-y0*y0;  if(t0<0) n0 = 0.0;  else {    t0 *= t0;    n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0);  // (x,y) of grad3 used for 2D gradient  }  var t1 = 0.5 - x1*x1-y1*y1;  if(t1<0) n1 = 0.0;  else {    t1 *= t1;    n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1);  } var t2 = 0.5 - x2*x2-y2*y2;  if(t2<0) n2 = 0.0;  else {    t2 *= t2;    n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2);  }  // Add contributions from each corner to get the final noise value.  // The result is scaled to return values in the interval [-1,1].  return 70.0 * (n0 + n1 + n2); }; // 3D simplex noise SimplexNoise.prototype.noise3d = function(xin, yin, zin) {  var n0, n1, n2, n3; // Noise contributions from the four corners  // Skew the input space to determine which simplex cell we're in  var F3 = 1.0/3.0;  var s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D  var i = Math.floor(xin+s);  var j = Math.floor(yin+s);  var k = Math.floor(zin+s);  var G3 = 1.0/6.0; // Very nice and simple unskew factor, too  var t = (i+j+k)*G3;  var X0 = i-t; // Unskew the cell origin back to (x,y,z) space  var Y0 = j-t;  var Z0 = k-t;  var x0 = xin-X0; // The x,y,z distances from the cell origin  var y0 = yin-Y0;  var z0 = zin-Z0;  // For the 3D case, the simplex shape is a slightly irregular tetrahedron.  // Determine which simplex we are in.  var i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords  var i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords  if(x0>=y0) {    if(y0>=z0)      { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order      else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order      else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order    }  else { // x0<y0    if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order    else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order    else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order  }  // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),  // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and  // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where  // c = 1/6. var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords  var y1 = y0 - j1 + G3;  var z1 = z0 - k1 + G3;  var x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords  var y2 = y0 - j2 + 2.0*G3;  var z2 = z0 - k2 + 2.0*G3;  var x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords  var y3 = y0 - 1.0 + 3.0*G3;  var z3 = z0 - 1.0 + 3.0*G3;  // Work out the hashed gradient indices of the four simplex corners  var ii = i & 255;  var jj = j & 255;  var kk = k & 255;  var gi0 = this.perm[ii+this.perm[jj+this.perm[kk]]] % 12;  var gi1 = this.perm[ii+i1+this.perm[jj+j1+this.perm[kk+k1]]] % 12;  var gi2 = this.perm[ii+i2+this.perm[jj+j2+this.perm[kk+k2]]] % 12;  var gi3 = this.perm[ii+1+this.perm[jj+1+this.perm[kk+1]]] % 12;  // Calculate the contribution from the four corners  var t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;  if(t0<0) n0 = 0.0;  else {    t0 *= t0;    n0 = t0 * t0 * this.dot(this.grad3[gi0], x0, y0, z0);  } var t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;  if(t1<0) n1 = 0.0;  else {    t1 *= t1;    n1 = t1 * t1 * this.dot(this.grad3[gi1], x1, y1, z1);  }  var t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;  if(t2<0) n2 = 0.0;  else {    t2 *= t2;    n2 = t2 * t2 * this.dot(this.grad3[gi2], x2, y2, z2);  }  var t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;  if(t3<0) n3 = 0.0;  else {    t3 *= t3;    n3 = t3 * t3 * this.dot(this.grad3[gi3], x3, y3, z3);  }  // Add contributions from each corner to get the final noise value.  // The result is scaled to stay just inside [-1,1]  return 32.0*(n0 + n1 + n2 + n3); }; return SimplexNoise;})(); NoiseGen = new SimplexNoise;         ground_geometry = new THREE.PlaneGeometry(75, 75, 50, 50);        for (var i = 0; i < ground_geometry.vertices.length; i++) {            var vertex = ground_geometry.vertices[i];            vertex.z = NoiseGen.noise(vertex.x / 10, vertex.y / 10) * 2;        }

Hi PetSaCoch,

 

I allowed myself to format your post so it's easier to read the code you posted. (use the icon 'Code' for that).

[BeRightBack]

Thanks for the tips, not sure how to adapt it tho, If ever I come up with something useful, i'll post it, I'll give a try to picking, and wait for the new plugin and doing some test with ammo and oimo 

[Dad72]

The plugin system is done, but need someone brave, it starts to do a plugin for amno.js or oimo.js

[BeRightBack]

is it downloadable somewhere? i'll be glad to test it as I plan to stick with Babylon and working full time on it

[BeRightBack]

sorry I'm a little slow ... but better late than noting loll,, so I understand that I can create my own pluggin, using the already implemented plugin system in 1.12-beta? a lot of fun ahead! since I have to implement physics in my game anyway, i'll do my best

[Dad72]

That's cool. will you share then the plugin to benefit the community? I would be very interested.

Thank you in advance

[BeRightBack]

of course

[Dad72]

Cool, It is good to know. good luck for this plugin.