|
|
@@ -1,144 +0,0 @@
|
|
|
-/**
|
|
|
- * @author santiago / @glitch_life
|
|
|
- * wrapper of https://www.npmjs.com/package/isosurface by https://github.com/mikolalysenko
|
|
|
- *
|
|
|
- * Returns BufferGeometry from SDF
|
|
|
- */
|
|
|
-
|
|
|
-import {
|
|
|
- BufferAttribute,
|
|
|
- BufferGeometry,
|
|
|
- FloatType,
|
|
|
- Mesh,
|
|
|
- OrthographicCamera,
|
|
|
- PlaneGeometry,
|
|
|
- Scene,
|
|
|
- ShaderMaterial,
|
|
|
- Vector2,
|
|
|
- WebGLRenderTarget
|
|
|
-} from 'three';
|
|
|
-
|
|
|
-import { surfaceNet } from './../libs/surfaceNet.js';
|
|
|
-
|
|
|
-class SDFGeometryGenerator {
|
|
|
-
|
|
|
- constructor( renderer ) {
|
|
|
-
|
|
|
- this.renderer = renderer;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- generate( res = 64, distFunc = 'float dist( vec3 p ){ return length(p) - 0.5; }', bounds = 1 ) {
|
|
|
-
|
|
|
- let w, h;
|
|
|
- if ( res == 8 ) [ w, h ] = [ 32, 16 ];
|
|
|
- else if ( res == 16 ) [ w, h ] = [ 64, 64 ];
|
|
|
- else if ( res == 32 ) [ w, h ] = [ 256, 128 ];
|
|
|
- else if ( res == 64 ) [ w, h ] = [ 512, 512 ];
|
|
|
- else if ( res == 128 ) [ w, h ] = [ 2048, 1024 ];
|
|
|
- else if ( res == 256 ) [ w, h ] = [ 4096, 4096 ];
|
|
|
- else if ( res == 512 ) [ w, h ] = [ 16384, 8096 ];
|
|
|
- else if ( res == 1024 ) [ w, h ] = [ 32768, 32768 ];
|
|
|
- else throw new Error( 'THREE.SDFGeometryGenerator: Resolution must be in range 8 < res < 1024 and must be ^2' );
|
|
|
-
|
|
|
- const maxTexSize = this.renderer.capabilities.maxTextureSize;
|
|
|
-
|
|
|
- if ( w > maxTexSize || h > maxTexSize ) throw new Error( 'THREE.SDFGeometryGenerator: Your device does not support this resolution ( ' + res + ' ), decrease [res] param.' );
|
|
|
-
|
|
|
- const [ tilesX, tilesY ] = [ ( w / res ), ( h / res ) ];
|
|
|
-
|
|
|
- const sdfCompute = `
|
|
|
- varying vec2 vUv;
|
|
|
- uniform float tileNum;
|
|
|
- uniform float bounds;
|
|
|
- [#dist#]
|
|
|
- void main() { gl_FragColor=vec4( ( dist( vec3( vUv, tileNum ) * 2.0 * bounds - vec3( bounds ) ) < 0.00001 ) ? 1.0 : 0.0 ); }
|
|
|
- `;
|
|
|
-
|
|
|
- const sdfRT = this.computeSDF( w, h, tilesX, tilesY, bounds, sdfCompute.replace( '[#dist#]', distFunc ) );
|
|
|
-
|
|
|
- const read = new Float32Array( w * h * 4 );
|
|
|
- this.renderer.readRenderTargetPixels( sdfRT, 0, 0, w, h, read );
|
|
|
- sdfRT.dispose();
|
|
|
-
|
|
|
- //
|
|
|
-
|
|
|
- const mesh = surfaceNet( [ res, res, res ], ( x, y, z ) => {
|
|
|
-
|
|
|
- x = ( x + bounds ) * ( res / ( bounds * 2 ) );
|
|
|
- y = ( y + bounds ) * ( res / ( bounds * 2 ) );
|
|
|
- z = ( z + bounds ) * ( res / ( bounds * 2 ) );
|
|
|
- let p = ( x + ( z % tilesX ) * res ) + y * w + ( Math.floor( z / tilesX ) * res * w );
|
|
|
- p *= 4;
|
|
|
- return ( read[ p + 3 ] > 0 ) ? - 0.000000001 : 1;
|
|
|
-
|
|
|
- }, [[ - bounds, - bounds, - bounds ], [ bounds, bounds, bounds ]] );
|
|
|
-
|
|
|
- const ps = [], ids = [];
|
|
|
- const geometry = new BufferGeometry();
|
|
|
- mesh.positions.forEach( p => {
|
|
|
-
|
|
|
- ps.push( p[ 0 ], p[ 1 ], p[ 2 ] );
|
|
|
-
|
|
|
- } );
|
|
|
- mesh.cells.forEach( p => ids.push( p[ 0 ], p[ 1 ], p[ 2 ] ) );
|
|
|
- geometry.setAttribute( 'position', new BufferAttribute( new Float32Array( ps ), 3 ) );
|
|
|
- geometry.setIndex( ids );
|
|
|
-
|
|
|
- return geometry;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- computeSDF( width, height, tilesX, tilesY, bounds, shader ) {
|
|
|
-
|
|
|
- const rt = new WebGLRenderTarget( width, height, { type: FloatType } );
|
|
|
- const scn = new Scene();
|
|
|
- const cam = new OrthographicCamera();
|
|
|
- const tiles = tilesX * tilesY;
|
|
|
- let currentTile = 0;
|
|
|
-
|
|
|
- Object.assign( cam, { left: width / - 2, right: width / 2, top: height / 2, bottom: height / - 2 } ).updateProjectionMatrix();
|
|
|
- cam.position.z = 2;
|
|
|
-
|
|
|
- const tileSize = width / tilesX;
|
|
|
- const geometry = new PlaneGeometry( tileSize, tileSize );
|
|
|
-
|
|
|
- while ( currentTile ++ < tiles ) {
|
|
|
-
|
|
|
- const c = currentTile - 1;
|
|
|
- const [ px, py ] = [ ( tileSize ) / 2 + ( c % tilesX ) * ( tileSize ) - width / 2, ( tileSize ) / 2 + Math.floor( c / tilesX ) * ( tileSize ) - height / 2 ];
|
|
|
- const compPlane = new Mesh( geometry, new ShaderMaterial( {
|
|
|
- uniforms: {
|
|
|
- res: { value: new Vector2( width, height ) },
|
|
|
- tileNum: { value: c / ( tilesX * tilesY - 1 ) },
|
|
|
- bounds: { value: bounds }
|
|
|
- },
|
|
|
- vertexShader: 'varying vec2 vUv;void main(){vUv=uv;gl_Position=projectionMatrix*modelViewMatrix*vec4(position,1.0);}',
|
|
|
- fragmentShader: shader
|
|
|
- } ) );
|
|
|
- compPlane.position.set( px, py, 0 );
|
|
|
- scn.add( compPlane );
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- this.renderer.setRenderTarget( rt );
|
|
|
- this.renderer.render( scn, cam );
|
|
|
- this.renderer.setRenderTarget( null );
|
|
|
-
|
|
|
- //
|
|
|
-
|
|
|
- geometry.dispose();
|
|
|
-
|
|
|
- scn.traverse( function ( object ) {
|
|
|
-
|
|
|
- if ( object.material !== undefined ) object.material.dispose();
|
|
|
-
|
|
|
- } );
|
|
|
-
|
|
|
- return rt;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-export { SDFGeometryGenerator };
|
Michael Herzog
