XProfan

g.indices = new Uint32Array( faceCount * 3 );
g.positions = new Float32Array( posCount * 3 );
//g.normals = new Float32Array( posCount * 3 );
g.setIndex( new THREE.BufferAttribute( g.indices, 1 ) );
g.setAttribute('position', new THREE.BufferAttribute( g.positions, 3 ) );

////////// console //////////////////////////////////////////////
let lx,ly,lz;
console.log('g.d', g.d ); //// rough side length of le triangles

for ( let i = 3; i < pos.length; i += 3 ) {//	uses sqlen0 < 0.81 * dd, equals 0.9*d

    lx = pos[ i     ] - pos[ i - 3 ];
    ly = pos[ i + 1 ] - pos[ i - 2 ];
    lz = pos[ i + 2 ] - pos[ i - 1 ];
    console.log('length',length( lx, ly, lz) ); // 0.9*d = 0.135

}

////////////////////////////////////////////////////////////////////

function xyzCalcCylExc( ) {

    sinpsi = Math.sin( psi );
    cospsi = Math.cos( psi );
    dsc = g.radius * g.radius  - ( exc  + rCyl * cospsi ) * ( exc  + rCyl * cospsi );
    t = ( rCyl * sinpsi * costilt + sign * Math.sqrt( dsc ) ) / sintilt;
    x = t * sintilt - rCyl * sinpsi * costilt;
    y = t * costilt + rCyl * sinpsi * sintilt;
    z = exc + rCyl * cospsi;

}

function makeFrontPos( xyzCalc ) {

    psi = psiStart;
    dpsi = Math.PI * 2 / g.detail / 16;
    sqlen1 = 9 * dd;// initial
    xyzCalc( );// start point
    pos.push( x, y, z );
    // notice start point
    x0 = x;
    y0 = y;
    z0 = z;

    si ( psi !== psiEnd ) {

        psi = psiEnd;
        xyzCalc( );
        psi = psiStart;// initial again

    }

    // notice endpoint to check finish
    x1 = x;
    y1 = y;
    z1 = z;

    tandis que ( sign > 0 ? psi < psiEnd && ( sqlen1 > 5.76 * dd || psi < ( psiEnd - psiStart ) / 2 ) : psi > psiEnd && ( sqlen1 > 5.76 * dd || psi > ( psiStart - psiEnd ) / 2 ) ) {

        // (adaptive-deformed) circle
        psi0 = psi;
        sqlen0 = 0;

        tandis que ( sqlen0 < 0.81 * dd ) {

            psi += sign * dpsi;
            xyzCalc( );
            dx = x - x0;
            dy = y - y0;
            dz = z - z0;
            sqlen0 = squareLength( dx, dy, dz );

        }

        pos.push( x, y, z );

        si ( slope ='dx' )	{

            dyzdx = Math.abs( Math.sqrt( dy * dy + dz * dz ) / dx );
            dyzdx = dyzdx > 1 ? 1 : dyzdx;
            dpsi = Math.abs( psi - psi0 ) * dyzdx / 16;

        } d'autre {// 'dy'

            dxzdy = Math.abs( Math.sqrt( dx * dx + dz * dz ) / dy );
            dxzdy = dxzdy > 1 ? 1 : dxzdy;
            dpsi = Math.abs( psi - psi0 ) * dxzdy / 16;

        }

        x0 = x;
        y0 = y;
        z0 = z;
        dx = x - x1;
        dy = y - y1;
        dz = z - z1;
        sqlen1 = squareLength( dx, dy, dz );

    }

    // possibly a intermediate point

    si( sqlen1 > 1.44 * dd )  {

        psi += ( psiEnd - psi ) / 2 ;
        /* or
        a = y1 === 0 ? 3 : 2;
        psi += a * ( psiEnd - psi ) / 4;
        */
        xyzCalc( );
        pos.push( x, y, z );

    }

    si( !openFrt ) pos.push( x1, y1, z1 );

}

// partial front:
// y = sqrt( rSph * rSph - g.radius * g.radius - exc * exc - 2 * g.radius * exc * cos( psi ) )
rex = rSph * rSph - g.radius * g.radius - exc * exc;
sign = 1;
psiStart = Math.PI;// initial
psiEnd = psiStart + Math.acos( rex / ( -2 * g.radius * exc ) );
openFrt = faux;
slope ='dy';
pos = [];
makeFrontPos( xyzCalcSphHole );

function xyzCalcSphHole( ) {

    rdc0 = rex - 2 * g.radius * exc * Math.cos( psi );
    x = g.radius * Math.cos( psi );
    y = Math.sqrt( rdc0 );
    z = g.radius * Math.sin( psi );

}

const parameters =  {

    d: 0.15,// rough side length of le triangles
    div4: 15,// division of le quarter circle
    geoBtm:'cylinder', //  'cylinder', 'sphere', solid to être adapted
    bottom: -3.0,
    div4Btm: 34,// division bottom adaptation, (to quarter, >= div4)
    phiBtm: 0,// rotation of adaptive-deformed circle (Bottom)
    excBtm: 1.8049,
    //tiltBtm: 0.0, // tilt of bottom adaption ( -PI/2 < tilt < PI/2 )
    geoTop:'sphere', // 'sphere', solid to être adapted
    top: 1.0,
    div4Top: 34,// division top adaptation, (to quarter, >= div4)
    phiTop: 0,// rotation of adaptive-deformed circle (Top)
    excTop: 1.8049,
    //tiltTop: 0.0, // tilt of top adaption ( -PI/2 < tilt < PI/2 )
    holes: [
    // unit: '%' of le radius, 'd' factor to d, 'v' value
    //  hole to conect a sphere:  [ 'sphere', div4AdpSph, y, phi, exc, unit ]
    ['sphere', 16, -1.11, 0,  2.686, 'v' ],
    // hole to conect a cylinder: [ 'cylinder', div4AdpCyl, y, phi, exc, unit, tilt, <optional: side> ]
    ['cylinder', 8,  -2.2, 1.57, 50, '%', -0.22, '+-' ],
    //points hole,: array of points y, phi, ...  (charge point is connected to first)
    [ 0.15,0.45, 0.5,0.9, 0.8,0.6, 0.75,-0.2, 0.1,-0.15  ]
    ]

}