Dies ist das Repository meines kleinen Portfolios.
Im Hintergrund läuft eine Planetensimulation, geschrieben in JavaScript und Three.js.
Die zu sehenden Texturen stammen von:
https://www.solarsystemscope.com/textures/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
639 lines
14 KiB
639 lines
14 KiB
/** |
|
* Octahedron and Quantization encodings based on work by: |
|
* |
|
* @link https://github.com/tsherif/mesh-quantization-example |
|
* |
|
*/ |
|
|
|
import { |
|
BufferAttribute, |
|
Matrix3, |
|
Matrix4, |
|
Vector3 |
|
} from 'three'; |
|
import { PackedPhongMaterial } from './PackedPhongMaterial.js'; |
|
|
|
|
|
|
|
/** |
|
* Make the input mesh.geometry's normal attribute encoded and compressed by 3 different methods. |
|
* Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the normal data. |
|
* |
|
* @param {THREE.Mesh} mesh |
|
* @param {String} encodeMethod "DEFAULT" || "OCT1Byte" || "OCT2Byte" || "ANGLES" |
|
* |
|
*/ |
|
function compressNormals( mesh, encodeMethod ) { |
|
|
|
if ( ! mesh.geometry ) { |
|
|
|
console.error( 'Mesh must contain geometry. ' ); |
|
|
|
} |
|
|
|
const normal = mesh.geometry.attributes.normal; |
|
|
|
if ( ! normal ) { |
|
|
|
console.error( 'Geometry must contain normal attribute. ' ); |
|
|
|
} |
|
|
|
if ( normal.isPacked ) return; |
|
|
|
if ( normal.itemSize != 3 ) { |
|
|
|
console.error( 'normal.itemSize is not 3, which cannot be encoded. ' ); |
|
|
|
} |
|
|
|
const array = normal.array; |
|
const count = normal.count; |
|
|
|
let result; |
|
if ( encodeMethod == 'DEFAULT' ) { |
|
|
|
// TODO: Add 1 byte to the result, making the encoded length to be 4 bytes. |
|
result = new Uint8Array( count * 3 ); |
|
|
|
for ( let idx = 0; idx < array.length; idx += 3 ) { |
|
|
|
const encoded = defaultEncode( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 1 ); |
|
|
|
result[ idx + 0 ] = encoded[ 0 ]; |
|
result[ idx + 1 ] = encoded[ 1 ]; |
|
result[ idx + 2 ] = encoded[ 2 ]; |
|
|
|
} |
|
|
|
mesh.geometry.setAttribute( 'normal', new BufferAttribute( result, 3, true ) ); |
|
mesh.geometry.attributes.normal.bytes = result.length * 1; |
|
|
|
} else if ( encodeMethod == 'OCT1Byte' ) { |
|
|
|
/** |
|
* It is not recommended to use 1-byte octahedron normals encoding unless you want to extremely reduce the memory usage |
|
* As it makes vertex data not aligned to a 4 byte boundary which may harm some WebGL implementations and sometimes the normal distortion is visible |
|
* Please refer to @zeux 's comments in https://github.com/mrdoob/three.js/pull/18208 |
|
*/ |
|
|
|
result = new Int8Array( count * 2 ); |
|
|
|
for ( let idx = 0; idx < array.length; idx += 3 ) { |
|
|
|
const encoded = octEncodeBest( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 1 ); |
|
|
|
result[ idx / 3 * 2 + 0 ] = encoded[ 0 ]; |
|
result[ idx / 3 * 2 + 1 ] = encoded[ 1 ]; |
|
|
|
} |
|
|
|
mesh.geometry.setAttribute( 'normal', new BufferAttribute( result, 2, true ) ); |
|
mesh.geometry.attributes.normal.bytes = result.length * 1; |
|
|
|
} else if ( encodeMethod == 'OCT2Byte' ) { |
|
|
|
result = new Int16Array( count * 2 ); |
|
|
|
for ( let idx = 0; idx < array.length; idx += 3 ) { |
|
|
|
const encoded = octEncodeBest( array[ idx ], array[ idx + 1 ], array[ idx + 2 ], 2 ); |
|
|
|
result[ idx / 3 * 2 + 0 ] = encoded[ 0 ]; |
|
result[ idx / 3 * 2 + 1 ] = encoded[ 1 ]; |
|
|
|
} |
|
|
|
mesh.geometry.setAttribute( 'normal', new BufferAttribute( result, 2, true ) ); |
|
mesh.geometry.attributes.normal.bytes = result.length * 2; |
|
|
|
} else if ( encodeMethod == 'ANGLES' ) { |
|
|
|
result = new Uint16Array( count * 2 ); |
|
|
|
for ( let idx = 0; idx < array.length; idx += 3 ) { |
|
|
|
const encoded = anglesEncode( array[ idx ], array[ idx + 1 ], array[ idx + 2 ] ); |
|
|
|
result[ idx / 3 * 2 + 0 ] = encoded[ 0 ]; |
|
result[ idx / 3 * 2 + 1 ] = encoded[ 1 ]; |
|
|
|
} |
|
|
|
mesh.geometry.setAttribute( 'normal', new BufferAttribute( result, 2, true ) ); |
|
mesh.geometry.attributes.normal.bytes = result.length * 2; |
|
|
|
} else { |
|
|
|
console.error( 'Unrecognized encoding method, should be `DEFAULT` or `ANGLES` or `OCT`. ' ); |
|
|
|
} |
|
|
|
mesh.geometry.attributes.normal.needsUpdate = true; |
|
mesh.geometry.attributes.normal.isPacked = true; |
|
mesh.geometry.attributes.normal.packingMethod = encodeMethod; |
|
|
|
// modify material |
|
if ( ! ( mesh.material instanceof PackedPhongMaterial ) ) { |
|
|
|
mesh.material = new PackedPhongMaterial().copy( mesh.material ); |
|
|
|
} |
|
|
|
if ( encodeMethod == 'ANGLES' ) { |
|
|
|
mesh.material.defines.USE_PACKED_NORMAL = 0; |
|
|
|
} |
|
|
|
if ( encodeMethod == 'OCT1Byte' ) { |
|
|
|
mesh.material.defines.USE_PACKED_NORMAL = 1; |
|
|
|
} |
|
|
|
if ( encodeMethod == 'OCT2Byte' ) { |
|
|
|
mesh.material.defines.USE_PACKED_NORMAL = 1; |
|
|
|
} |
|
|
|
if ( encodeMethod == 'DEFAULT' ) { |
|
|
|
mesh.material.defines.USE_PACKED_NORMAL = 2; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
/** |
|
* Make the input mesh.geometry's position attribute encoded and compressed. |
|
* Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the position data. |
|
* |
|
* @param {THREE.Mesh} mesh |
|
* |
|
*/ |
|
function compressPositions( mesh ) { |
|
|
|
if ( ! mesh.geometry ) { |
|
|
|
console.error( 'Mesh must contain geometry. ' ); |
|
|
|
} |
|
|
|
const position = mesh.geometry.attributes.position; |
|
|
|
if ( ! position ) { |
|
|
|
console.error( 'Geometry must contain position attribute. ' ); |
|
|
|
} |
|
|
|
if ( position.isPacked ) return; |
|
|
|
if ( position.itemSize != 3 ) { |
|
|
|
console.error( 'position.itemSize is not 3, which cannot be packed. ' ); |
|
|
|
} |
|
|
|
const array = position.array; |
|
const encodingBytes = 2; |
|
|
|
const result = quantizedEncode( array, encodingBytes ); |
|
|
|
const quantized = result.quantized; |
|
const decodeMat = result.decodeMat; |
|
|
|
// IMPORTANT: calculate original geometry bounding info first, before updating packed positions |
|
if ( mesh.geometry.boundingBox == null ) mesh.geometry.computeBoundingBox(); |
|
if ( mesh.geometry.boundingSphere == null ) mesh.geometry.computeBoundingSphere(); |
|
|
|
mesh.geometry.setAttribute( 'position', new BufferAttribute( quantized, 3 ) ); |
|
mesh.geometry.attributes.position.isPacked = true; |
|
mesh.geometry.attributes.position.needsUpdate = true; |
|
mesh.geometry.attributes.position.bytes = quantized.length * encodingBytes; |
|
|
|
// modify material |
|
if ( ! ( mesh.material instanceof PackedPhongMaterial ) ) { |
|
|
|
mesh.material = new PackedPhongMaterial().copy( mesh.material ); |
|
|
|
} |
|
|
|
mesh.material.defines.USE_PACKED_POSITION = 0; |
|
|
|
mesh.material.uniforms.quantizeMatPos.value = decodeMat; |
|
mesh.material.uniforms.quantizeMatPos.needsUpdate = true; |
|
|
|
} |
|
|
|
/** |
|
* Make the input mesh.geometry's uv attribute encoded and compressed. |
|
* Also will change the mesh.material to `PackedPhongMaterial` which let the vertex shader program decode the uv data. |
|
* |
|
* @param {THREE.Mesh} mesh |
|
* |
|
*/ |
|
function compressUvs( mesh ) { |
|
|
|
if ( ! mesh.geometry ) { |
|
|
|
console.error( 'Mesh must contain geometry property. ' ); |
|
|
|
} |
|
|
|
const uvs = mesh.geometry.attributes.uv; |
|
|
|
if ( ! uvs ) { |
|
|
|
console.error( 'Geometry must contain uv attribute. ' ); |
|
|
|
} |
|
|
|
if ( uvs.isPacked ) return; |
|
|
|
const range = { min: Infinity, max: - Infinity }; |
|
|
|
const array = uvs.array; |
|
|
|
for ( let i = 0; i < array.length; i ++ ) { |
|
|
|
range.min = Math.min( range.min, array[ i ] ); |
|
range.max = Math.max( range.max, array[ i ] ); |
|
|
|
} |
|
|
|
let result; |
|
|
|
if ( range.min >= - 1.0 && range.max <= 1.0 ) { |
|
|
|
// use default encoding method |
|
result = new Uint16Array( array.length ); |
|
|
|
for ( let i = 0; i < array.length; i += 2 ) { |
|
|
|
const encoded = defaultEncode( array[ i ], array[ i + 1 ], 0, 2 ); |
|
|
|
result[ i ] = encoded[ 0 ]; |
|
result[ i + 1 ] = encoded[ 1 ]; |
|
|
|
} |
|
|
|
mesh.geometry.setAttribute( 'uv', new BufferAttribute( result, 2, true ) ); |
|
mesh.geometry.attributes.uv.isPacked = true; |
|
mesh.geometry.attributes.uv.needsUpdate = true; |
|
mesh.geometry.attributes.uv.bytes = result.length * 2; |
|
|
|
if ( ! ( mesh.material instanceof PackedPhongMaterial ) ) { |
|
|
|
mesh.material = new PackedPhongMaterial().copy( mesh.material ); |
|
|
|
} |
|
|
|
mesh.material.defines.USE_PACKED_UV = 0; |
|
|
|
} else { |
|
|
|
// use quantized encoding method |
|
result = quantizedEncodeUV( array, 2 ); |
|
|
|
mesh.geometry.setAttribute( 'uv', new BufferAttribute( result.quantized, 2 ) ); |
|
mesh.geometry.attributes.uv.isPacked = true; |
|
mesh.geometry.attributes.uv.needsUpdate = true; |
|
mesh.geometry.attributes.uv.bytes = result.quantized.length * 2; |
|
|
|
if ( ! ( mesh.material instanceof PackedPhongMaterial ) ) { |
|
|
|
mesh.material = new PackedPhongMaterial().copy( mesh.material ); |
|
|
|
} |
|
|
|
mesh.material.defines.USE_PACKED_UV = 1; |
|
|
|
mesh.material.uniforms.quantizeMatUV.value = result.decodeMat; |
|
mesh.material.uniforms.quantizeMatUV.needsUpdate = true; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
// Encoding functions |
|
|
|
function defaultEncode( x, y, z, bytes ) { |
|
|
|
if ( bytes == 1 ) { |
|
|
|
const tmpx = Math.round( ( x + 1 ) * 0.5 * 255 ); |
|
const tmpy = Math.round( ( y + 1 ) * 0.5 * 255 ); |
|
const tmpz = Math.round( ( z + 1 ) * 0.5 * 255 ); |
|
return new Uint8Array( [ tmpx, tmpy, tmpz ] ); |
|
|
|
} else if ( bytes == 2 ) { |
|
|
|
const tmpx = Math.round( ( x + 1 ) * 0.5 * 65535 ); |
|
const tmpy = Math.round( ( y + 1 ) * 0.5 * 65535 ); |
|
const tmpz = Math.round( ( z + 1 ) * 0.5 * 65535 ); |
|
return new Uint16Array( [ tmpx, tmpy, tmpz ] ); |
|
|
|
} else { |
|
|
|
console.error( 'number of bytes must be 1 or 2' ); |
|
|
|
} |
|
|
|
} |
|
|
|
// for `Angles` encoding |
|
function anglesEncode( x, y, z ) { |
|
|
|
const normal0 = parseInt( 0.5 * ( 1.0 + Math.atan2( y, x ) / Math.PI ) * 65535 ); |
|
const normal1 = parseInt( 0.5 * ( 1.0 + z ) * 65535 ); |
|
return new Uint16Array( [ normal0, normal1 ] ); |
|
|
|
} |
|
|
|
// for `Octahedron` encoding |
|
function octEncodeBest( x, y, z, bytes ) { |
|
|
|
let oct, dec, best, currentCos, bestCos; |
|
|
|
// Test various combinations of ceil and floor |
|
// to minimize rounding errors |
|
best = oct = octEncodeVec3( x, y, z, 'floor', 'floor' ); |
|
dec = octDecodeVec2( oct ); |
|
bestCos = dot( x, y, z, dec ); |
|
|
|
oct = octEncodeVec3( x, y, z, 'ceil', 'floor' ); |
|
dec = octDecodeVec2( oct ); |
|
currentCos = dot( x, y, z, dec ); |
|
|
|
if ( currentCos > bestCos ) { |
|
|
|
best = oct; |
|
bestCos = currentCos; |
|
|
|
} |
|
|
|
oct = octEncodeVec3( x, y, z, 'floor', 'ceil' ); |
|
dec = octDecodeVec2( oct ); |
|
currentCos = dot( x, y, z, dec ); |
|
|
|
if ( currentCos > bestCos ) { |
|
|
|
best = oct; |
|
bestCos = currentCos; |
|
|
|
} |
|
|
|
oct = octEncodeVec3( x, y, z, 'ceil', 'ceil' ); |
|
dec = octDecodeVec2( oct ); |
|
currentCos = dot( x, y, z, dec ); |
|
|
|
if ( currentCos > bestCos ) { |
|
|
|
best = oct; |
|
|
|
} |
|
|
|
return best; |
|
|
|
function octEncodeVec3( x0, y0, z0, xfunc, yfunc ) { |
|
|
|
let x = x0 / ( Math.abs( x0 ) + Math.abs( y0 ) + Math.abs( z0 ) ); |
|
let y = y0 / ( Math.abs( x0 ) + Math.abs( y0 ) + Math.abs( z0 ) ); |
|
|
|
if ( z < 0 ) { |
|
|
|
const tempx = ( 1 - Math.abs( y ) ) * ( x >= 0 ? 1 : - 1 ); |
|
const tempy = ( 1 - Math.abs( x ) ) * ( y >= 0 ? 1 : - 1 ); |
|
|
|
x = tempx; |
|
y = tempy; |
|
|
|
let diff = 1 - Math.abs( x ) - Math.abs( y ); |
|
if ( diff > 0 ) { |
|
|
|
diff += 0.001; |
|
x += x > 0 ? diff / 2 : - diff / 2; |
|
y += y > 0 ? diff / 2 : - diff / 2; |
|
|
|
} |
|
|
|
} |
|
|
|
if ( bytes == 1 ) { |
|
|
|
return new Int8Array( [ |
|
Math[ xfunc ]( x * 127.5 + ( x < 0 ? 1 : 0 ) ), |
|
Math[ yfunc ]( y * 127.5 + ( y < 0 ? 1 : 0 ) ) |
|
] ); |
|
|
|
} |
|
|
|
if ( bytes == 2 ) { |
|
|
|
return new Int16Array( [ |
|
Math[ xfunc ]( x * 32767.5 + ( x < 0 ? 1 : 0 ) ), |
|
Math[ yfunc ]( y * 32767.5 + ( y < 0 ? 1 : 0 ) ) |
|
] ); |
|
|
|
} |
|
|
|
|
|
} |
|
|
|
function octDecodeVec2( oct ) { |
|
|
|
let x = oct[ 0 ]; |
|
let y = oct[ 1 ]; |
|
|
|
if ( bytes == 1 ) { |
|
|
|
x /= x < 0 ? 127 : 128; |
|
y /= y < 0 ? 127 : 128; |
|
|
|
} else if ( bytes == 2 ) { |
|
|
|
x /= x < 0 ? 32767 : 32768; |
|
y /= y < 0 ? 32767 : 32768; |
|
|
|
} |
|
|
|
|
|
const z = 1 - Math.abs( x ) - Math.abs( y ); |
|
|
|
if ( z < 0 ) { |
|
|
|
const tmpx = x; |
|
x = ( 1 - Math.abs( y ) ) * ( x >= 0 ? 1 : - 1 ); |
|
y = ( 1 - Math.abs( tmpx ) ) * ( y >= 0 ? 1 : - 1 ); |
|
|
|
} |
|
|
|
const length = Math.sqrt( x * x + y * y + z * z ); |
|
|
|
return [ |
|
x / length, |
|
y / length, |
|
z / length |
|
]; |
|
|
|
} |
|
|
|
function dot( x, y, z, vec3 ) { |
|
|
|
return x * vec3[ 0 ] + y * vec3[ 1 ] + z * vec3[ 2 ]; |
|
|
|
} |
|
|
|
} |
|
|
|
function quantizedEncode( array, bytes ) { |
|
|
|
let quantized, segments; |
|
|
|
if ( bytes == 1 ) { |
|
|
|
quantized = new Uint8Array( array.length ); |
|
segments = 255; |
|
|
|
} else if ( bytes == 2 ) { |
|
|
|
quantized = new Uint16Array( array.length ); |
|
segments = 65535; |
|
|
|
} else { |
|
|
|
console.error( 'number of bytes error! ' ); |
|
|
|
} |
|
|
|
const decodeMat = new Matrix4(); |
|
|
|
const min = new Float32Array( 3 ); |
|
const max = new Float32Array( 3 ); |
|
|
|
min[ 0 ] = min[ 1 ] = min[ 2 ] = Number.MAX_VALUE; |
|
max[ 0 ] = max[ 1 ] = max[ 2 ] = - Number.MAX_VALUE; |
|
|
|
for ( let i = 0; i < array.length; i += 3 ) { |
|
|
|
min[ 0 ] = Math.min( min[ 0 ], array[ i + 0 ] ); |
|
min[ 1 ] = Math.min( min[ 1 ], array[ i + 1 ] ); |
|
min[ 2 ] = Math.min( min[ 2 ], array[ i + 2 ] ); |
|
max[ 0 ] = Math.max( max[ 0 ], array[ i + 0 ] ); |
|
max[ 1 ] = Math.max( max[ 1 ], array[ i + 1 ] ); |
|
max[ 2 ] = Math.max( max[ 2 ], array[ i + 2 ] ); |
|
|
|
} |
|
|
|
decodeMat.scale( new Vector3( |
|
( max[ 0 ] - min[ 0 ] ) / segments, |
|
( max[ 1 ] - min[ 1 ] ) / segments, |
|
( max[ 2 ] - min[ 2 ] ) / segments |
|
) ); |
|
|
|
decodeMat.elements[ 12 ] = min[ 0 ]; |
|
decodeMat.elements[ 13 ] = min[ 1 ]; |
|
decodeMat.elements[ 14 ] = min[ 2 ]; |
|
|
|
decodeMat.transpose(); |
|
|
|
|
|
const multiplier = new Float32Array( [ |
|
max[ 0 ] !== min[ 0 ] ? segments / ( max[ 0 ] - min[ 0 ] ) : 0, |
|
max[ 1 ] !== min[ 1 ] ? segments / ( max[ 1 ] - min[ 1 ] ) : 0, |
|
max[ 2 ] !== min[ 2 ] ? segments / ( max[ 2 ] - min[ 2 ] ) : 0 |
|
] ); |
|
|
|
for ( let i = 0; i < array.length; i += 3 ) { |
|
|
|
quantized[ i + 0 ] = Math.floor( ( array[ i + 0 ] - min[ 0 ] ) * multiplier[ 0 ] ); |
|
quantized[ i + 1 ] = Math.floor( ( array[ i + 1 ] - min[ 1 ] ) * multiplier[ 1 ] ); |
|
quantized[ i + 2 ] = Math.floor( ( array[ i + 2 ] - min[ 2 ] ) * multiplier[ 2 ] ); |
|
|
|
} |
|
|
|
return { |
|
quantized: quantized, |
|
decodeMat: decodeMat |
|
}; |
|
|
|
} |
|
|
|
function quantizedEncodeUV( array, bytes ) { |
|
|
|
let quantized, segments; |
|
|
|
if ( bytes == 1 ) { |
|
|
|
quantized = new Uint8Array( array.length ); |
|
segments = 255; |
|
|
|
} else if ( bytes == 2 ) { |
|
|
|
quantized = new Uint16Array( array.length ); |
|
segments = 65535; |
|
|
|
} else { |
|
|
|
console.error( 'number of bytes error! ' ); |
|
|
|
} |
|
|
|
const decodeMat = new Matrix3(); |
|
|
|
const min = new Float32Array( 2 ); |
|
const max = new Float32Array( 2 ); |
|
|
|
min[ 0 ] = min[ 1 ] = Number.MAX_VALUE; |
|
max[ 0 ] = max[ 1 ] = - Number.MAX_VALUE; |
|
|
|
for ( let i = 0; i < array.length; i += 2 ) { |
|
|
|
min[ 0 ] = Math.min( min[ 0 ], array[ i + 0 ] ); |
|
min[ 1 ] = Math.min( min[ 1 ], array[ i + 1 ] ); |
|
max[ 0 ] = Math.max( max[ 0 ], array[ i + 0 ] ); |
|
max[ 1 ] = Math.max( max[ 1 ], array[ i + 1 ] ); |
|
|
|
} |
|
|
|
decodeMat.scale( |
|
( max[ 0 ] - min[ 0 ] ) / segments, |
|
( max[ 1 ] - min[ 1 ] ) / segments |
|
); |
|
|
|
decodeMat.elements[ 6 ] = min[ 0 ]; |
|
decodeMat.elements[ 7 ] = min[ 1 ]; |
|
|
|
decodeMat.transpose(); |
|
|
|
const multiplier = new Float32Array( [ |
|
max[ 0 ] !== min[ 0 ] ? segments / ( max[ 0 ] - min[ 0 ] ) : 0, |
|
max[ 1 ] !== min[ 1 ] ? segments / ( max[ 1 ] - min[ 1 ] ) : 0 |
|
] ); |
|
|
|
for ( let i = 0; i < array.length; i += 2 ) { |
|
|
|
quantized[ i + 0 ] = Math.floor( ( array[ i + 0 ] - min[ 0 ] ) * multiplier[ 0 ] ); |
|
quantized[ i + 1 ] = Math.floor( ( array[ i + 1 ] - min[ 1 ] ) * multiplier[ 1 ] ); |
|
|
|
} |
|
|
|
return { |
|
quantized: quantized, |
|
decodeMat: decodeMat |
|
}; |
|
|
|
} |
|
|
|
|
|
|
|
export { |
|
compressNormals, |
|
compressPositions, |
|
compressUvs, |
|
};
|
|
|