添加关照、全局等高线、修改图层问题
This commit is contained in:
267
static/sdk/three/jsm/exporters/DRACOExporter.js
Normal file
267
static/sdk/three/jsm/exporters/DRACOExporter.js
Normal file
@ -0,0 +1,267 @@
|
||||
import { Color } from 'three';
|
||||
|
||||
/**
|
||||
* Export draco compressed files from threejs geometry objects.
|
||||
*
|
||||
* Draco files are compressed and usually are smaller than conventional 3D file formats.
|
||||
*
|
||||
* The exporter receives a options object containing
|
||||
* - decodeSpeed, indicates how to tune the encoder regarding decode speed (0 gives better speed but worst quality)
|
||||
* - encodeSpeed, indicates how to tune the encoder parameters (0 gives better speed but worst quality)
|
||||
* - encoderMethod
|
||||
* - quantization, indicates the presision of each type of data stored in the draco file in the order (POSITION, NORMAL, COLOR, TEX_COORD, GENERIC)
|
||||
* - exportUvs
|
||||
* - exportNormals
|
||||
* - exportColor
|
||||
*/
|
||||
|
||||
/* global DracoEncoderModule */
|
||||
|
||||
class DRACOExporter {
|
||||
|
||||
parse( object, options = {} ) {
|
||||
|
||||
options = Object.assign( {
|
||||
decodeSpeed: 5,
|
||||
encodeSpeed: 5,
|
||||
encoderMethod: DRACOExporter.MESH_EDGEBREAKER_ENCODING,
|
||||
quantization: [ 16, 8, 8, 8, 8 ],
|
||||
exportUvs: true,
|
||||
exportNormals: true,
|
||||
exportColor: false,
|
||||
}, options );
|
||||
|
||||
if ( DracoEncoderModule === undefined ) {
|
||||
|
||||
throw new Error( 'THREE.DRACOExporter: required the draco_encoder to work.' );
|
||||
|
||||
}
|
||||
|
||||
const geometry = object.geometry;
|
||||
|
||||
const dracoEncoder = DracoEncoderModule();
|
||||
const encoder = new dracoEncoder.Encoder();
|
||||
let builder;
|
||||
let dracoObject;
|
||||
|
||||
if ( object.isMesh === true ) {
|
||||
|
||||
builder = new dracoEncoder.MeshBuilder();
|
||||
dracoObject = new dracoEncoder.Mesh();
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array );
|
||||
|
||||
const faces = geometry.getIndex();
|
||||
|
||||
if ( faces !== null ) {
|
||||
|
||||
builder.AddFacesToMesh( dracoObject, faces.count / 3, faces.array );
|
||||
|
||||
} else {
|
||||
|
||||
const faces = new ( vertices.count > 65535 ? Uint32Array : Uint16Array )( vertices.count );
|
||||
|
||||
for ( let i = 0; i < faces.length; i ++ ) {
|
||||
|
||||
faces[ i ] = i;
|
||||
|
||||
}
|
||||
|
||||
builder.AddFacesToMesh( dracoObject, vertices.count, faces );
|
||||
|
||||
}
|
||||
|
||||
if ( options.exportNormals === true ) {
|
||||
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
|
||||
if ( normals !== undefined ) {
|
||||
|
||||
builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.NORMAL, normals.count, normals.itemSize, normals.array );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( options.exportUvs === true ) {
|
||||
|
||||
const uvs = geometry.getAttribute( 'uv' );
|
||||
|
||||
if ( uvs !== undefined ) {
|
||||
|
||||
builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.TEX_COORD, uvs.count, uvs.itemSize, uvs.array );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( options.exportColor === true ) {
|
||||
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
|
||||
if ( colors !== undefined ) {
|
||||
|
||||
const array = createVertexColorSRGBArray( colors );
|
||||
|
||||
builder.AddFloatAttributeToMesh( dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, array );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} else if ( object.isPoints === true ) {
|
||||
|
||||
builder = new dracoEncoder.PointCloudBuilder();
|
||||
dracoObject = new dracoEncoder.PointCloud();
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
builder.AddFloatAttribute( dracoObject, dracoEncoder.POSITION, vertices.count, vertices.itemSize, vertices.array );
|
||||
|
||||
if ( options.exportColor === true ) {
|
||||
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
|
||||
if ( colors !== undefined ) {
|
||||
|
||||
const array = createVertexColorSRGBArray( colors );
|
||||
|
||||
builder.AddFloatAttribute( dracoObject, dracoEncoder.COLOR, colors.count, colors.itemSize, array );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
throw new Error( 'DRACOExporter: Unsupported object type.' );
|
||||
|
||||
}
|
||||
|
||||
//Compress using draco encoder
|
||||
|
||||
const encodedData = new dracoEncoder.DracoInt8Array();
|
||||
|
||||
//Sets the desired encoding and decoding speed for the given options from 0 (slowest speed, but the best compression) to 10 (fastest, but the worst compression).
|
||||
|
||||
const encodeSpeed = ( options.encodeSpeed !== undefined ) ? options.encodeSpeed : 5;
|
||||
const decodeSpeed = ( options.decodeSpeed !== undefined ) ? options.decodeSpeed : 5;
|
||||
|
||||
encoder.SetSpeedOptions( encodeSpeed, decodeSpeed );
|
||||
|
||||
// Sets the desired encoding method for a given geometry.
|
||||
|
||||
if ( options.encoderMethod !== undefined ) {
|
||||
|
||||
encoder.SetEncodingMethod( options.encoderMethod );
|
||||
|
||||
}
|
||||
|
||||
// Sets the quantization (number of bits used to represent) compression options for a named attribute.
|
||||
// The attribute values will be quantized in a box defined by the maximum extent of the attribute values.
|
||||
if ( options.quantization !== undefined ) {
|
||||
|
||||
for ( let i = 0; i < 5; i ++ ) {
|
||||
|
||||
if ( options.quantization[ i ] !== undefined ) {
|
||||
|
||||
encoder.SetAttributeQuantization( i, options.quantization[ i ] );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
let length;
|
||||
|
||||
if ( object.isMesh === true ) {
|
||||
|
||||
length = encoder.EncodeMeshToDracoBuffer( dracoObject, encodedData );
|
||||
|
||||
} else {
|
||||
|
||||
length = encoder.EncodePointCloudToDracoBuffer( dracoObject, true, encodedData );
|
||||
|
||||
}
|
||||
|
||||
dracoEncoder.destroy( dracoObject );
|
||||
|
||||
if ( length === 0 ) {
|
||||
|
||||
throw new Error( 'THREE.DRACOExporter: Draco encoding failed.' );
|
||||
|
||||
}
|
||||
|
||||
//Copy encoded data to buffer.
|
||||
const outputData = new Int8Array( new ArrayBuffer( length ) );
|
||||
|
||||
for ( let i = 0; i < length; i ++ ) {
|
||||
|
||||
outputData[ i ] = encodedData.GetValue( i );
|
||||
|
||||
}
|
||||
|
||||
dracoEncoder.destroy( encodedData );
|
||||
dracoEncoder.destroy( encoder );
|
||||
dracoEncoder.destroy( builder );
|
||||
|
||||
return outputData;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function createVertexColorSRGBArray( attribute ) {
|
||||
|
||||
// While .drc files do not specify colorspace, the only 'official' tooling
|
||||
// is PLY and OBJ converters, which use sRGB. We'll assume sRGB is expected
|
||||
// for .drc files, but note that Draco buffers embedded in glTF files will
|
||||
// be Linear-sRGB instead.
|
||||
|
||||
const _color = new Color();
|
||||
|
||||
const count = attribute.count;
|
||||
const itemSize = attribute.itemSize;
|
||||
const array = new Float32Array( count * itemSize );
|
||||
|
||||
for ( let i = 0, il = count; i < il; i ++ ) {
|
||||
|
||||
_color.fromBufferAttribute( attribute, i ).convertLinearToSRGB();
|
||||
|
||||
array[ i * itemSize ] = _color.r;
|
||||
array[ i * itemSize + 1 ] = _color.g;
|
||||
array[ i * itemSize + 2 ] = _color.b;
|
||||
|
||||
if ( itemSize === 4 ) {
|
||||
|
||||
array[ i * itemSize + 3 ] = attribute.getW( i );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return array;
|
||||
|
||||
}
|
||||
|
||||
// Encoder methods
|
||||
|
||||
DRACOExporter.MESH_EDGEBREAKER_ENCODING = 1;
|
||||
DRACOExporter.MESH_SEQUENTIAL_ENCODING = 0;
|
||||
|
||||
// Geometry type
|
||||
|
||||
DRACOExporter.POINT_CLOUD = 0;
|
||||
DRACOExporter.TRIANGULAR_MESH = 1;
|
||||
|
||||
// Attribute type
|
||||
|
||||
DRACOExporter.INVALID = - 1;
|
||||
DRACOExporter.POSITION = 0;
|
||||
DRACOExporter.NORMAL = 1;
|
||||
DRACOExporter.COLOR = 2;
|
||||
DRACOExporter.TEX_COORD = 3;
|
||||
DRACOExporter.GENERIC = 4;
|
||||
|
||||
export { DRACOExporter };
|
||||
579
static/sdk/three/jsm/exporters/EXRExporter.js
Normal file
579
static/sdk/three/jsm/exporters/EXRExporter.js
Normal file
@ -0,0 +1,579 @@
|
||||
/**
|
||||
* @author sciecode / https://github.com/sciecode
|
||||
*
|
||||
* EXR format references:
|
||||
* https://www.openexr.com/documentation/openexrfilelayout.pdf
|
||||
*/
|
||||
|
||||
import {
|
||||
FloatType,
|
||||
HalfFloatType,
|
||||
RGBAFormat,
|
||||
DataUtils,
|
||||
} from 'three';
|
||||
import * as fflate from '../libs/fflate.module.js';
|
||||
|
||||
const textEncoder = new TextEncoder();
|
||||
|
||||
const NO_COMPRESSION = 0;
|
||||
const ZIPS_COMPRESSION = 2;
|
||||
const ZIP_COMPRESSION = 3;
|
||||
|
||||
class EXRExporter {
|
||||
|
||||
parse( arg1, arg2, arg3 ) {
|
||||
|
||||
if ( ! arg1 || ! ( arg1.isWebGLRenderer || arg1.isDataTexture ) ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported first parameter, expected instance of WebGLRenderer or DataTexture.' );
|
||||
|
||||
} else if ( arg1.isWebGLRenderer ) {
|
||||
|
||||
const renderer = arg1, renderTarget = arg2, options = arg3;
|
||||
|
||||
supportedRTT( renderTarget );
|
||||
|
||||
const info = buildInfoRTT( renderTarget, options ),
|
||||
dataBuffer = getPixelData( renderer, renderTarget, info ),
|
||||
rawContentBuffer = reorganizeDataBuffer( dataBuffer, info ),
|
||||
chunks = compressData( rawContentBuffer, info );
|
||||
|
||||
return fillData( chunks, info );
|
||||
|
||||
} else if ( arg1.isDataTexture ) {
|
||||
|
||||
const texture = arg1, options = arg2;
|
||||
|
||||
supportedDT( texture );
|
||||
|
||||
const info = buildInfoDT( texture, options ),
|
||||
dataBuffer = texture.image.data,
|
||||
rawContentBuffer = reorganizeDataBuffer( dataBuffer, info ),
|
||||
chunks = compressData( rawContentBuffer, info );
|
||||
|
||||
return fillData( chunks, info );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function supportedRTT( renderTarget ) {
|
||||
|
||||
if ( ! renderTarget || ! renderTarget.isWebGLRenderTarget ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported second parameter, expected instance of WebGLRenderTarget.' );
|
||||
|
||||
}
|
||||
|
||||
if ( renderTarget.isWebGLCubeRenderTarget || renderTarget.isWebGL3DRenderTarget || renderTarget.isWebGLArrayRenderTarget ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported render target type, expected instance of WebGLRenderTarget.' );
|
||||
|
||||
}
|
||||
|
||||
if ( renderTarget.texture.type !== FloatType && renderTarget.texture.type !== HalfFloatType ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported WebGLRenderTarget texture type.' );
|
||||
|
||||
}
|
||||
|
||||
if ( renderTarget.texture.format !== RGBAFormat ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported WebGLRenderTarget texture format, expected RGBAFormat.' );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function supportedDT( texture ) {
|
||||
|
||||
if ( texture.type !== FloatType && texture.type !== HalfFloatType ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported DataTexture texture type.' );
|
||||
|
||||
}
|
||||
|
||||
if ( texture.format !== RGBAFormat ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Unsupported DataTexture texture format, expected RGBAFormat.' );
|
||||
|
||||
}
|
||||
|
||||
if ( ! texture.image.data ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: Invalid DataTexture image data.' );
|
||||
|
||||
}
|
||||
|
||||
if ( texture.type === FloatType && texture.image.data.constructor.name !== 'Float32Array' ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: DataTexture image data doesn\'t match type, expected \'Float32Array\'.' );
|
||||
|
||||
}
|
||||
|
||||
if ( texture.type === HalfFloatType && texture.image.data.constructor.name !== 'Uint16Array' ) {
|
||||
|
||||
throw Error( 'EXRExporter.parse: DataTexture image data doesn\'t match type, expected \'Uint16Array\'.' );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function buildInfoRTT( renderTarget, options = {} ) {
|
||||
|
||||
const compressionSizes = {
|
||||
0: 1,
|
||||
2: 1,
|
||||
3: 16
|
||||
};
|
||||
|
||||
const WIDTH = renderTarget.width,
|
||||
HEIGHT = renderTarget.height,
|
||||
TYPE = renderTarget.texture.type,
|
||||
FORMAT = renderTarget.texture.format,
|
||||
COMPRESSION = ( options.compression !== undefined ) ? options.compression : ZIP_COMPRESSION,
|
||||
EXPORTER_TYPE = ( options.type !== undefined ) ? options.type : HalfFloatType,
|
||||
OUT_TYPE = ( EXPORTER_TYPE === FloatType ) ? 2 : 1,
|
||||
COMPRESSION_SIZE = compressionSizes[ COMPRESSION ],
|
||||
NUM_CHANNELS = 4;
|
||||
|
||||
return {
|
||||
width: WIDTH,
|
||||
height: HEIGHT,
|
||||
type: TYPE,
|
||||
format: FORMAT,
|
||||
compression: COMPRESSION,
|
||||
blockLines: COMPRESSION_SIZE,
|
||||
dataType: OUT_TYPE,
|
||||
dataSize: 2 * OUT_TYPE,
|
||||
numBlocks: Math.ceil( HEIGHT / COMPRESSION_SIZE ),
|
||||
numInputChannels: 4,
|
||||
numOutputChannels: NUM_CHANNELS,
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
function buildInfoDT( texture, options = {} ) {
|
||||
|
||||
const compressionSizes = {
|
||||
0: 1,
|
||||
2: 1,
|
||||
3: 16
|
||||
};
|
||||
|
||||
const WIDTH = texture.image.width,
|
||||
HEIGHT = texture.image.height,
|
||||
TYPE = texture.type,
|
||||
FORMAT = texture.format,
|
||||
COMPRESSION = ( options.compression !== undefined ) ? options.compression : ZIP_COMPRESSION,
|
||||
EXPORTER_TYPE = ( options.type !== undefined ) ? options.type : HalfFloatType,
|
||||
OUT_TYPE = ( EXPORTER_TYPE === FloatType ) ? 2 : 1,
|
||||
COMPRESSION_SIZE = compressionSizes[ COMPRESSION ],
|
||||
NUM_CHANNELS = 4;
|
||||
|
||||
return {
|
||||
width: WIDTH,
|
||||
height: HEIGHT,
|
||||
type: TYPE,
|
||||
format: FORMAT,
|
||||
compression: COMPRESSION,
|
||||
blockLines: COMPRESSION_SIZE,
|
||||
dataType: OUT_TYPE,
|
||||
dataSize: 2 * OUT_TYPE,
|
||||
numBlocks: Math.ceil( HEIGHT / COMPRESSION_SIZE ),
|
||||
numInputChannels: 4,
|
||||
numOutputChannels: NUM_CHANNELS,
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
function getPixelData( renderer, rtt, info ) {
|
||||
|
||||
let dataBuffer;
|
||||
|
||||
if ( info.type === FloatType ) {
|
||||
|
||||
dataBuffer = new Float32Array( info.width * info.height * info.numInputChannels );
|
||||
|
||||
} else {
|
||||
|
||||
dataBuffer = new Uint16Array( info.width * info.height * info.numInputChannels );
|
||||
|
||||
}
|
||||
|
||||
renderer.readRenderTargetPixels( rtt, 0, 0, info.width, info.height, dataBuffer );
|
||||
|
||||
return dataBuffer;
|
||||
|
||||
}
|
||||
|
||||
function reorganizeDataBuffer( inBuffer, info ) {
|
||||
|
||||
const w = info.width,
|
||||
h = info.height,
|
||||
dec = { r: 0, g: 0, b: 0, a: 0 },
|
||||
offset = { value: 0 },
|
||||
cOffset = ( info.numOutputChannels == 4 ) ? 1 : 0,
|
||||
getValue = ( info.type == FloatType ) ? getFloat32 : getFloat16,
|
||||
setValue = ( info.dataType == 1 ) ? setFloat16 : setFloat32,
|
||||
outBuffer = new Uint8Array( info.width * info.height * info.numOutputChannels * info.dataSize ),
|
||||
dv = new DataView( outBuffer.buffer );
|
||||
|
||||
for ( let y = 0; y < h; ++ y ) {
|
||||
|
||||
for ( let x = 0; x < w; ++ x ) {
|
||||
|
||||
const i = y * w * 4 + x * 4;
|
||||
|
||||
const r = getValue( inBuffer, i );
|
||||
const g = getValue( inBuffer, i + 1 );
|
||||
const b = getValue( inBuffer, i + 2 );
|
||||
const a = getValue( inBuffer, i + 3 );
|
||||
|
||||
const line = ( h - y - 1 ) * w * ( 3 + cOffset ) * info.dataSize;
|
||||
|
||||
decodeLinear( dec, r, g, b, a );
|
||||
|
||||
offset.value = line + x * info.dataSize;
|
||||
setValue( dv, dec.a, offset );
|
||||
|
||||
offset.value = line + ( cOffset ) * w * info.dataSize + x * info.dataSize;
|
||||
setValue( dv, dec.b, offset );
|
||||
|
||||
offset.value = line + ( 1 + cOffset ) * w * info.dataSize + x * info.dataSize;
|
||||
setValue( dv, dec.g, offset );
|
||||
|
||||
offset.value = line + ( 2 + cOffset ) * w * info.dataSize + x * info.dataSize;
|
||||
setValue( dv, dec.r, offset );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return outBuffer;
|
||||
|
||||
}
|
||||
|
||||
function compressData( inBuffer, info ) {
|
||||
|
||||
let compress,
|
||||
tmpBuffer,
|
||||
sum = 0;
|
||||
|
||||
const chunks = { data: new Array(), totalSize: 0 },
|
||||
size = info.width * info.numOutputChannels * info.blockLines * info.dataSize;
|
||||
|
||||
switch ( info.compression ) {
|
||||
|
||||
case 0:
|
||||
compress = compressNONE;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
case 3:
|
||||
compress = compressZIP;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
if ( info.compression !== 0 ) {
|
||||
|
||||
tmpBuffer = new Uint8Array( size );
|
||||
|
||||
}
|
||||
|
||||
for ( let i = 0; i < info.numBlocks; ++ i ) {
|
||||
|
||||
const arr = inBuffer.subarray( size * i, size * ( i + 1 ) );
|
||||
|
||||
const block = compress( arr, tmpBuffer );
|
||||
|
||||
sum += block.length;
|
||||
|
||||
chunks.data.push( { dataChunk: block, size: block.length } );
|
||||
|
||||
}
|
||||
|
||||
chunks.totalSize = sum;
|
||||
|
||||
return chunks;
|
||||
|
||||
}
|
||||
|
||||
function compressNONE( data ) {
|
||||
|
||||
return data;
|
||||
|
||||
}
|
||||
|
||||
function compressZIP( data, tmpBuffer ) {
|
||||
|
||||
//
|
||||
// Reorder the pixel data.
|
||||
//
|
||||
|
||||
let t1 = 0,
|
||||
t2 = Math.floor( ( data.length + 1 ) / 2 ),
|
||||
s = 0;
|
||||
|
||||
const stop = data.length - 1;
|
||||
|
||||
while ( true ) {
|
||||
|
||||
if ( s > stop ) break;
|
||||
tmpBuffer[ t1 ++ ] = data[ s ++ ];
|
||||
|
||||
if ( s > stop ) break;
|
||||
tmpBuffer[ t2 ++ ] = data[ s ++ ];
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// Predictor.
|
||||
//
|
||||
|
||||
let p = tmpBuffer[ 0 ];
|
||||
|
||||
for ( let t = 1; t < tmpBuffer.length; t ++ ) {
|
||||
|
||||
const d = tmpBuffer[ t ] - p + ( 128 + 256 );
|
||||
p = tmpBuffer[ t ];
|
||||
tmpBuffer[ t ] = d;
|
||||
|
||||
}
|
||||
|
||||
const deflate = fflate.zlibSync( tmpBuffer );
|
||||
|
||||
return deflate;
|
||||
|
||||
}
|
||||
|
||||
function fillHeader( outBuffer, chunks, info ) {
|
||||
|
||||
const offset = { value: 0 };
|
||||
const dv = new DataView( outBuffer.buffer );
|
||||
|
||||
setUint32( dv, 20000630, offset ); // magic
|
||||
setUint32( dv, 2, offset ); // mask
|
||||
|
||||
// = HEADER =
|
||||
|
||||
setString( dv, 'compression', offset );
|
||||
setString( dv, 'compression', offset );
|
||||
setUint32( dv, 1, offset );
|
||||
setUint8( dv, info.compression, offset );
|
||||
|
||||
setString( dv, 'screenWindowCenter', offset );
|
||||
setString( dv, 'v2f', offset );
|
||||
setUint32( dv, 8, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
|
||||
setString( dv, 'screenWindowWidth', offset );
|
||||
setString( dv, 'float', offset );
|
||||
setUint32( dv, 4, offset );
|
||||
setFloat32( dv, 1.0, offset );
|
||||
|
||||
setString( dv, 'pixelAspectRatio', offset );
|
||||
setString( dv, 'float', offset );
|
||||
setUint32( dv, 4, offset );
|
||||
setFloat32( dv, 1.0, offset );
|
||||
|
||||
setString( dv, 'lineOrder', offset );
|
||||
setString( dv, 'lineOrder', offset );
|
||||
setUint32( dv, 1, offset );
|
||||
setUint8( dv, 0, offset );
|
||||
|
||||
setString( dv, 'dataWindow', offset );
|
||||
setString( dv, 'box2i', offset );
|
||||
setUint32( dv, 16, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
setUint32( dv, info.width - 1, offset );
|
||||
setUint32( dv, info.height - 1, offset );
|
||||
|
||||
setString( dv, 'displayWindow', offset );
|
||||
setString( dv, 'box2i', offset );
|
||||
setUint32( dv, 16, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
setUint32( dv, 0, offset );
|
||||
setUint32( dv, info.width - 1, offset );
|
||||
setUint32( dv, info.height - 1, offset );
|
||||
|
||||
setString( dv, 'channels', offset );
|
||||
setString( dv, 'chlist', offset );
|
||||
setUint32( dv, info.numOutputChannels * 18 + 1, offset );
|
||||
|
||||
setString( dv, 'A', offset );
|
||||
setUint32( dv, info.dataType, offset );
|
||||
offset.value += 4;
|
||||
setUint32( dv, 1, offset );
|
||||
setUint32( dv, 1, offset );
|
||||
|
||||
setString( dv, 'B', offset );
|
||||
setUint32( dv, info.dataType, offset );
|
||||
offset.value += 4;
|
||||
setUint32( dv, 1, offset );
|
||||
setUint32( dv, 1, offset );
|
||||
|
||||
setString( dv, 'G', offset );
|
||||
setUint32( dv, info.dataType, offset );
|
||||
offset.value += 4;
|
||||
setUint32( dv, 1, offset );
|
||||
setUint32( dv, 1, offset );
|
||||
|
||||
setString( dv, 'R', offset );
|
||||
setUint32( dv, info.dataType, offset );
|
||||
offset.value += 4;
|
||||
setUint32( dv, 1, offset );
|
||||
setUint32( dv, 1, offset );
|
||||
|
||||
setUint8( dv, 0, offset );
|
||||
|
||||
// null-byte
|
||||
setUint8( dv, 0, offset );
|
||||
|
||||
// = OFFSET TABLE =
|
||||
|
||||
let sum = offset.value + info.numBlocks * 8;
|
||||
|
||||
for ( let i = 0; i < chunks.data.length; ++ i ) {
|
||||
|
||||
setUint64( dv, sum, offset );
|
||||
|
||||
sum += chunks.data[ i ].size + 8;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function fillData( chunks, info ) {
|
||||
|
||||
const TableSize = info.numBlocks * 8,
|
||||
HeaderSize = 259 + ( 18 * info.numOutputChannels ), // 259 + 18 * chlist
|
||||
offset = { value: HeaderSize + TableSize },
|
||||
outBuffer = new Uint8Array( HeaderSize + TableSize + chunks.totalSize + info.numBlocks * 8 ),
|
||||
dv = new DataView( outBuffer.buffer );
|
||||
|
||||
fillHeader( outBuffer, chunks, info );
|
||||
|
||||
for ( let i = 0; i < chunks.data.length; ++ i ) {
|
||||
|
||||
const data = chunks.data[ i ].dataChunk;
|
||||
const size = chunks.data[ i ].size;
|
||||
|
||||
setUint32( dv, i * info.blockLines, offset );
|
||||
setUint32( dv, size, offset );
|
||||
|
||||
outBuffer.set( data, offset.value );
|
||||
offset.value += size;
|
||||
|
||||
}
|
||||
|
||||
return outBuffer;
|
||||
|
||||
}
|
||||
|
||||
function decodeLinear( dec, r, g, b, a ) {
|
||||
|
||||
dec.r = r;
|
||||
dec.g = g;
|
||||
dec.b = b;
|
||||
dec.a = a;
|
||||
|
||||
}
|
||||
|
||||
// function decodeSRGB( dec, r, g, b, a ) {
|
||||
|
||||
// dec.r = r > 0.04045 ? Math.pow( r * 0.9478672986 + 0.0521327014, 2.4 ) : r * 0.0773993808;
|
||||
// dec.g = g > 0.04045 ? Math.pow( g * 0.9478672986 + 0.0521327014, 2.4 ) : g * 0.0773993808;
|
||||
// dec.b = b > 0.04045 ? Math.pow( b * 0.9478672986 + 0.0521327014, 2.4 ) : b * 0.0773993808;
|
||||
// dec.a = a;
|
||||
|
||||
// }
|
||||
|
||||
|
||||
function setUint8( dv, value, offset ) {
|
||||
|
||||
dv.setUint8( offset.value, value );
|
||||
|
||||
offset.value += 1;
|
||||
|
||||
}
|
||||
|
||||
function setUint32( dv, value, offset ) {
|
||||
|
||||
dv.setUint32( offset.value, value, true );
|
||||
|
||||
offset.value += 4;
|
||||
|
||||
}
|
||||
|
||||
function setFloat16( dv, value, offset ) {
|
||||
|
||||
dv.setUint16( offset.value, DataUtils.toHalfFloat( value ), true );
|
||||
|
||||
offset.value += 2;
|
||||
|
||||
}
|
||||
|
||||
function setFloat32( dv, value, offset ) {
|
||||
|
||||
dv.setFloat32( offset.value, value, true );
|
||||
|
||||
offset.value += 4;
|
||||
|
||||
}
|
||||
|
||||
function setUint64( dv, value, offset ) {
|
||||
|
||||
dv.setBigUint64( offset.value, BigInt( value ), true );
|
||||
|
||||
offset.value += 8;
|
||||
|
||||
}
|
||||
|
||||
function setString( dv, string, offset ) {
|
||||
|
||||
const tmp = textEncoder.encode( string + '\0' );
|
||||
|
||||
for ( let i = 0; i < tmp.length; ++ i ) {
|
||||
|
||||
setUint8( dv, tmp[ i ], offset );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function decodeFloat16( binary ) {
|
||||
|
||||
const exponent = ( binary & 0x7C00 ) >> 10,
|
||||
fraction = binary & 0x03FF;
|
||||
|
||||
return ( binary >> 15 ? - 1 : 1 ) * (
|
||||
exponent ?
|
||||
(
|
||||
exponent === 0x1F ?
|
||||
fraction ? NaN : Infinity :
|
||||
Math.pow( 2, exponent - 15 ) * ( 1 + fraction / 0x400 )
|
||||
) :
|
||||
6.103515625e-5 * ( fraction / 0x400 )
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
function getFloat16( arr, i ) {
|
||||
|
||||
return decodeFloat16( arr[ i ] );
|
||||
|
||||
}
|
||||
|
||||
function getFloat32( arr, i ) {
|
||||
|
||||
return arr[ i ];
|
||||
|
||||
}
|
||||
|
||||
export { EXRExporter, NO_COMPRESSION, ZIP_COMPRESSION, ZIPS_COMPRESSION };
|
||||
3380
static/sdk/three/jsm/exporters/GLTFExporter.js
Normal file
3380
static/sdk/three/jsm/exporters/GLTFExporter.js
Normal file
File diff suppressed because it is too large
Load Diff
292
static/sdk/three/jsm/exporters/KTX2Exporter.js
Normal file
292
static/sdk/three/jsm/exporters/KTX2Exporter.js
Normal file
@ -0,0 +1,292 @@
|
||||
import {
|
||||
FloatType,
|
||||
HalfFloatType,
|
||||
UnsignedByteType,
|
||||
RGBAFormat,
|
||||
RGFormat,
|
||||
RGIntegerFormat,
|
||||
RedFormat,
|
||||
RedIntegerFormat,
|
||||
NoColorSpace,
|
||||
LinearSRGBColorSpace,
|
||||
SRGBColorSpace,
|
||||
DataTexture,
|
||||
REVISION,
|
||||
} from 'three';
|
||||
|
||||
import {
|
||||
write,
|
||||
KTX2Container,
|
||||
KHR_DF_CHANNEL_RGBSDA_ALPHA,
|
||||
KHR_DF_CHANNEL_RGBSDA_BLUE,
|
||||
KHR_DF_CHANNEL_RGBSDA_GREEN,
|
||||
KHR_DF_CHANNEL_RGBSDA_RED,
|
||||
KHR_DF_MODEL_RGBSDA,
|
||||
KHR_DF_PRIMARIES_BT709,
|
||||
KHR_DF_PRIMARIES_UNSPECIFIED,
|
||||
KHR_DF_SAMPLE_DATATYPE_FLOAT,
|
||||
KHR_DF_SAMPLE_DATATYPE_LINEAR,
|
||||
KHR_DF_SAMPLE_DATATYPE_SIGNED,
|
||||
KHR_DF_TRANSFER_LINEAR,
|
||||
KHR_DF_TRANSFER_SRGB,
|
||||
VK_FORMAT_R16_SFLOAT,
|
||||
VK_FORMAT_R16G16_SFLOAT,
|
||||
VK_FORMAT_R16G16B16A16_SFLOAT,
|
||||
VK_FORMAT_R32_SFLOAT,
|
||||
VK_FORMAT_R32G32_SFLOAT,
|
||||
VK_FORMAT_R32G32B32A32_SFLOAT,
|
||||
VK_FORMAT_R8_SRGB,
|
||||
VK_FORMAT_R8_UNORM,
|
||||
VK_FORMAT_R8G8_SRGB,
|
||||
VK_FORMAT_R8G8_UNORM,
|
||||
VK_FORMAT_R8G8B8A8_SRGB,
|
||||
VK_FORMAT_R8G8B8A8_UNORM,
|
||||
} from '../libs/ktx-parse.module.js';
|
||||
|
||||
const VK_FORMAT_MAP = {
|
||||
|
||||
[ RGBAFormat ]: {
|
||||
[ FloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R32G32B32A32_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R32G32B32A32_SFLOAT,
|
||||
},
|
||||
[ HalfFloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R16G16B16A16_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R16G16B16A16_SFLOAT,
|
||||
},
|
||||
[ UnsignedByteType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R8G8B8A8_UNORM,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R8G8B8A8_UNORM,
|
||||
[ SRGBColorSpace ]: VK_FORMAT_R8G8B8A8_SRGB,
|
||||
},
|
||||
},
|
||||
|
||||
[ RGFormat ]: {
|
||||
[ FloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R32G32_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R32G32_SFLOAT,
|
||||
},
|
||||
[ HalfFloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R16G16_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R16G16_SFLOAT,
|
||||
},
|
||||
[ UnsignedByteType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R8G8_UNORM,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R8G8_UNORM,
|
||||
[ SRGBColorSpace ]: VK_FORMAT_R8G8_SRGB,
|
||||
},
|
||||
},
|
||||
|
||||
[ RedFormat ]: {
|
||||
[ FloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R32_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R32_SFLOAT,
|
||||
},
|
||||
[ HalfFloatType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R16_SFLOAT,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R16_SFLOAT,
|
||||
},
|
||||
[ UnsignedByteType ]: {
|
||||
[ NoColorSpace ]: VK_FORMAT_R8_UNORM,
|
||||
[ LinearSRGBColorSpace ]: VK_FORMAT_R8_UNORM,
|
||||
[ SRGBColorSpace ]: VK_FORMAT_R8_SRGB,
|
||||
},
|
||||
},
|
||||
|
||||
};
|
||||
|
||||
const KHR_DF_CHANNEL_MAP = {
|
||||
|
||||
0: KHR_DF_CHANNEL_RGBSDA_RED,
|
||||
1: KHR_DF_CHANNEL_RGBSDA_GREEN,
|
||||
2: KHR_DF_CHANNEL_RGBSDA_BLUE,
|
||||
3: KHR_DF_CHANNEL_RGBSDA_ALPHA,
|
||||
|
||||
};
|
||||
|
||||
const ERROR_INPUT = 'THREE.KTX2Exporter: Supported inputs are DataTexture, Data3DTexture, or WebGLRenderer and WebGLRenderTarget.';
|
||||
const ERROR_FORMAT = 'THREE.KTX2Exporter: Supported formats are RGBAFormat, RGFormat, or RedFormat.';
|
||||
const ERROR_TYPE = 'THREE.KTX2Exporter: Supported types are FloatType, HalfFloatType, or UnsignedByteType."';
|
||||
const ERROR_COLOR_SPACE = 'THREE.KTX2Exporter: Supported color spaces are SRGBColorSpace (UnsignedByteType only), LinearSRGBColorSpace, or NoColorSpace.';
|
||||
|
||||
export class KTX2Exporter {
|
||||
|
||||
parse( arg1, arg2 ) {
|
||||
|
||||
let texture;
|
||||
|
||||
if ( arg1.isDataTexture || arg1.isData3DTexture ) {
|
||||
|
||||
texture = arg1;
|
||||
|
||||
} else if ( arg1.isWebGLRenderer && arg2.isWebGLRenderTarget ) {
|
||||
|
||||
texture = toDataTexture( arg1, arg2 );
|
||||
|
||||
} else {
|
||||
|
||||
throw new Error( ERROR_INPUT );
|
||||
|
||||
}
|
||||
|
||||
if ( VK_FORMAT_MAP[ texture.format ] === undefined ) {
|
||||
|
||||
throw new Error( ERROR_FORMAT );
|
||||
|
||||
}
|
||||
|
||||
if ( VK_FORMAT_MAP[ texture.format ][ texture.type ] === undefined ) {
|
||||
|
||||
throw new Error( ERROR_TYPE );
|
||||
|
||||
}
|
||||
|
||||
if ( VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.colorSpace ] === undefined ) {
|
||||
|
||||
throw new Error( ERROR_COLOR_SPACE );
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
const array = texture.image.data;
|
||||
const channelCount = getChannelCount( texture );
|
||||
const container = new KTX2Container();
|
||||
|
||||
container.vkFormat = VK_FORMAT_MAP[ texture.format ][ texture.type ][ texture.colorSpace ];
|
||||
container.typeSize = array.BYTES_PER_ELEMENT;
|
||||
container.pixelWidth = texture.image.width;
|
||||
container.pixelHeight = texture.image.height;
|
||||
|
||||
if ( texture.isData3DTexture ) {
|
||||
|
||||
container.pixelDepth = texture.image.depth;
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
const basicDesc = container.dataFormatDescriptor[ 0 ];
|
||||
|
||||
basicDesc.colorModel = KHR_DF_MODEL_RGBSDA;
|
||||
basicDesc.colorPrimaries = texture.colorSpace === NoColorSpace
|
||||
? KHR_DF_PRIMARIES_UNSPECIFIED
|
||||
: KHR_DF_PRIMARIES_BT709;
|
||||
basicDesc.transferFunction = texture.colorSpace === SRGBColorSpace
|
||||
? KHR_DF_TRANSFER_SRGB
|
||||
: KHR_DF_TRANSFER_LINEAR;
|
||||
|
||||
basicDesc.texelBlockDimension = [ 0, 0, 0, 0 ];
|
||||
|
||||
basicDesc.bytesPlane = [
|
||||
|
||||
container.typeSize * channelCount, 0, 0, 0, 0, 0, 0, 0,
|
||||
|
||||
];
|
||||
|
||||
for ( let i = 0; i < channelCount; ++ i ) {
|
||||
|
||||
let channelType = KHR_DF_CHANNEL_MAP[ i ];
|
||||
|
||||
if ( texture.colorSpace === LinearSRGBColorSpace || texture.colorSpace === NoColorSpace ) {
|
||||
|
||||
channelType |= KHR_DF_SAMPLE_DATATYPE_LINEAR;
|
||||
|
||||
}
|
||||
|
||||
if ( texture.type === FloatType || texture.type === HalfFloatType ) {
|
||||
|
||||
channelType |= KHR_DF_SAMPLE_DATATYPE_FLOAT;
|
||||
channelType |= KHR_DF_SAMPLE_DATATYPE_SIGNED;
|
||||
|
||||
}
|
||||
|
||||
basicDesc.samples.push( {
|
||||
|
||||
channelType: channelType,
|
||||
bitOffset: i * array.BYTES_PER_ELEMENT,
|
||||
bitLength: array.BYTES_PER_ELEMENT * 8 - 1,
|
||||
samplePosition: [ 0, 0, 0, 0 ],
|
||||
sampleLower: texture.type === UnsignedByteType ? 0 : - 1,
|
||||
sampleUpper: texture.type === UnsignedByteType ? 255 : 1,
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
container.levels = [ {
|
||||
|
||||
levelData: new Uint8Array( array.buffer, array.byteOffset, array.byteLength ),
|
||||
uncompressedByteLength: array.byteLength,
|
||||
|
||||
} ];
|
||||
|
||||
//
|
||||
|
||||
container.keyValue[ 'KTXwriter' ] = `three.js ${ REVISION }`;
|
||||
|
||||
//
|
||||
|
||||
return write( container, { keepWriter: true } );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function toDataTexture( renderer, rtt ) {
|
||||
|
||||
const channelCount = getChannelCount( rtt.texture );
|
||||
|
||||
let view;
|
||||
|
||||
if ( rtt.texture.type === FloatType ) {
|
||||
|
||||
view = new Float32Array( rtt.width * rtt.height * channelCount );
|
||||
|
||||
} else if ( rtt.texture.type === HalfFloatType ) {
|
||||
|
||||
view = new Uint16Array( rtt.width * rtt.height * channelCount );
|
||||
|
||||
} else if ( rtt.texture.type === UnsignedByteType ) {
|
||||
|
||||
view = new Uint8Array( rtt.width * rtt.height * channelCount );
|
||||
|
||||
} else {
|
||||
|
||||
throw new Error( ERROR_TYPE );
|
||||
|
||||
}
|
||||
|
||||
renderer.readRenderTargetPixels( rtt, 0, 0, rtt.width, rtt.height, view );
|
||||
|
||||
return new DataTexture( view, rtt.width, rtt.height, rtt.texture.format, rtt.texture.type );
|
||||
|
||||
}
|
||||
|
||||
function getChannelCount( texture ) {
|
||||
|
||||
switch ( texture.format ) {
|
||||
|
||||
case RGBAFormat:
|
||||
|
||||
return 4;
|
||||
|
||||
case RGFormat:
|
||||
case RGIntegerFormat:
|
||||
|
||||
return 2;
|
||||
|
||||
case RedFormat:
|
||||
case RedIntegerFormat:
|
||||
|
||||
return 1;
|
||||
|
||||
default:
|
||||
|
||||
throw new Error( ERROR_FORMAT );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
217
static/sdk/three/jsm/exporters/MMDExporter.js
Normal file
217
static/sdk/three/jsm/exporters/MMDExporter.js
Normal file
@ -0,0 +1,217 @@
|
||||
import {
|
||||
Matrix4,
|
||||
Quaternion,
|
||||
Vector3
|
||||
} from 'three';
|
||||
import { MMDParser } from '../libs/mmdparser.module.js';
|
||||
|
||||
/**
|
||||
* Dependencies
|
||||
* - mmd-parser https://github.com/takahirox/mmd-parser
|
||||
*/
|
||||
|
||||
class MMDExporter {
|
||||
|
||||
/* TODO: implement
|
||||
// mesh -> pmd
|
||||
this.parsePmd = function ( object ) {
|
||||
|
||||
};
|
||||
*/
|
||||
|
||||
/* TODO: implement
|
||||
// mesh -> pmx
|
||||
this.parsePmx = function ( object ) {
|
||||
|
||||
};
|
||||
*/
|
||||
|
||||
/* TODO: implement
|
||||
// animation + skeleton -> vmd
|
||||
this.parseVmd = function ( object ) {
|
||||
|
||||
};
|
||||
*/
|
||||
|
||||
/*
|
||||
* skeleton -> vpd
|
||||
* Returns Shift_JIS encoded Uint8Array. Otherwise return strings.
|
||||
*/
|
||||
parseVpd( skin, outputShiftJis, useOriginalBones ) {
|
||||
|
||||
if ( skin.isSkinnedMesh !== true ) {
|
||||
|
||||
console.warn( 'THREE.MMDExporter: parseVpd() requires SkinnedMesh instance.' );
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
function toStringsFromNumber( num ) {
|
||||
|
||||
if ( Math.abs( num ) < 1e-6 ) num = 0;
|
||||
|
||||
let a = num.toString();
|
||||
|
||||
if ( a.indexOf( '.' ) === - 1 ) {
|
||||
|
||||
a += '.';
|
||||
|
||||
}
|
||||
|
||||
a += '000000';
|
||||
|
||||
const index = a.indexOf( '.' );
|
||||
|
||||
const d = a.slice( 0, index );
|
||||
const p = a.slice( index + 1, index + 7 );
|
||||
|
||||
return d + '.' + p;
|
||||
|
||||
}
|
||||
|
||||
function toStringsFromArray( array ) {
|
||||
|
||||
const a = [];
|
||||
|
||||
for ( let i = 0, il = array.length; i < il; i ++ ) {
|
||||
|
||||
a.push( toStringsFromNumber( array[ i ] ) );
|
||||
|
||||
}
|
||||
|
||||
return a.join( ',' );
|
||||
|
||||
}
|
||||
|
||||
skin.updateMatrixWorld( true );
|
||||
|
||||
const bones = skin.skeleton.bones;
|
||||
const bones2 = getBindBones( skin );
|
||||
|
||||
const position = new Vector3();
|
||||
const quaternion = new Quaternion();
|
||||
const quaternion2 = new Quaternion();
|
||||
const matrix = new Matrix4();
|
||||
|
||||
const array = [];
|
||||
array.push( 'Vocaloid Pose Data file' );
|
||||
array.push( '' );
|
||||
array.push( ( skin.name !== '' ? skin.name.replace( /\s/g, '_' ) : 'skin' ) + '.osm;' );
|
||||
array.push( bones.length + ';' );
|
||||
array.push( '' );
|
||||
|
||||
for ( let i = 0, il = bones.length; i < il; i ++ ) {
|
||||
|
||||
const bone = bones[ i ];
|
||||
const bone2 = bones2[ i ];
|
||||
|
||||
/*
|
||||
* use the bone matrix saved before solving IK.
|
||||
* see CCDIKSolver for the detail.
|
||||
*/
|
||||
if ( useOriginalBones === true &&
|
||||
bone.userData.ik !== undefined &&
|
||||
bone.userData.ik.originalMatrix !== undefined ) {
|
||||
|
||||
matrix.fromArray( bone.userData.ik.originalMatrix );
|
||||
|
||||
} else {
|
||||
|
||||
matrix.copy( bone.matrix );
|
||||
|
||||
}
|
||||
|
||||
position.setFromMatrixPosition( matrix );
|
||||
quaternion.setFromRotationMatrix( matrix );
|
||||
|
||||
const pArray = position.sub( bone2.position ).toArray();
|
||||
const qArray = quaternion2.copy( bone2.quaternion ).conjugate().multiply( quaternion ).toArray();
|
||||
|
||||
// right to left
|
||||
pArray[ 2 ] = - pArray[ 2 ];
|
||||
qArray[ 0 ] = - qArray[ 0 ];
|
||||
qArray[ 1 ] = - qArray[ 1 ];
|
||||
|
||||
array.push( 'Bone' + i + '{' + bone.name );
|
||||
array.push( ' ' + toStringsFromArray( pArray ) + ';' );
|
||||
array.push( ' ' + toStringsFromArray( qArray ) + ';' );
|
||||
array.push( '}' );
|
||||
array.push( '' );
|
||||
|
||||
}
|
||||
|
||||
array.push( '' );
|
||||
|
||||
const lines = array.join( '\n' );
|
||||
|
||||
return ( outputShiftJis === true ) ? unicodeToShiftjis( lines ) : lines;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Unicode to Shift_JIS table
|
||||
let u2sTable;
|
||||
|
||||
function unicodeToShiftjis( str ) {
|
||||
|
||||
if ( u2sTable === undefined ) {
|
||||
|
||||
const encoder = new MMDParser.CharsetEncoder();
|
||||
const table = encoder.s2uTable;
|
||||
u2sTable = {};
|
||||
|
||||
const keys = Object.keys( table );
|
||||
|
||||
for ( let i = 0, il = keys.length; i < il; i ++ ) {
|
||||
|
||||
let key = keys[ i ];
|
||||
|
||||
const value = table[ key ];
|
||||
key = parseInt( key );
|
||||
|
||||
u2sTable[ value ] = key;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
const array = [];
|
||||
|
||||
for ( let i = 0, il = str.length; i < il; i ++ ) {
|
||||
|
||||
const code = str.charCodeAt( i );
|
||||
|
||||
const value = u2sTable[ code ];
|
||||
|
||||
if ( value === undefined ) {
|
||||
|
||||
throw new Error( 'cannot convert charcode 0x' + code.toString( 16 ) );
|
||||
|
||||
} else if ( value > 0xff ) {
|
||||
|
||||
array.push( ( value >> 8 ) & 0xff );
|
||||
array.push( value & 0xff );
|
||||
|
||||
} else {
|
||||
|
||||
array.push( value & 0xff );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return new Uint8Array( array );
|
||||
|
||||
}
|
||||
|
||||
function getBindBones( skin ) {
|
||||
|
||||
// any more efficient ways?
|
||||
const poseSkin = skin.clone();
|
||||
poseSkin.pose();
|
||||
return poseSkin.skeleton.bones;
|
||||
|
||||
}
|
||||
|
||||
export { MMDExporter };
|
||||
284
static/sdk/three/jsm/exporters/OBJExporter.js
Normal file
284
static/sdk/three/jsm/exporters/OBJExporter.js
Normal file
@ -0,0 +1,284 @@
|
||||
import {
|
||||
Color,
|
||||
Matrix3,
|
||||
Vector2,
|
||||
Vector3
|
||||
} from 'three';
|
||||
|
||||
class OBJExporter {
|
||||
|
||||
parse( object ) {
|
||||
|
||||
let output = '';
|
||||
|
||||
let indexVertex = 0;
|
||||
let indexVertexUvs = 0;
|
||||
let indexNormals = 0;
|
||||
|
||||
const vertex = new Vector3();
|
||||
const color = new Color();
|
||||
const normal = new Vector3();
|
||||
const uv = new Vector2();
|
||||
|
||||
const face = [];
|
||||
|
||||
function parseMesh( mesh ) {
|
||||
|
||||
let nbVertex = 0;
|
||||
let nbNormals = 0;
|
||||
let nbVertexUvs = 0;
|
||||
|
||||
const geometry = mesh.geometry;
|
||||
|
||||
const normalMatrixWorld = new Matrix3();
|
||||
|
||||
// shortcuts
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
const uvs = geometry.getAttribute( 'uv' );
|
||||
const indices = geometry.getIndex();
|
||||
|
||||
// name of the mesh object
|
||||
output += 'o ' + mesh.name + '\n';
|
||||
|
||||
// name of the mesh material
|
||||
if ( mesh.material && mesh.material.name ) {
|
||||
|
||||
output += 'usemtl ' + mesh.material.name + '\n';
|
||||
|
||||
}
|
||||
|
||||
// vertices
|
||||
|
||||
if ( vertices !== undefined ) {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
|
||||
|
||||
vertex.fromBufferAttribute( vertices, i );
|
||||
|
||||
// transform the vertex to world space
|
||||
vertex.applyMatrix4( mesh.matrixWorld );
|
||||
|
||||
// transform the vertex to export format
|
||||
output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// uvs
|
||||
|
||||
if ( uvs !== undefined ) {
|
||||
|
||||
for ( let i = 0, l = uvs.count; i < l; i ++, nbVertexUvs ++ ) {
|
||||
|
||||
uv.fromBufferAttribute( uvs, i );
|
||||
|
||||
// transform the uv to export format
|
||||
output += 'vt ' + uv.x + ' ' + uv.y + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// normals
|
||||
|
||||
if ( normals !== undefined ) {
|
||||
|
||||
normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
|
||||
|
||||
for ( let i = 0, l = normals.count; i < l; i ++, nbNormals ++ ) {
|
||||
|
||||
normal.fromBufferAttribute( normals, i );
|
||||
|
||||
// transform the normal to world space
|
||||
normal.applyMatrix3( normalMatrixWorld ).normalize();
|
||||
|
||||
// transform the normal to export format
|
||||
output += 'vn ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// faces
|
||||
|
||||
if ( indices !== null ) {
|
||||
|
||||
for ( let i = 0, l = indices.count; i < l; i += 3 ) {
|
||||
|
||||
for ( let m = 0; m < 3; m ++ ) {
|
||||
|
||||
const j = indices.getX( i + m ) + 1;
|
||||
|
||||
face[ m ] = ( indexVertex + j ) + ( normals || uvs ? '/' + ( uvs ? ( indexVertexUvs + j ) : '' ) + ( normals ? '/' + ( indexNormals + j ) : '' ) : '' );
|
||||
|
||||
}
|
||||
|
||||
// transform the face to export format
|
||||
output += 'f ' + face.join( ' ' ) + '\n';
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
|
||||
|
||||
for ( let m = 0; m < 3; m ++ ) {
|
||||
|
||||
const j = i + m + 1;
|
||||
|
||||
face[ m ] = ( indexVertex + j ) + ( normals || uvs ? '/' + ( uvs ? ( indexVertexUvs + j ) : '' ) + ( normals ? '/' + ( indexNormals + j ) : '' ) : '' );
|
||||
|
||||
}
|
||||
|
||||
// transform the face to export format
|
||||
output += 'f ' + face.join( ' ' ) + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// update index
|
||||
indexVertex += nbVertex;
|
||||
indexVertexUvs += nbVertexUvs;
|
||||
indexNormals += nbNormals;
|
||||
|
||||
}
|
||||
|
||||
function parseLine( line ) {
|
||||
|
||||
let nbVertex = 0;
|
||||
|
||||
const geometry = line.geometry;
|
||||
const type = line.type;
|
||||
|
||||
// shortcuts
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
|
||||
// name of the line object
|
||||
output += 'o ' + line.name + '\n';
|
||||
|
||||
if ( vertices !== undefined ) {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
|
||||
|
||||
vertex.fromBufferAttribute( vertices, i );
|
||||
|
||||
// transform the vertex to world space
|
||||
vertex.applyMatrix4( line.matrixWorld );
|
||||
|
||||
// transform the vertex to export format
|
||||
output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( type === 'Line' ) {
|
||||
|
||||
output += 'l ';
|
||||
|
||||
for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
|
||||
|
||||
output += ( indexVertex + j ) + ' ';
|
||||
|
||||
}
|
||||
|
||||
output += '\n';
|
||||
|
||||
}
|
||||
|
||||
if ( type === 'LineSegments' ) {
|
||||
|
||||
for ( let j = 1, k = j + 1, l = vertices.count; j < l; j += 2, k = j + 1 ) {
|
||||
|
||||
output += 'l ' + ( indexVertex + j ) + ' ' + ( indexVertex + k ) + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// update index
|
||||
indexVertex += nbVertex;
|
||||
|
||||
}
|
||||
|
||||
function parsePoints( points ) {
|
||||
|
||||
let nbVertex = 0;
|
||||
|
||||
const geometry = points.geometry;
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
|
||||
output += 'o ' + points.name + '\n';
|
||||
|
||||
if ( vertices !== undefined ) {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i ++, nbVertex ++ ) {
|
||||
|
||||
vertex.fromBufferAttribute( vertices, i );
|
||||
vertex.applyMatrix4( points.matrixWorld );
|
||||
|
||||
output += 'v ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z;
|
||||
|
||||
if ( colors !== undefined ) {
|
||||
|
||||
color.fromBufferAttribute( colors, i ).convertLinearToSRGB();
|
||||
|
||||
output += ' ' + color.r + ' ' + color.g + ' ' + color.b;
|
||||
|
||||
}
|
||||
|
||||
output += '\n';
|
||||
|
||||
}
|
||||
|
||||
output += 'p ';
|
||||
|
||||
for ( let j = 1, l = vertices.count; j <= l; j ++ ) {
|
||||
|
||||
output += ( indexVertex + j ) + ' ';
|
||||
|
||||
}
|
||||
|
||||
output += '\n';
|
||||
|
||||
}
|
||||
|
||||
// update index
|
||||
indexVertex += nbVertex;
|
||||
|
||||
}
|
||||
|
||||
object.traverse( function ( child ) {
|
||||
|
||||
if ( child.isMesh === true ) {
|
||||
|
||||
parseMesh( child );
|
||||
|
||||
}
|
||||
|
||||
if ( child.isLine === true ) {
|
||||
|
||||
parseLine( child );
|
||||
|
||||
}
|
||||
|
||||
if ( child.isPoints === true ) {
|
||||
|
||||
parsePoints( child );
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
return output;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export { OBJExporter };
|
||||
528
static/sdk/three/jsm/exporters/PLYExporter.js
Normal file
528
static/sdk/three/jsm/exporters/PLYExporter.js
Normal file
@ -0,0 +1,528 @@
|
||||
import {
|
||||
Matrix3,
|
||||
Vector3,
|
||||
Color
|
||||
} from 'three';
|
||||
|
||||
/**
|
||||
* https://github.com/gkjohnson/ply-exporter-js
|
||||
*
|
||||
* Usage:
|
||||
* const exporter = new PLYExporter();
|
||||
*
|
||||
* // second argument is a list of options
|
||||
* exporter.parse(mesh, data => console.log(data), { binary: true, excludeAttributes: [ 'color' ], littleEndian: true });
|
||||
*
|
||||
* Format Definition:
|
||||
* http://paulbourke.net/dataformats/ply/
|
||||
*/
|
||||
|
||||
class PLYExporter {
|
||||
|
||||
parse( object, onDone, options = {} ) {
|
||||
|
||||
// Iterate over the valid meshes in the object
|
||||
function traverseMeshes( cb ) {
|
||||
|
||||
object.traverse( function ( child ) {
|
||||
|
||||
if ( child.isMesh === true || child.isPoints ) {
|
||||
|
||||
const mesh = child;
|
||||
const geometry = mesh.geometry;
|
||||
|
||||
if ( geometry.hasAttribute( 'position' ) === true ) {
|
||||
|
||||
cb( mesh, geometry );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
|
||||
// Default options
|
||||
const defaultOptions = {
|
||||
binary: false,
|
||||
excludeAttributes: [], // normal, uv, color, index
|
||||
littleEndian: false
|
||||
};
|
||||
|
||||
options = Object.assign( defaultOptions, options );
|
||||
|
||||
const excludeAttributes = options.excludeAttributes;
|
||||
let includeIndices = true;
|
||||
let includeNormals = false;
|
||||
let includeColors = false;
|
||||
let includeUVs = false;
|
||||
|
||||
// count the vertices, check which properties are used,
|
||||
// and cache the BufferGeometry
|
||||
let vertexCount = 0;
|
||||
let faceCount = 0;
|
||||
|
||||
object.traverse( function ( child ) {
|
||||
|
||||
if ( child.isMesh === true ) {
|
||||
|
||||
const mesh = child;
|
||||
const geometry = mesh.geometry;
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
const uvs = geometry.getAttribute( 'uv' );
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
const indices = geometry.getIndex();
|
||||
|
||||
if ( vertices === undefined ) {
|
||||
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
vertexCount += vertices.count;
|
||||
faceCount += indices ? indices.count / 3 : vertices.count / 3;
|
||||
|
||||
if ( normals !== undefined ) includeNormals = true;
|
||||
|
||||
if ( uvs !== undefined ) includeUVs = true;
|
||||
|
||||
if ( colors !== undefined ) includeColors = true;
|
||||
|
||||
} else if ( child.isPoints ) {
|
||||
|
||||
const mesh = child;
|
||||
const geometry = mesh.geometry;
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
|
||||
vertexCount += vertices.count;
|
||||
|
||||
if ( normals !== undefined ) includeNormals = true;
|
||||
|
||||
if ( colors !== undefined ) includeColors = true;
|
||||
|
||||
includeIndices = false;
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
const tempColor = new Color();
|
||||
includeIndices = includeIndices && excludeAttributes.indexOf( 'index' ) === - 1;
|
||||
includeNormals = includeNormals && excludeAttributes.indexOf( 'normal' ) === - 1;
|
||||
includeColors = includeColors && excludeAttributes.indexOf( 'color' ) === - 1;
|
||||
includeUVs = includeUVs && excludeAttributes.indexOf( 'uv' ) === - 1;
|
||||
|
||||
|
||||
if ( includeIndices && faceCount !== Math.floor( faceCount ) ) {
|
||||
|
||||
// point cloud meshes will not have an index array and may not have a
|
||||
// number of vertices that is divisble by 3 (and therefore representable
|
||||
// as triangles)
|
||||
console.error(
|
||||
|
||||
'PLYExporter: Failed to generate a valid PLY file with triangle indices because the ' +
|
||||
'number of indices is not divisible by 3.'
|
||||
|
||||
);
|
||||
|
||||
return null;
|
||||
|
||||
}
|
||||
|
||||
const indexByteCount = 4;
|
||||
|
||||
let header =
|
||||
'ply\n' +
|
||||
`format ${ options.binary ? ( options.littleEndian ? 'binary_little_endian' : 'binary_big_endian' ) : 'ascii' } 1.0\n` +
|
||||
`element vertex ${vertexCount}\n` +
|
||||
|
||||
// position
|
||||
'property float x\n' +
|
||||
'property float y\n' +
|
||||
'property float z\n';
|
||||
|
||||
if ( includeNormals === true ) {
|
||||
|
||||
// normal
|
||||
header +=
|
||||
'property float nx\n' +
|
||||
'property float ny\n' +
|
||||
'property float nz\n';
|
||||
|
||||
}
|
||||
|
||||
if ( includeUVs === true ) {
|
||||
|
||||
// uvs
|
||||
header +=
|
||||
'property float s\n' +
|
||||
'property float t\n';
|
||||
|
||||
}
|
||||
|
||||
if ( includeColors === true ) {
|
||||
|
||||
// colors
|
||||
header +=
|
||||
'property uchar red\n' +
|
||||
'property uchar green\n' +
|
||||
'property uchar blue\n';
|
||||
|
||||
}
|
||||
|
||||
if ( includeIndices === true ) {
|
||||
|
||||
// faces
|
||||
header +=
|
||||
`element face ${faceCount}\n` +
|
||||
'property list uchar int vertex_index\n';
|
||||
|
||||
}
|
||||
|
||||
header += 'end_header\n';
|
||||
|
||||
|
||||
// Generate attribute data
|
||||
const vertex = new Vector3();
|
||||
const normalMatrixWorld = new Matrix3();
|
||||
let result = null;
|
||||
|
||||
if ( options.binary === true ) {
|
||||
|
||||
// Binary File Generation
|
||||
const headerBin = new TextEncoder().encode( header );
|
||||
|
||||
// 3 position values at 4 bytes
|
||||
// 3 normal values at 4 bytes
|
||||
// 3 color channels with 1 byte
|
||||
// 2 uv values at 4 bytes
|
||||
const vertexListLength = vertexCount * ( 4 * 3 + ( includeNormals ? 4 * 3 : 0 ) + ( includeColors ? 3 : 0 ) + ( includeUVs ? 4 * 2 : 0 ) );
|
||||
|
||||
// 1 byte shape desciptor
|
||||
// 3 vertex indices at ${indexByteCount} bytes
|
||||
const faceListLength = includeIndices ? faceCount * ( indexByteCount * 3 + 1 ) : 0;
|
||||
const output = new DataView( new ArrayBuffer( headerBin.length + vertexListLength + faceListLength ) );
|
||||
new Uint8Array( output.buffer ).set( headerBin, 0 );
|
||||
|
||||
|
||||
let vOffset = headerBin.length;
|
||||
let fOffset = headerBin.length + vertexListLength;
|
||||
let writtenVertices = 0;
|
||||
traverseMeshes( function ( mesh, geometry ) {
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
const uvs = geometry.getAttribute( 'uv' );
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
const indices = geometry.getIndex();
|
||||
|
||||
normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i ++ ) {
|
||||
|
||||
vertex.fromBufferAttribute( vertices, i );
|
||||
|
||||
vertex.applyMatrix4( mesh.matrixWorld );
|
||||
|
||||
|
||||
// Position information
|
||||
output.setFloat32( vOffset, vertex.x, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, vertex.y, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, vertex.z, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
// Normal information
|
||||
if ( includeNormals === true ) {
|
||||
|
||||
if ( normals != null ) {
|
||||
|
||||
vertex.fromBufferAttribute( normals, i );
|
||||
|
||||
vertex.applyMatrix3( normalMatrixWorld ).normalize();
|
||||
|
||||
output.setFloat32( vOffset, vertex.x, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, vertex.y, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, vertex.z, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
} else {
|
||||
|
||||
output.setFloat32( vOffset, 0, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, 0, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, 0, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// UV information
|
||||
if ( includeUVs === true ) {
|
||||
|
||||
if ( uvs != null ) {
|
||||
|
||||
output.setFloat32( vOffset, uvs.getX( i ), options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, uvs.getY( i ), options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
} else {
|
||||
|
||||
output.setFloat32( vOffset, 0, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
output.setFloat32( vOffset, 0, options.littleEndian );
|
||||
vOffset += 4;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Color information
|
||||
if ( includeColors === true ) {
|
||||
|
||||
if ( colors != null ) {
|
||||
|
||||
tempColor
|
||||
.fromBufferAttribute( colors, i )
|
||||
.convertLinearToSRGB();
|
||||
|
||||
output.setUint8( vOffset, Math.floor( tempColor.r * 255 ) );
|
||||
vOffset += 1;
|
||||
|
||||
output.setUint8( vOffset, Math.floor( tempColor.g * 255 ) );
|
||||
vOffset += 1;
|
||||
|
||||
output.setUint8( vOffset, Math.floor( tempColor.b * 255 ) );
|
||||
vOffset += 1;
|
||||
|
||||
} else {
|
||||
|
||||
output.setUint8( vOffset, 255 );
|
||||
vOffset += 1;
|
||||
|
||||
output.setUint8( vOffset, 255 );
|
||||
vOffset += 1;
|
||||
|
||||
output.setUint8( vOffset, 255 );
|
||||
vOffset += 1;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( includeIndices === true ) {
|
||||
|
||||
// Create the face list
|
||||
|
||||
if ( indices !== null ) {
|
||||
|
||||
for ( let i = 0, l = indices.count; i < l; i += 3 ) {
|
||||
|
||||
output.setUint8( fOffset, 3 );
|
||||
fOffset += 1;
|
||||
|
||||
output.setUint32( fOffset, indices.getX( i + 0 ) + writtenVertices, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
output.setUint32( fOffset, indices.getX( i + 1 ) + writtenVertices, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
output.setUint32( fOffset, indices.getX( i + 2 ) + writtenVertices, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
|
||||
|
||||
output.setUint8( fOffset, 3 );
|
||||
fOffset += 1;
|
||||
|
||||
output.setUint32( fOffset, writtenVertices + i, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
output.setUint32( fOffset, writtenVertices + i + 1, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
output.setUint32( fOffset, writtenVertices + i + 2, options.littleEndian );
|
||||
fOffset += indexByteCount;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
// Save the amount of verts we've already written so we can offset
|
||||
// the face index on the next mesh
|
||||
writtenVertices += vertices.count;
|
||||
|
||||
} );
|
||||
|
||||
result = output.buffer;
|
||||
|
||||
} else {
|
||||
|
||||
// Ascii File Generation
|
||||
// count the number of vertices
|
||||
let writtenVertices = 0;
|
||||
let vertexList = '';
|
||||
let faceList = '';
|
||||
|
||||
traverseMeshes( function ( mesh, geometry ) {
|
||||
|
||||
const vertices = geometry.getAttribute( 'position' );
|
||||
const normals = geometry.getAttribute( 'normal' );
|
||||
const uvs = geometry.getAttribute( 'uv' );
|
||||
const colors = geometry.getAttribute( 'color' );
|
||||
const indices = geometry.getIndex();
|
||||
|
||||
normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
|
||||
|
||||
// form each line
|
||||
for ( let i = 0, l = vertices.count; i < l; i ++ ) {
|
||||
|
||||
vertex.fromBufferAttribute( vertices, i );
|
||||
|
||||
vertex.applyMatrix4( mesh.matrixWorld );
|
||||
|
||||
|
||||
// Position information
|
||||
let line =
|
||||
vertex.x + ' ' +
|
||||
vertex.y + ' ' +
|
||||
vertex.z;
|
||||
|
||||
// Normal information
|
||||
if ( includeNormals === true ) {
|
||||
|
||||
if ( normals != null ) {
|
||||
|
||||
vertex.fromBufferAttribute( normals, i );
|
||||
|
||||
vertex.applyMatrix3( normalMatrixWorld ).normalize();
|
||||
|
||||
line += ' ' +
|
||||
vertex.x + ' ' +
|
||||
vertex.y + ' ' +
|
||||
vertex.z;
|
||||
|
||||
} else {
|
||||
|
||||
line += ' 0 0 0';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// UV information
|
||||
if ( includeUVs === true ) {
|
||||
|
||||
if ( uvs != null ) {
|
||||
|
||||
line += ' ' +
|
||||
uvs.getX( i ) + ' ' +
|
||||
uvs.getY( i );
|
||||
|
||||
} else {
|
||||
|
||||
line += ' 0 0';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Color information
|
||||
if ( includeColors === true ) {
|
||||
|
||||
if ( colors != null ) {
|
||||
|
||||
tempColor
|
||||
.fromBufferAttribute( colors, i )
|
||||
.convertLinearToSRGB();
|
||||
|
||||
line += ' ' +
|
||||
Math.floor( tempColor.r * 255 ) + ' ' +
|
||||
Math.floor( tempColor.g * 255 ) + ' ' +
|
||||
Math.floor( tempColor.b * 255 );
|
||||
|
||||
} else {
|
||||
|
||||
line += ' 255 255 255';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
vertexList += line + '\n';
|
||||
|
||||
}
|
||||
|
||||
// Create the face list
|
||||
if ( includeIndices === true ) {
|
||||
|
||||
if ( indices !== null ) {
|
||||
|
||||
for ( let i = 0, l = indices.count; i < l; i += 3 ) {
|
||||
|
||||
faceList += `3 ${ indices.getX( i + 0 ) + writtenVertices }`;
|
||||
faceList += ` ${ indices.getX( i + 1 ) + writtenVertices }`;
|
||||
faceList += ` ${ indices.getX( i + 2 ) + writtenVertices }\n`;
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
|
||||
|
||||
faceList += `3 ${ writtenVertices + i } ${ writtenVertices + i + 1 } ${ writtenVertices + i + 2 }\n`;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
faceCount += indices ? indices.count / 3 : vertices.count / 3;
|
||||
|
||||
}
|
||||
|
||||
writtenVertices += vertices.count;
|
||||
|
||||
} );
|
||||
|
||||
result = `${ header }${vertexList}${ includeIndices ? `${faceList}\n` : '\n' }`;
|
||||
|
||||
}
|
||||
|
||||
if ( typeof onDone === 'function' ) requestAnimationFrame( () => onDone( result ) );
|
||||
|
||||
return result;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export { PLYExporter };
|
||||
199
static/sdk/three/jsm/exporters/STLExporter.js
Normal file
199
static/sdk/three/jsm/exporters/STLExporter.js
Normal file
@ -0,0 +1,199 @@
|
||||
import { Vector3 } from 'three';
|
||||
|
||||
/**
|
||||
* Usage:
|
||||
* const exporter = new STLExporter();
|
||||
*
|
||||
* // second argument is a list of options
|
||||
* const data = exporter.parse( mesh, { binary: true } );
|
||||
*
|
||||
*/
|
||||
|
||||
class STLExporter {
|
||||
|
||||
parse( scene, options = {} ) {
|
||||
|
||||
options = Object.assign( {
|
||||
binary: false
|
||||
}, options );
|
||||
|
||||
const binary = options.binary;
|
||||
|
||||
//
|
||||
|
||||
const objects = [];
|
||||
let triangles = 0;
|
||||
|
||||
scene.traverse( function ( object ) {
|
||||
|
||||
if ( object.isMesh ) {
|
||||
|
||||
const geometry = object.geometry;
|
||||
|
||||
const index = geometry.index;
|
||||
const positionAttribute = geometry.getAttribute( 'position' );
|
||||
|
||||
triangles += ( index !== null ) ? ( index.count / 3 ) : ( positionAttribute.count / 3 );
|
||||
|
||||
objects.push( {
|
||||
object3d: object,
|
||||
geometry: geometry
|
||||
} );
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
let output;
|
||||
let offset = 80; // skip header
|
||||
|
||||
if ( binary === true ) {
|
||||
|
||||
const bufferLength = triangles * 2 + triangles * 3 * 4 * 4 + 80 + 4;
|
||||
const arrayBuffer = new ArrayBuffer( bufferLength );
|
||||
output = new DataView( arrayBuffer );
|
||||
output.setUint32( offset, triangles, true ); offset += 4;
|
||||
|
||||
} else {
|
||||
|
||||
output = '';
|
||||
output += 'solid exported\n';
|
||||
|
||||
}
|
||||
|
||||
const vA = new Vector3();
|
||||
const vB = new Vector3();
|
||||
const vC = new Vector3();
|
||||
const cb = new Vector3();
|
||||
const ab = new Vector3();
|
||||
const normal = new Vector3();
|
||||
|
||||
for ( let i = 0, il = objects.length; i < il; i ++ ) {
|
||||
|
||||
const object = objects[ i ].object3d;
|
||||
const geometry = objects[ i ].geometry;
|
||||
|
||||
const index = geometry.index;
|
||||
const positionAttribute = geometry.getAttribute( 'position' );
|
||||
|
||||
if ( index !== null ) {
|
||||
|
||||
// indexed geometry
|
||||
|
||||
for ( let j = 0; j < index.count; j += 3 ) {
|
||||
|
||||
const a = index.getX( j + 0 );
|
||||
const b = index.getX( j + 1 );
|
||||
const c = index.getX( j + 2 );
|
||||
|
||||
writeFace( a, b, c, positionAttribute, object );
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
// non-indexed geometry
|
||||
|
||||
for ( let j = 0; j < positionAttribute.count; j += 3 ) {
|
||||
|
||||
const a = j + 0;
|
||||
const b = j + 1;
|
||||
const c = j + 2;
|
||||
|
||||
writeFace( a, b, c, positionAttribute, object );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if ( binary === false ) {
|
||||
|
||||
output += 'endsolid exported\n';
|
||||
|
||||
}
|
||||
|
||||
return output;
|
||||
|
||||
function writeFace( a, b, c, positionAttribute, object ) {
|
||||
|
||||
vA.fromBufferAttribute( positionAttribute, a );
|
||||
vB.fromBufferAttribute( positionAttribute, b );
|
||||
vC.fromBufferAttribute( positionAttribute, c );
|
||||
|
||||
if ( object.isSkinnedMesh === true ) {
|
||||
|
||||
object.applyBoneTransform( a, vA );
|
||||
object.applyBoneTransform( b, vB );
|
||||
object.applyBoneTransform( c, vC );
|
||||
|
||||
}
|
||||
|
||||
vA.applyMatrix4( object.matrixWorld );
|
||||
vB.applyMatrix4( object.matrixWorld );
|
||||
vC.applyMatrix4( object.matrixWorld );
|
||||
|
||||
writeNormal( vA, vB, vC );
|
||||
|
||||
writeVertex( vA );
|
||||
writeVertex( vB );
|
||||
writeVertex( vC );
|
||||
|
||||
if ( binary === true ) {
|
||||
|
||||
output.setUint16( offset, 0, true ); offset += 2;
|
||||
|
||||
} else {
|
||||
|
||||
output += '\t\tendloop\n';
|
||||
output += '\tendfacet\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function writeNormal( vA, vB, vC ) {
|
||||
|
||||
cb.subVectors( vC, vB );
|
||||
ab.subVectors( vA, vB );
|
||||
cb.cross( ab ).normalize();
|
||||
|
||||
normal.copy( cb ).normalize();
|
||||
|
||||
if ( binary === true ) {
|
||||
|
||||
output.setFloat32( offset, normal.x, true ); offset += 4;
|
||||
output.setFloat32( offset, normal.y, true ); offset += 4;
|
||||
output.setFloat32( offset, normal.z, true ); offset += 4;
|
||||
|
||||
} else {
|
||||
|
||||
output += '\tfacet normal ' + normal.x + ' ' + normal.y + ' ' + normal.z + '\n';
|
||||
output += '\t\touter loop\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function writeVertex( vertex ) {
|
||||
|
||||
if ( binary === true ) {
|
||||
|
||||
output.setFloat32( offset, vertex.x, true ); offset += 4;
|
||||
output.setFloat32( offset, vertex.y, true ); offset += 4;
|
||||
output.setFloat32( offset, vertex.z, true ); offset += 4;
|
||||
|
||||
} else {
|
||||
|
||||
output += '\t\t\tvertex ' + vertex.x + ' ' + vertex.y + ' ' + vertex.z + '\n';
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export { STLExporter };
|
||||
741
static/sdk/three/jsm/exporters/USDZExporter.js
Normal file
741
static/sdk/three/jsm/exporters/USDZExporter.js
Normal file
@ -0,0 +1,741 @@
|
||||
import {
|
||||
NoColorSpace,
|
||||
DoubleSide,
|
||||
} from 'three';
|
||||
|
||||
import {
|
||||
strToU8,
|
||||
zipSync,
|
||||
} from '../libs/fflate.module.js';
|
||||
|
||||
import { decompress } from './../utils/TextureUtils.js';
|
||||
|
||||
class USDZExporter {
|
||||
|
||||
parse( scene, onDone, onError, options ) {
|
||||
|
||||
this.parseAsync( scene, options ).then( onDone ).catch( onError );
|
||||
|
||||
}
|
||||
|
||||
async parseAsync( scene, options = {} ) {
|
||||
|
||||
options = Object.assign( {
|
||||
ar: {
|
||||
anchoring: { type: 'plane' },
|
||||
planeAnchoring: { alignment: 'horizontal' }
|
||||
},
|
||||
quickLookCompatible: false,
|
||||
maxTextureSize: 1024,
|
||||
}, options );
|
||||
|
||||
const files = {};
|
||||
const modelFileName = 'model.usda';
|
||||
|
||||
// model file should be first in USDZ archive so we init it here
|
||||
files[ modelFileName ] = null;
|
||||
|
||||
let output = buildHeader();
|
||||
|
||||
output += buildSceneStart( options );
|
||||
|
||||
const materials = {};
|
||||
const textures = {};
|
||||
|
||||
scene.traverseVisible( ( object ) => {
|
||||
|
||||
if ( object.isMesh ) {
|
||||
|
||||
const geometry = object.geometry;
|
||||
const material = object.material;
|
||||
|
||||
if ( material.isMeshStandardMaterial ) {
|
||||
|
||||
const geometryFileName = 'geometries/Geometry_' + geometry.id + '.usda';
|
||||
|
||||
if ( ! ( geometryFileName in files ) ) {
|
||||
|
||||
const meshObject = buildMeshObject( geometry );
|
||||
files[ geometryFileName ] = buildUSDFileAsString( meshObject );
|
||||
|
||||
}
|
||||
|
||||
if ( ! ( material.uuid in materials ) ) {
|
||||
|
||||
materials[ material.uuid ] = material;
|
||||
|
||||
}
|
||||
|
||||
output += buildXform( object, geometry, material );
|
||||
|
||||
} else {
|
||||
|
||||
console.warn( 'THREE.USDZExporter: Unsupported material type (USDZ only supports MeshStandardMaterial)', object );
|
||||
|
||||
}
|
||||
|
||||
} else if ( object.isCamera ) {
|
||||
|
||||
output += buildCamera( object );
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
|
||||
output += buildSceneEnd();
|
||||
|
||||
output += buildMaterials( materials, textures, options.quickLookCompatible );
|
||||
|
||||
files[ modelFileName ] = strToU8( output );
|
||||
output = null;
|
||||
|
||||
for ( const id in textures ) {
|
||||
|
||||
let texture = textures[ id ];
|
||||
|
||||
if ( texture.isCompressedTexture === true ) {
|
||||
|
||||
texture = decompress( texture );
|
||||
|
||||
}
|
||||
|
||||
const canvas = imageToCanvas( texture.image, texture.flipY, options.maxTextureSize );
|
||||
const blob = await new Promise( resolve => canvas.toBlob( resolve, 'image/png', 1 ) );
|
||||
|
||||
files[ `textures/Texture_${ id }.png` ] = new Uint8Array( await blob.arrayBuffer() );
|
||||
|
||||
}
|
||||
|
||||
// 64 byte alignment
|
||||
// https://github.com/101arrowz/fflate/issues/39#issuecomment-777263109
|
||||
|
||||
let offset = 0;
|
||||
|
||||
for ( const filename in files ) {
|
||||
|
||||
const file = files[ filename ];
|
||||
const headerSize = 34 + filename.length;
|
||||
|
||||
offset += headerSize;
|
||||
|
||||
const offsetMod64 = offset & 63;
|
||||
|
||||
if ( offsetMod64 !== 4 ) {
|
||||
|
||||
const padLength = 64 - offsetMod64;
|
||||
const padding = new Uint8Array( padLength );
|
||||
|
||||
files[ filename ] = [ file, { extra: { 12345: padding } } ];
|
||||
|
||||
}
|
||||
|
||||
offset = file.length;
|
||||
|
||||
}
|
||||
|
||||
return zipSync( files, { level: 0 } );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
function imageToCanvas( image, flipY, maxTextureSize ) {
|
||||
|
||||
if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
|
||||
( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
|
||||
( typeof OffscreenCanvas !== 'undefined' && image instanceof OffscreenCanvas ) ||
|
||||
( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
|
||||
|
||||
const scale = maxTextureSize / Math.max( image.width, image.height );
|
||||
|
||||
const canvas = document.createElement( 'canvas' );
|
||||
canvas.width = image.width * Math.min( 1, scale );
|
||||
canvas.height = image.height * Math.min( 1, scale );
|
||||
|
||||
const context = canvas.getContext( '2d' );
|
||||
|
||||
// TODO: We should be able to do this in the UsdTransform2d?
|
||||
|
||||
if ( flipY === true ) {
|
||||
|
||||
context.translate( 0, canvas.height );
|
||||
context.scale( 1, - 1 );
|
||||
|
||||
}
|
||||
|
||||
context.drawImage( image, 0, 0, canvas.width, canvas.height );
|
||||
|
||||
return canvas;
|
||||
|
||||
} else {
|
||||
|
||||
throw new Error( 'THREE.USDZExporter: No valid image data found. Unable to process texture.' );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
const PRECISION = 7;
|
||||
|
||||
function buildHeader() {
|
||||
|
||||
return `#usda 1.0
|
||||
(
|
||||
customLayerData = {
|
||||
string creator = "Three.js USDZExporter"
|
||||
}
|
||||
defaultPrim = "Root"
|
||||
metersPerUnit = 1
|
||||
upAxis = "Y"
|
||||
)
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildSceneStart( options ) {
|
||||
|
||||
return `def Xform "Root"
|
||||
{
|
||||
def Scope "Scenes" (
|
||||
kind = "sceneLibrary"
|
||||
)
|
||||
{
|
||||
def Xform "Scene" (
|
||||
customData = {
|
||||
bool preliminary_collidesWithEnvironment = 0
|
||||
string sceneName = "Scene"
|
||||
}
|
||||
sceneName = "Scene"
|
||||
)
|
||||
{
|
||||
token preliminary:anchoring:type = "${options.ar.anchoring.type}"
|
||||
token preliminary:planeAnchoring:alignment = "${options.ar.planeAnchoring.alignment}"
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildSceneEnd() {
|
||||
|
||||
return `
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildUSDFileAsString( dataToInsert ) {
|
||||
|
||||
let output = buildHeader();
|
||||
output += dataToInsert;
|
||||
return strToU8( output );
|
||||
|
||||
}
|
||||
|
||||
// Xform
|
||||
|
||||
function buildXform( object, geometry, material ) {
|
||||
|
||||
const name = 'Object_' + object.id;
|
||||
const transform = buildMatrix( object.matrixWorld );
|
||||
|
||||
if ( object.matrixWorld.determinant() < 0 ) {
|
||||
|
||||
console.warn( 'THREE.USDZExporter: USDZ does not support negative scales', object );
|
||||
|
||||
}
|
||||
|
||||
return `def Xform "${ name }" (
|
||||
prepend references = @./geometries/Geometry_${ geometry.id }.usda@</Geometry>
|
||||
prepend apiSchemas = ["MaterialBindingAPI"]
|
||||
)
|
||||
{
|
||||
matrix4d xformOp:transform = ${ transform }
|
||||
uniform token[] xformOpOrder = ["xformOp:transform"]
|
||||
|
||||
rel material:binding = </Materials/Material_${ material.id }>
|
||||
}
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildMatrix( matrix ) {
|
||||
|
||||
const array = matrix.elements;
|
||||
|
||||
return `( ${ buildMatrixRow( array, 0 ) }, ${ buildMatrixRow( array, 4 ) }, ${ buildMatrixRow( array, 8 ) }, ${ buildMatrixRow( array, 12 ) } )`;
|
||||
|
||||
}
|
||||
|
||||
function buildMatrixRow( array, offset ) {
|
||||
|
||||
return `(${ array[ offset + 0 ] }, ${ array[ offset + 1 ] }, ${ array[ offset + 2 ] }, ${ array[ offset + 3 ] })`;
|
||||
|
||||
}
|
||||
|
||||
// Mesh
|
||||
|
||||
function buildMeshObject( geometry ) {
|
||||
|
||||
const mesh = buildMesh( geometry );
|
||||
return `
|
||||
def "Geometry"
|
||||
{
|
||||
${mesh}
|
||||
}
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildMesh( geometry ) {
|
||||
|
||||
const name = 'Geometry';
|
||||
const attributes = geometry.attributes;
|
||||
const count = attributes.position.count;
|
||||
|
||||
return `
|
||||
def Mesh "${ name }"
|
||||
{
|
||||
int[] faceVertexCounts = [${ buildMeshVertexCount( geometry ) }]
|
||||
int[] faceVertexIndices = [${ buildMeshVertexIndices( geometry ) }]
|
||||
normal3f[] normals = [${ buildVector3Array( attributes.normal, count )}] (
|
||||
interpolation = "vertex"
|
||||
)
|
||||
point3f[] points = [${ buildVector3Array( attributes.position, count )}]
|
||||
${ buildPrimvars( attributes ) }
|
||||
uniform token subdivisionScheme = "none"
|
||||
}
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildMeshVertexCount( geometry ) {
|
||||
|
||||
const count = geometry.index !== null ? geometry.index.count : geometry.attributes.position.count;
|
||||
|
||||
return Array( count / 3 ).fill( 3 ).join( ', ' );
|
||||
|
||||
}
|
||||
|
||||
function buildMeshVertexIndices( geometry ) {
|
||||
|
||||
const index = geometry.index;
|
||||
const array = [];
|
||||
|
||||
if ( index !== null ) {
|
||||
|
||||
for ( let i = 0; i < index.count; i ++ ) {
|
||||
|
||||
array.push( index.getX( i ) );
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
const length = geometry.attributes.position.count;
|
||||
|
||||
for ( let i = 0; i < length; i ++ ) {
|
||||
|
||||
array.push( i );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return array.join( ', ' );
|
||||
|
||||
}
|
||||
|
||||
function buildVector3Array( attribute, count ) {
|
||||
|
||||
if ( attribute === undefined ) {
|
||||
|
||||
console.warn( 'USDZExporter: Normals missing.' );
|
||||
return Array( count ).fill( '(0, 0, 0)' ).join( ', ' );
|
||||
|
||||
}
|
||||
|
||||
const array = [];
|
||||
|
||||
for ( let i = 0; i < attribute.count; i ++ ) {
|
||||
|
||||
const x = attribute.getX( i );
|
||||
const y = attribute.getY( i );
|
||||
const z = attribute.getZ( i );
|
||||
|
||||
array.push( `(${ x.toPrecision( PRECISION ) }, ${ y.toPrecision( PRECISION ) }, ${ z.toPrecision( PRECISION ) })` );
|
||||
|
||||
}
|
||||
|
||||
return array.join( ', ' );
|
||||
|
||||
}
|
||||
|
||||
function buildVector2Array( attribute ) {
|
||||
|
||||
const array = [];
|
||||
|
||||
for ( let i = 0; i < attribute.count; i ++ ) {
|
||||
|
||||
const x = attribute.getX( i );
|
||||
const y = attribute.getY( i );
|
||||
|
||||
array.push( `(${ x.toPrecision( PRECISION ) }, ${ 1 - y.toPrecision( PRECISION ) })` );
|
||||
|
||||
}
|
||||
|
||||
return array.join( ', ' );
|
||||
|
||||
}
|
||||
|
||||
function buildPrimvars( attributes ) {
|
||||
|
||||
let string = '';
|
||||
|
||||
for ( let i = 0; i < 4; i ++ ) {
|
||||
|
||||
const id = ( i > 0 ? i : '' );
|
||||
const attribute = attributes[ 'uv' + id ];
|
||||
|
||||
if ( attribute !== undefined ) {
|
||||
|
||||
string += `
|
||||
texCoord2f[] primvars:st${ id } = [${ buildVector2Array( attribute )}] (
|
||||
interpolation = "vertex"
|
||||
)`;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// vertex colors
|
||||
|
||||
const colorAttribute = attributes.color;
|
||||
|
||||
if ( colorAttribute !== undefined ) {
|
||||
|
||||
const count = colorAttribute.count;
|
||||
|
||||
string += `
|
||||
color3f[] primvars:displayColor = [${buildVector3Array( colorAttribute, count )}] (
|
||||
interpolation = "vertex"
|
||||
)`;
|
||||
|
||||
}
|
||||
|
||||
return string;
|
||||
|
||||
}
|
||||
|
||||
// Materials
|
||||
|
||||
function buildMaterials( materials, textures, quickLookCompatible = false ) {
|
||||
|
||||
const array = [];
|
||||
|
||||
for ( const uuid in materials ) {
|
||||
|
||||
const material = materials[ uuid ];
|
||||
|
||||
array.push( buildMaterial( material, textures, quickLookCompatible ) );
|
||||
|
||||
}
|
||||
|
||||
return `def "Materials"
|
||||
{
|
||||
${ array.join( '' ) }
|
||||
}
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildMaterial( material, textures, quickLookCompatible = false ) {
|
||||
|
||||
// https://graphics.pixar.com/usd/docs/UsdPreviewSurface-Proposal.html
|
||||
|
||||
const pad = ' ';
|
||||
const inputs = [];
|
||||
const samplers = [];
|
||||
|
||||
function buildTexture( texture, mapType, color ) {
|
||||
|
||||
const id = texture.source.id + '_' + texture.flipY;
|
||||
|
||||
textures[ id ] = texture;
|
||||
|
||||
const uv = texture.channel > 0 ? 'st' + texture.channel : 'st';
|
||||
|
||||
const WRAPPINGS = {
|
||||
1000: 'repeat', // RepeatWrapping
|
||||
1001: 'clamp', // ClampToEdgeWrapping
|
||||
1002: 'mirror' // MirroredRepeatWrapping
|
||||
};
|
||||
|
||||
const repeat = texture.repeat.clone();
|
||||
const offset = texture.offset.clone();
|
||||
const rotation = texture.rotation;
|
||||
|
||||
// rotation is around the wrong point. after rotation we need to shift offset again so that we're rotating around the right spot
|
||||
const xRotationOffset = Math.sin( rotation );
|
||||
const yRotationOffset = Math.cos( rotation );
|
||||
|
||||
// texture coordinates start in the opposite corner, need to correct
|
||||
offset.y = 1 - offset.y - repeat.y;
|
||||
|
||||
// turns out QuickLook is buggy and interprets texture repeat inverted/applies operations in a different order.
|
||||
// Apple Feedback: FB10036297 and FB11442287
|
||||
if ( quickLookCompatible ) {
|
||||
|
||||
// This is NOT correct yet in QuickLook, but comes close for a range of models.
|
||||
// It becomes more incorrect the bigger the offset is
|
||||
|
||||
offset.x = offset.x / repeat.x;
|
||||
offset.y = offset.y / repeat.y;
|
||||
|
||||
offset.x += xRotationOffset / repeat.x;
|
||||
offset.y += yRotationOffset - 1;
|
||||
|
||||
} else {
|
||||
|
||||
// results match glTF results exactly. verified correct in usdview.
|
||||
offset.x += xRotationOffset * repeat.x;
|
||||
offset.y += ( 1 - yRotationOffset ) * repeat.y;
|
||||
|
||||
}
|
||||
|
||||
return `
|
||||
def Shader "PrimvarReader_${ mapType }"
|
||||
{
|
||||
uniform token info:id = "UsdPrimvarReader_float2"
|
||||
float2 inputs:fallback = (0.0, 0.0)
|
||||
token inputs:varname = "${ uv }"
|
||||
float2 outputs:result
|
||||
}
|
||||
|
||||
def Shader "Transform2d_${ mapType }"
|
||||
{
|
||||
uniform token info:id = "UsdTransform2d"
|
||||
token inputs:in.connect = </Materials/Material_${ material.id }/PrimvarReader_${ mapType }.outputs:result>
|
||||
float inputs:rotation = ${ ( rotation * ( 180 / Math.PI ) ).toFixed( PRECISION ) }
|
||||
float2 inputs:scale = ${ buildVector2( repeat ) }
|
||||
float2 inputs:translation = ${ buildVector2( offset ) }
|
||||
float2 outputs:result
|
||||
}
|
||||
|
||||
def Shader "Texture_${ texture.id }_${ mapType }"
|
||||
{
|
||||
uniform token info:id = "UsdUVTexture"
|
||||
asset inputs:file = @textures/Texture_${ id }.png@
|
||||
float2 inputs:st.connect = </Materials/Material_${ material.id }/Transform2d_${ mapType }.outputs:result>
|
||||
${ color !== undefined ? 'float4 inputs:scale = ' + buildColor4( color ) : '' }
|
||||
token inputs:sourceColorSpace = "${ texture.colorSpace === NoColorSpace ? 'raw' : 'sRGB' }"
|
||||
token inputs:wrapS = "${ WRAPPINGS[ texture.wrapS ] }"
|
||||
token inputs:wrapT = "${ WRAPPINGS[ texture.wrapT ] }"
|
||||
float outputs:r
|
||||
float outputs:g
|
||||
float outputs:b
|
||||
float3 outputs:rgb
|
||||
${ material.transparent || material.alphaTest > 0.0 ? 'float outputs:a' : '' }
|
||||
}`;
|
||||
|
||||
}
|
||||
|
||||
|
||||
if ( material.side === DoubleSide ) {
|
||||
|
||||
console.warn( 'THREE.USDZExporter: USDZ does not support double sided materials', material );
|
||||
|
||||
}
|
||||
|
||||
if ( material.map !== null ) {
|
||||
|
||||
inputs.push( `${ pad }color3f inputs:diffuseColor.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:rgb>` );
|
||||
|
||||
if ( material.transparent ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
|
||||
|
||||
} else if ( material.alphaTest > 0.0 ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:opacity.connect = </Materials/Material_${ material.id }/Texture_${ material.map.id }_diffuse.outputs:a>` );
|
||||
inputs.push( `${ pad }float inputs:opacityThreshold = ${material.alphaTest}` );
|
||||
|
||||
}
|
||||
|
||||
samplers.push( buildTexture( material.map, 'diffuse', material.color ) );
|
||||
|
||||
} else {
|
||||
|
||||
inputs.push( `${ pad }color3f inputs:diffuseColor = ${ buildColor( material.color ) }` );
|
||||
|
||||
}
|
||||
|
||||
if ( material.emissiveMap !== null ) {
|
||||
|
||||
inputs.push( `${ pad }color3f inputs:emissiveColor.connect = </Materials/Material_${ material.id }/Texture_${ material.emissiveMap.id }_emissive.outputs:rgb>` );
|
||||
|
||||
samplers.push( buildTexture( material.emissiveMap, 'emissive' ) );
|
||||
|
||||
} else if ( material.emissive.getHex() > 0 ) {
|
||||
|
||||
inputs.push( `${ pad }color3f inputs:emissiveColor = ${ buildColor( material.emissive ) }` );
|
||||
|
||||
}
|
||||
|
||||
if ( material.normalMap !== null ) {
|
||||
|
||||
inputs.push( `${ pad }normal3f inputs:normal.connect = </Materials/Material_${ material.id }/Texture_${ material.normalMap.id }_normal.outputs:rgb>` );
|
||||
|
||||
samplers.push( buildTexture( material.normalMap, 'normal' ) );
|
||||
|
||||
}
|
||||
|
||||
if ( material.aoMap !== null ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:occlusion.connect = </Materials/Material_${ material.id }/Texture_${ material.aoMap.id }_occlusion.outputs:r>` );
|
||||
|
||||
samplers.push( buildTexture( material.aoMap, 'occlusion' ) );
|
||||
|
||||
}
|
||||
|
||||
if ( material.roughnessMap !== null && material.roughness === 1 ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:roughness.connect = </Materials/Material_${ material.id }/Texture_${ material.roughnessMap.id }_roughness.outputs:g>` );
|
||||
|
||||
samplers.push( buildTexture( material.roughnessMap, 'roughness' ) );
|
||||
|
||||
} else {
|
||||
|
||||
inputs.push( `${ pad }float inputs:roughness = ${ material.roughness }` );
|
||||
|
||||
}
|
||||
|
||||
if ( material.metalnessMap !== null && material.metalness === 1 ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:metallic.connect = </Materials/Material_${ material.id }/Texture_${ material.metalnessMap.id }_metallic.outputs:b>` );
|
||||
|
||||
samplers.push( buildTexture( material.metalnessMap, 'metallic' ) );
|
||||
|
||||
} else {
|
||||
|
||||
inputs.push( `${ pad }float inputs:metallic = ${ material.metalness }` );
|
||||
|
||||
}
|
||||
|
||||
if ( material.alphaMap !== null ) {
|
||||
|
||||
inputs.push( `${pad}float inputs:opacity.connect = </Materials/Material_${material.id}/Texture_${material.alphaMap.id}_opacity.outputs:r>` );
|
||||
inputs.push( `${pad}float inputs:opacityThreshold = 0.0001` );
|
||||
|
||||
samplers.push( buildTexture( material.alphaMap, 'opacity' ) );
|
||||
|
||||
} else {
|
||||
|
||||
inputs.push( `${pad}float inputs:opacity = ${material.opacity}` );
|
||||
|
||||
}
|
||||
|
||||
if ( material.isMeshPhysicalMaterial ) {
|
||||
|
||||
inputs.push( `${ pad }float inputs:clearcoat = ${ material.clearcoat }` );
|
||||
inputs.push( `${ pad }float inputs:clearcoatRoughness = ${ material.clearcoatRoughness }` );
|
||||
inputs.push( `${ pad }float inputs:ior = ${ material.ior }` );
|
||||
|
||||
}
|
||||
|
||||
return `
|
||||
def Material "Material_${ material.id }"
|
||||
{
|
||||
def Shader "PreviewSurface"
|
||||
{
|
||||
uniform token info:id = "UsdPreviewSurface"
|
||||
${ inputs.join( '\n' ) }
|
||||
int inputs:useSpecularWorkflow = 0
|
||||
token outputs:surface
|
||||
}
|
||||
|
||||
token outputs:surface.connect = </Materials/Material_${ material.id }/PreviewSurface.outputs:surface>
|
||||
|
||||
${ samplers.join( '\n' ) }
|
||||
|
||||
}
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
function buildColor( color ) {
|
||||
|
||||
return `(${ color.r }, ${ color.g }, ${ color.b })`;
|
||||
|
||||
}
|
||||
|
||||
function buildColor4( color ) {
|
||||
|
||||
return `(${ color.r }, ${ color.g }, ${ color.b }, 1.0)`;
|
||||
|
||||
}
|
||||
|
||||
function buildVector2( vector ) {
|
||||
|
||||
return `(${ vector.x }, ${ vector.y })`;
|
||||
|
||||
}
|
||||
|
||||
|
||||
function buildCamera( camera ) {
|
||||
|
||||
const name = camera.name ? camera.name : 'Camera_' + camera.id;
|
||||
|
||||
const transform = buildMatrix( camera.matrixWorld );
|
||||
|
||||
if ( camera.matrixWorld.determinant() < 0 ) {
|
||||
|
||||
console.warn( 'THREE.USDZExporter: USDZ does not support negative scales', camera );
|
||||
|
||||
}
|
||||
|
||||
if ( camera.isOrthographicCamera ) {
|
||||
|
||||
return `def Camera "${name}"
|
||||
{
|
||||
matrix4d xformOp:transform = ${ transform }
|
||||
uniform token[] xformOpOrder = ["xformOp:transform"]
|
||||
|
||||
float2 clippingRange = (${ camera.near.toPrecision( PRECISION ) }, ${ camera.far.toPrecision( PRECISION ) })
|
||||
float horizontalAperture = ${ ( ( Math.abs( camera.left ) + Math.abs( camera.right ) ) * 10 ).toPrecision( PRECISION ) }
|
||||
float verticalAperture = ${ ( ( Math.abs( camera.top ) + Math.abs( camera.bottom ) ) * 10 ).toPrecision( PRECISION ) }
|
||||
token projection = "orthographic"
|
||||
}
|
||||
|
||||
`;
|
||||
|
||||
} else {
|
||||
|
||||
return `def Camera "${name}"
|
||||
{
|
||||
matrix4d xformOp:transform = ${ transform }
|
||||
uniform token[] xformOpOrder = ["xformOp:transform"]
|
||||
|
||||
float2 clippingRange = (${ camera.near.toPrecision( PRECISION ) }, ${ camera.far.toPrecision( PRECISION ) })
|
||||
float focalLength = ${ camera.getFocalLength().toPrecision( PRECISION ) }
|
||||
float focusDistance = ${ camera.focus.toPrecision( PRECISION ) }
|
||||
float horizontalAperture = ${ camera.getFilmWidth().toPrecision( PRECISION ) }
|
||||
token projection = "perspective"
|
||||
float verticalAperture = ${ camera.getFilmHeight().toPrecision( PRECISION ) }
|
||||
}
|
||||
|
||||
`;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export { USDZExporter };
|
||||
Reference in New Issue
Block a user