class FreeFormDeformer { /** c'tor * * @param dimL - Number of control points in the 'X' direction * @param dimM - Number of control points in the 'Y' direction * @param dimN - Number of control points in the 'Z' direction * * @note - Technically the axes for our control points can be arbitrary * but to keep things simple we align our controls axes S, T, U to X, * Y, and Z respectively. So why introduce an L, M, and N? That's the * nomenclature from the original paper. In 3 dimensions you have * N objects in one direction, M in another, and L in the 3rd. Yes, * it can be hard to remember. * */ constructor(dimL,dimM,dimN){ this.target = null; this.originalVertices = []; this.transformedVertices = []; this.vertexParams = []; this.S = new THREE.Vector3(0,0,0); this.T = new THREE.Vector3(0,0,0); this.U = new THREE.Vector3(0,0,0); this.L = dimL; this.M = dimM; this.N = dimN; } /** Attach free form deformer to a model. * * @param target - THREE.js mesh * @note - Assumes 'target' has only a single child containing all the geometry. */ attach(target){ this.target = target; // Keep a direct reference to the target's position array to avoid costly copies. this.transformedVertices = target.children[0].geometry.attributes.position.array; // Also retain a clean copy of the unaltered data, stored as THREE.Vector3 for(let i = 0; i < this.transformedVertices.length; i+=3){ this.originalVertices.push(new THREE.Vector3( this.transformedVertices[i], this.transformedVertices[i+1], this.transformedVertices[i+2]) ); }; } /** Calculated a bionomial coefficient (obviously) * * @param n * @param k * @note - See https://en.wikipedia.org/wiki/Binomial_coefficient */ binomialCoeff(n,k){ let total = 1.0; for(let i = 1; i <= k; i++){ total *= (n - (k - i)) / parseFloat(i); } return total; } /** Compute part of a trivariate Bernstein Polynomial * * @param n {int} - Number of control points in a given direction * @param v {int} - Current control point between 1 and 'n' * @param x {float} - One of the local coordinates of local coordinate system {s,t,u} */ bernsteinPoly(n, v, x) { return this.binomialCoeff(n,v) * Math.pow(x, parseFloat(v)) * Math.pow(parseFloat(1.0 - x), parseFloat(n - v)); } /** Parameterize the deformation by the currently attached model * */ parameterize() { if(this.target == null){ throw "Call Free Form Deformations 'attach' method before calling 'parameterize'" } let minVertex = new THREE.Vector3(Infinity,Infinity,Infinity); let maxVertex = new THREE.Vector3(-Infinity,-Infinity,-Infinity); this.originalVertices.forEach((v)=>{ maxVertex = maxVertex.max(v,maxVertex); minVertex = minVertex.min(v,minVertex); }); this.calculateSTU(maxVertex, minVertex); this.calculateTrivariateBernsteinPolynomial(minVertex); this.createControlPoints(minVertex); } /** Calculate our local coordinate system S, T, U * * @param max * @param min */ calculateSTU(max, min){ this.S = new THREE.Vector3(max.x - min.x, 0.0, 0.0); this.T = new THREE.Vector3(0.0, max.y - min.y, 0.0); this.U = new THREE.Vector3(0.0, 0.0, max.z - min.z); } /** Generate control points along S, T, U that will deform our object. * * @param origin - Origin of S, T, U */ createControlPoints(origin){ this.controlPoints = []; for(let i = 0; i <= this.L; i++){ this.controlPoints.push([]); for(let j = 0; j <= this.M; j++){ this.controlPoints[i].push([]) for(let k = 0; k <= this.N; k++){ this.controlPoints[i][j].push(this.createControlPoint(origin, i, j, k)); } } } } /** Create individual control point * * @param p0 {THREE.Vector3} - Origin of the entire S, T, U coordinate system. * @param i {int} - Control point along S * @param j {int} - Control point along T * @param k {int} - Control point along U */ createControlPoint(p0, i, j, k){ let LS = this.S.clone(); LS.multiplyScalar(i/parseFloat(this.L)); let MT = this.T.clone(); MT.multiplyScalar(j/this.M); let NU = this.U.clone(); NU.multiplyScalar(k/this.N); let cp = p0.clone().add(LS).add(MT).add(NU); return cp; } /** Precalculate the trivariate bernstein polynomial * * The coefficients created by the tribavariate bernstein poly. * only need to be calculated once. The state of the control points * has no bearing on these values (it uses them, but it doesn't alter them). * Precalculating this here will save us some CPU time down the road. * * @param p0 - Origin of the S, T, U coordinate system. */ calculateTrivariateBernsteinPolynomial(p0){ let TcU = this.T.clone(); TcU.cross(this.U); let ScU = this.S.clone(); ScU.cross(this.U); let ScT = this.S.clone(); ScT.cross(this.T); let TcUdS = TcU.dot(this.S); let ScUdT = ScU.dot(this.T); let ScTdU = ScT.dot(this.U); for (let v = 0; v < this.originalVertices.length; ++v){ let diff = this.originalVertices[v].clone().sub(p0); let tmp = {}; tmp.s = TcU.clone(); tmp.s = tmp.s.dot(diff.clone().divideScalar(TcUdS)); tmp.t = ScU.clone(); tmp.t = tmp.t.dot(diff.clone().divideScalar(ScUdT)); tmp.u = ScT.clone(); tmp.u = tmp.u.dot(diff.clone().divideScalar(ScTdU)); tmp.p = p0.clone(); tmp.p.add(this.S.clone().multiplyScalar(tmp.s)); tmp.p.add(this.T.clone().multiplyScalar(tmp.t)); tmp.p.add(this.U.clone().multiplyScalar(tmp.u)); tmp.p0 = p0.clone(); tmp.bernPolyPack = []; { // Reserve room for each bernstein polynomial pack. tmp.bernPolyPack.push([]); tmp.bernPolyPack.push([]); tmp.bernPolyPack.push([]); } { // Pre-calculate bernstein polynomial expansion. It only needs to be done once per parameterization for (let i = 0; i <= this.L; i++){ for (let j = 0; j <= this.M; j++){ for (let k = 0; k <= this.N; k++){ tmp.bernPolyPack[2].push(this.bernsteinPoly(this.N, k, tmp.u)); } tmp.bernPolyPack[1].push(this.bernsteinPoly(this.M, j, tmp.t)); } tmp.bernPolyPack[0].push(this.bernsteinPoly(this.L, i, tmp.s)); } } this.vertexParams.push(tmp); } } /** Deform vertex by the current state of the control points. * * @param r {bernsteinPoly value} - Single value from 'bernsteinPoly' containing all * data on how all the control points affect a particular vertex. */ getWorldVector3(r){ let l = this.L; let m = this.M; let n = this.N; let tS = new THREE.Vector3(0,0,0); for(let i = 0; i <= l; i++){ let tM = new THREE.Vector3(0,0,0); for(let j = 0; j <= m; j++){ let tK = new THREE.Vector3(0,0,0); for(let k = 0; k <= n; k++){ tK.add(this.controlPoints[i][j][k].clone().multiplyScalar(r.bernPolyPack[2][k])); } tM.add(tK.multiplyScalar(r.bernPolyPack[1][j])); } tS.add(tM.multiplyScalar(r.bernPolyPack[0][i])); } return tS; } /** Call to deform mesh data. * */ updateMesh(){ if(this.target == null){ throw "Call Free Form Deformations 'attach' method before calling 'updateMesh'"; } // Transform 'target's geometry by the position of 'controlPoints' this.vertexParams.forEach((vp,vpi)=>{ let p = this.getWorldVector3(vp); this.transformedVertices[vpi*3] = p.x; this.transformedVertices[vpi*3+1] = p.y; this.transformedVertices[vpi*3+2] = p.z; }); // Make sure to signal THREE.js to update this.target.children[0].geometry.attributes.position.needsUpdate = true; this.target.children[0].geometry.computeBoundingSphere(); } };