rayzee 9.4.2 → 9.5.0

package/src/Processor/FileFormats.js

@@ -0,0 +1,116 @@
+import { FloatType, Mesh, MeshStandardMaterial, Points, PointsMaterial } from 'three';
+
+/**
+ * File formats beyond glTF and .hdr, each registered on its own (`assetLoader.registerFormat( fbxFormat )`) so a host
+ * ships only the readers it uses. A model format's `parse( file, { filename, cache } )` resolves to `{ model, result? }`;
+ * an environment format's `createLoader( manager )` to a three.js loader whose `loadAsync` resolves to a texture.
+ * Each three.js loader is imported the first time its format is read.
+ */
+
+export const fbxFormat = {
+	name: 'FBX', label: 'FBX', type: 'model', extensions: [ 'fbx' ],
+	async parse( file, { cache } ) {
+
+		cache.fbx ??= new ( await import( 'three/addons/loaders/FBXLoader.js' ) ).FBXLoader();
+		return { model: cache.fbx.parse( await file.arrayBuffer() ) };
+
+	},
+};
+
+export const objFormat = {
+	name: 'OBJ', label: 'OBJ', type: 'model', extensions: [ 'obj' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.obj ??= new ( await import( 'three/addons/loaders/OBJLoader.js' ) ).OBJLoader();
+		const model = cache.obj.parse( await file.text() );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const stlFormat = {
+	name: 'STL', label: 'STL', type: 'model', extensions: [ 'stl' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.stl ??= new ( await import( 'three/addons/loaders/STLLoader.js' ) ).STLLoader();
+		const model = new Mesh( cache.stl.parse( await file.arrayBuffer() ), new MeshStandardMaterial() );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const plyFormat = {
+	name: 'PLY (Polygon File Format)', label: 'PLY', type: 'model', extensions: [ 'ply' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.ply ??= new ( await import( 'three/addons/loaders/PLYLoader.js' ) ).PLYLoader();
+		const geometry = cache.ply.parse( await file.arrayBuffer() );
+		let model;
+		if ( geometry.index !== null ) {
+
+			model = new Mesh( geometry, new MeshStandardMaterial() );
+
+		} else {
+
+			const material = new PointsMaterial( { size: 0.01 } );
+			material.vertexColors = geometry.hasAttribute( 'color' );
+			model = new Points( geometry, material );
+
+		}
+
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const colladaFormat = {
+	name: 'Collada', label: 'Collada', type: 'model', extensions: [ 'dae' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.collada ??= new ( await import( 'three/addons/loaders/ColladaLoader.js' ) ).ColladaLoader();
+		const collada = cache.collada.parse( await file.text() );
+		collada.scene.name = filename;
+		return { model: collada.scene, result: collada };
+
+	},
+};
+
+export const threeMFFormat = {
+	name: '3D Manufacturing Format', label: '3MF', type: 'model', extensions: [ '3mf' ],
+	async parse( file, { cache } ) {
+
+		cache.threemf ??= new ( await import( 'three/addons/loaders/3MFLoader.js' ) ).ThreeMFLoader();
+		return { model: cache.threemf.parse( await file.arrayBuffer() ) };
+
+	},
+};
+
+export const usdFormat = {
+	name: 'USD (Universal Scene Description)', label: 'USD', type: 'model', extensions: [ 'usd', 'usda', 'usdc', 'usdz' ],
+	async parse( file, { filename, cache } ) {
+
+		cache.usd ??= new ( await import( 'three/addons/loaders/USDLoader.js' ) ).USDLoader();
+		const data = await file.arrayBuffer();
+		// parse() returns the group at once but resolves textures later; the materials are read after, so wait for them.
+		const model = await new Promise( ( resolve, reject ) => cache.usd.parse( data, '', resolve, reject ) );
+		model.name = filename;
+		return { model };
+
+	},
+};
+
+export const exrFormat = {
+	name: 'EXR (OpenEXR)', label: 'EXR', type: 'environment', extensions: [ 'exr' ],
+	async createLoader( manager ) {
+
+		const { EXRLoader } = await import( 'three/addons/loaders/EXRLoader.js' );
+		return new EXRLoader( manager ).setDataType( FloatType );
+
+	},
+};
+
+/** Every format above. */
+export const allFormats = [ fbxFormat, objFormat, stlFormat, plyFormat, colladaFormat, threeMFFormat, usdFormat, exrFormat ];

package/src/Processor/GLTFDecoders.js

@@ -0,0 +1,85 @@
+import { getAssetConfig } from '../AssetConfig.js';
+
+const DRACO = 'KHR_draco_mesh_compression';
+const BASISU = 'KHR_texture_basisu';
+const MESHOPT = [ 'EXT_meshopt_compression', 'KHR_meshopt_compression' ];
+
+const decoder = new TextDecoder();
+
+// The glTF's JSON as text: a .glb's first chunk, a .gltf whole. Only searched, never parsed.
+function jsonText( data ) {
+
+	if ( typeof data === 'string' ) return data;
+	if ( ! ( data instanceof ArrayBuffer ) ) return JSON.stringify( data?.extensionsUsed ?? [] );
+
+	const view = new DataView( data );
+	const isBinary = data.byteLength >= 20 && view.getUint32( 0, true ) === 0x46546C67;
+	if ( ! isBinary ) return decoder.decode( data );
+	const length = Math.min( view.getUint32( 12, true ), data.byteLength - 20 );
+	return decoder.decode( new Uint8Array( data, 20, length ) );
+
+}
+
+async function attachDecoders( loader, text, renderer ) {
+
+	const { dracoDecoderPath, ktx2TranscoderPath } = getAssetConfig();
+	const [ draco, ktx2, meshopt ] = await Promise.all( [
+		text.includes( DRACO ) && ! loader.dracoLoader ? import( 'three/addons/loaders/DRACOLoader.js' ) : null,
+		text.includes( BASISU ) && ! loader.ktx2Loader ? import( 'three/addons/loaders/KTX2Loader.js' ) : null,
+		MESHOPT.some( name => text.includes( name ) ) && ! loader.meshoptDecoder ? import( 'three/addons/libs/meshopt_decoder.module.js' ) : null,
+	] );
+
+	if ( draco ) {
+
+		const dracoLoader = new draco.DRACOLoader();
+		dracoLoader.setDecoderConfig( { type: 'js' } );
+		dracoLoader.setDecoderPath( dracoDecoderPath );
+		loader.setDRACOLoader( dracoLoader );
+
+	}
+
+	if ( ktx2 ) {
+
+		const ktx2Loader = new ktx2.KTX2Loader();
+		ktx2Loader.setTranscoderPath( ktx2TranscoderPath );
+		if ( renderer ) {
+
+			ktx2Loader.detectSupport( renderer );
+			// RGBA only: GPU-compressed texture arrays are blocked by a three.js TSL limitation (the node compiler's
+			// state survives dispose(), so swapping DataArrayTexture for CompressedArrayTexture breaks WGSL compilation).
+			ktx2Loader.workerConfig = {
+				astcSupported: false, etc1Supported: false, etc2Supported: false,
+				dxtSupported: false, bptcSupported: false, pvrtcSupported: false,
+			};
+
+		}
+
+		loader.setKTX2Loader( ktx2Loader );
+
+	}
+
+	if ( meshopt ) loader.setMeshoptDecoder( meshopt.MeshoptDecoder );
+
+}
+
+/**
+ * Gives a GLTFLoader the Draco, KTX2 and meshopt decoders only when the file it parses uses them, importing each then:
+ * most glTFs use none, and the three are ~35 KB compressed a host would otherwise always ship.
+ * @param {Object} loader - a GLTFLoader
+ * @param {?Object} renderer - for KTX2's format detection
+ */
+export function decodersOnDemand( loader, renderer ) {
+
+	const parse = loader.parse.bind( loader );
+	loader.parse = ( data, path, onLoad, onError ) => {
+
+		attachDecoders( loader, jsonText( data ), renderer ).then(
+			() => parse( data, path, onLoad, onError ),
+			( error ) => onError?.( error ),
+		);
+
+	};
+
+	return loader;
+
+}

package/src/Processor/GLTFDiffuseTransmission.js

@@ -0,0 +1,63 @@
+import { Color, LinearSRGBColorSpace, SRGBColorSpace } from 'three';
+
+export const DIFFUSE_TRANSMISSION_EXTENSION = 'KHR_materials_diffuse_transmission';
+
+/**
+ * A GLTFLoader plugin for KHR_materials_diffuse_transmission, which three.js does not read: each material's factors
+ * and textures become the engine's `diffuseTransmission`, `diffuseTransmissionColor`, `diffuseTransmissionMap` (its
+ * alpha is the factor) and `diffuseTransmissionColorMap`. The engine folds the maps in like the other extension maps,
+ * through the albedo map's uv transform.
+ */
+export function diffuseTransmissionPlugin( parser ) {
+
+	// The factor texture is read for its alpha alone and may be another slot's colour texture, so its colour space is
+	// left as it is.
+	const assign = ( material, key, info, colorSpace ) => {
+
+		const params = {};
+		return parser.assignTexture( params, key, info, colorSpace ).then( () => {
+
+			if ( params[ key ] ) material[ key ] = params[ key ];
+
+		} );
+
+	};
+
+	return {
+
+		name: DIFFUSE_TRANSMISSION_EXTENSION,
+
+		afterRoot( result ) {
+
+			const definitions = parser.json.materials ?? [];
+			const done = new Set();
+			const pending = [];
+
+			for ( const scene of result.scenes ?? [] ) scene.traverse( ( object ) => {
+
+				const materials = Array.isArray( object.material ) ? object.material : object.material ? [ object.material ] : [];
+				for ( const material of materials ) {
+
+					if ( done.has( material ) ) continue;
+					done.add( material );
+					const index = parser.associations.get( material )?.materials;
+					const extension = index === undefined ? null : definitions[ index ]?.extensions?.[ DIFFUSE_TRANSMISSION_EXTENSION ];
+					if ( ! extension ) continue;
+
+					material.diffuseTransmission = extension.diffuseTransmissionFactor ?? 0;
+					const [ r, g, b ] = extension.diffuseTransmissionColorFactor ?? [ 1, 1, 1 ];
+					material.diffuseTransmissionColor = new Color().setRGB( r, g, b, LinearSRGBColorSpace );
+					if ( extension.diffuseTransmissionTexture ) pending.push( assign( material, 'diffuseTransmissionMap', extension.diffuseTransmissionTexture ) );
+					if ( extension.diffuseTransmissionColorTexture ) pending.push( assign( material, 'diffuseTransmissionColorMap', extension.diffuseTransmissionColorTexture, SRGBColorSpace ) );
+
+				}
+
+			} );
+
+			return Promise.all( pending );
+
+		},
+
+	};
+
+}

package/src/Processor/GeometryExtractor.js

@@ -11,7 +11,7 @@ const log = createLogger( 'geometry' );
 
 const MAX_TEXTURES_LIMIT = TEXTURE_CONSTANTS.MAX_TEXTURES_LIMIT;
 
-const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor' ] );
+const COLOR_DEFAULTS = new Set( [ 'color', 'emissive', 'attenuationColor', 'sheenColor', 'specularColor', 'subsurfaceColor', 'diffuseTransmissionColor' ] );
 
 /**
  * Where a packed material value came from: the three.js material carried it, a legacy-type
@@ -58,6 +58,8 @@ export function resolveMaterialTextures( material ) {
 		sheenRoughnessMap: material.sheenRoughnessMap,
 		specularIntensityMap: material.specularIntensityMap,
 		specularColorMap: material.specularColorMap,
+		diffuseTransmissionMap: material.diffuseTransmissionMap,
+		diffuseTransmissionColorMap: material.diffuseTransmissionColorMap,
 		iridescenceMap: material.iridescenceMap,
 		iridescenceThicknessMap: material.iridescenceThicknessMap,
 	};
@@ -1110,6 +1112,9 @@ export class GeometryExtractor {
 			specularIntensity: pick( 'specularIntensity' ),
 			specularColor: pick( 'specularColor' ),
 
+			diffuseTransmission: pick( 'diffuseTransmission' ),
+			diffuseTransmissionColor: pick( 'diffuseTransmissionColor' ),
+
 			normalScale: pick( 'normalScale' ),
 			bumpScale: pick( 'bumpScale' ),
 			displacementScale: pick( 'displacementScale' ),
@@ -1141,6 +1146,8 @@ export class GeometryExtractor {
 			sheenRoughnessMap: this.processTexture( textures.sheenRoughnessMap, this.sheenRoughnessMaps ),
 			specularIntensityMap: this.processTexture( textures.specularIntensityMap, this.specularIntensityMaps ),
 			specularColorMap: this.processTexture( textures.specularColorMap, this.specularColorMaps ),
+			diffuseTransmissionMap: this.processTexture( textures.diffuseTransmissionMap, this.diffuseTransmissionMaps ),
+			diffuseTransmissionColorMap: this.processTexture( textures.diffuseTransmissionColorMap, this.diffuseTransmissionColorMaps ),
 			iridescenceMap: this.processTexture( textures.iridescenceMap, this.iridescenceMaps ),
 			iridescenceThicknessMap: this.processTexture( textures.iridescenceThicknessMap, this.iridescenceThicknessMaps ),
 
@@ -1537,6 +1544,8 @@ export class GeometryExtractor {
 		this.iridescenceThicknessMaps = [];
 		this.specularIntensityMaps = [];
 		this.specularColorMaps = [];
+		this.diffuseTransmissionMaps = [];
+		this.diffuseTransmissionColorMaps = [];
 		this.directionalLights = [];
 		this.cameras = [];
 
@@ -1578,6 +1587,8 @@ export class GeometryExtractor {
 			iridescenceThicknessMaps: this.iridescenceThicknessMaps,
 			specularIntensityMaps: this.specularIntensityMaps,
 			specularColorMaps: this.specularColorMaps,
+			diffuseTransmissionMaps: this.diffuseTransmissionMaps,
+			diffuseTransmissionColorMaps: this.diffuseTransmissionColorMaps,
 			directionalLights: this.directionalLights,
 			cameras: this.cameras
 		};

package/src/Processor/IESParser.js

@@ -125,19 +125,39 @@ export function parseIES( text, name = 'ies' ) {
 
 }
 
+/**
+ * The horizontal angle a type C profile stores for `hDeg` in [0, 360), by the symmetry its range implies
+ * (LM-63): one angle — the same all round; 0–90 — mirrored about the 0–180 and 90–270 planes; 0–180 — about the
+ * 0–180 plane; 90–270 — about the 90–270 plane; 0–360 — none.
+ */
+function storedHorizontalAngle( hDeg, hMin, hMax ) {
+
+	if ( hMin === 0 && hMax === 90 ) {
+
+		const half = hDeg % 180;
+		return half > 90 ? 180 - half : half;
+
+	}
+
+	if ( hMin === 0 && hMax === 180 ) return hDeg > 180 ? 360 - hDeg : hDeg;
+	if ( hMin === 90 && hMax === 270 ) return hDeg >= 90 && hDeg <= 270 ? hDeg : ( ( 540 - hDeg ) % 360 );
+	return hDeg;
+
+}
+
 /**
  * Resample an IESProfile onto a fixed-size 2D grid suitable for a
  * DataArrayTexture layer. Values are normalised to [0,1] by `maxCandela`
  * so the shader gets a pure shape multiplier; absolute intensity scaling
  * stays in `light.intensity`.
  *
- * UV convention:
+ * UV convention (TSL/LightsCore.js sampleIESProfile reads it so):
  *   U = horizontal angle / 360  (0..1)
  *   V = vertical angle / 180    (0..1, 0 = bulb axis, 1 = opposite axis)
  *
- * Profiles that are rotationally symmetric (single horizontal sample, or all
- * H angles identical) replicate the row across the U axis so the shader can
- * sample uniformly without a symmetry flag.
+ * The grid always spans the whole sphere: a downlight's 0–90° fills the lower half and leaves the upper dark, and
+ * a horizontal range with a symmetry is mirrored round (storedHorizontalAngle). Angles outside the file's range
+ * emit nothing. Type A and B profiles, whose angles mean something else, are stretched over the grid as before.
  *
  * @param {IESProfile} profile
  * @param {number} width   - texture width in samples (horizontal/U axis)
@@ -147,20 +167,34 @@ export function parseIES( text, name = 'ies' ) {
 export function resampleIESToGrid( profile, width, height ) {
 
 	const data = new Uint8Array( width * height );
-	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela } = profile;
+	const { verticalAngles: vA, horizontalAngles: hA, candela, maxCandela, photometricType } = profile;
 
 	if ( maxCandela <= 0 ) return data; // dead profile → zeros
 
-	const vMaxDeg = vA[ vA.length - 1 ];
-	const hMaxDeg = hA[ hA.length - 1 ];
+	const typeC = photometricType === undefined || photometricType === 1;
+	const vMin = vA[ 0 ];
+	const vMax = vA[ vA.length - 1 ];
 	const hMin = hA[ 0 ];
-	const rotationallySymmetric = hA.length === 1 || hMaxDeg === hMin;
+	const hMax = hA[ hA.length - 1 ];
+	const rotationallySymmetric = hA.length === 1 || hMax === hMin;
+
+	const at = ( v0, v1, vt, hDeg ) => {
+
+		if ( rotationallySymmetric ) return lerp( candela[ v0 ][ 0 ], candela[ v1 ][ 0 ], vt );
+		if ( hDeg < hMin || hDeg > hMax ) return 0;
+		const h0 = lowerBoundIdx( hA, hDeg );
+		const h1 = Math.min( h0 + 1, hA.length - 1 );
+		const hSpan = hA[ h1 ] - hA[ h0 ];
+		const ht = hSpan > 0 ? ( hDeg - hA[ h0 ] ) / hSpan : 0;
+		return lerp( lerp( candela[ v0 ][ h0 ], candela[ v0 ][ h1 ], ht ), lerp( candela[ v1 ][ h0 ], candela[ v1 ][ h1 ], ht ), vt );
+
+	};
 
 	for ( let py = 0; py < height; py ++ ) {
 
-		// V coordinate → vertical angle in degrees. Texture covers [0, vMaxDeg].
 		const tV = ( py + 0.5 ) / height;
-		const vDeg = tV * vMaxDeg;
+		const vDeg = typeC ? tV * 180 : vMin + tV * ( vMax - vMin );
+		if ( vDeg < vMin || vDeg > vMax ) continue;
 		const v0 = lowerBoundIdx( vA, vDeg );
 		const v1 = Math.min( v0 + 1, vA.length - 1 );
 		const vSpan = vA[ v1 ] - vA[ v0 ];
@@ -168,31 +202,9 @@ export function resampleIESToGrid( profile, width, height ) {
 
 		for ( let px = 0; px < width; px ++ ) {
 
-			let cd;
-
-			if ( rotationallySymmetric ) {
-
-				// Single column → just bilerp on V axis.
-				cd = lerp( candela[ v0 ][ 0 ], candela[ v1 ][ 0 ], vt );
-
-			} else {
-
-				const tH = ( px + 0.5 ) / width;
-				const hDeg = hMin + tH * ( hMaxDeg - hMin );
-				const h0 = lowerBoundIdx( hA, hDeg );
-				const h1 = Math.min( h0 + 1, hA.length - 1 );
-				const hSpan = hA[ h1 ] - hA[ h0 ];
-				const ht = hSpan > 0 ? ( hDeg - hA[ h0 ] ) / hSpan : 0;
-
-				const c00 = candela[ v0 ][ h0 ];
-				const c10 = candela[ v0 ][ h1 ];
-				const c01 = candela[ v1 ][ h0 ];
-				const c11 = candela[ v1 ][ h1 ];
-				cd = lerp( lerp( c00, c10, ht ), lerp( c01, c11, ht ), vt );
-
-			}
-
-			const norm = Math.min( 1, Math.max( 0, cd / maxCandela ) );
+			const tH = ( px + 0.5 ) / width;
+			const hDeg = typeC ? storedHorizontalAngle( tH * 360, hMin, hMax ) : hMin + tH * ( hMax - hMin );
+			const norm = Math.min( 1, Math.max( 0, at( v0, v1, vt, hDeg ) / maxCandela ) );
 			data[ py * width + px ] = Math.round( norm * 255 );
 
 		}

package/src/Processor/KernelManager.js

@@ -95,11 +95,44 @@ export class KernelManager {
 	 * Register a pre-built compute node.
 	 * @param {string} name - Kernel name (e.g. 'generate', 'extend')
 	 * @param {ComputeNode} computeNode - Built via `Fn().compute([dx,dy,dz], [wgx,wgy,wgz])`
+	 * @param {{eager?: boolean}} [options] - `eager: false` leaves it out of compile(): it compiles at its first dispatch
 	 */
-	register( name, computeNode ) {
+	register( name, computeNode, { eager = true } = {} ) {
 
 		this.kernels.set( name, computeNode );
-		this.timing.set( name, { compiledOnce: false, lastDispatchMs: 0 } );
+		this.timing.set( name, { compiledOnce: false, lastDispatchMs: 0, eager } );
+
+	}
+
+	/**
+	 * Whether compile() can run here: three yields between build steps through scheduler.yield or requestAnimationFrame,
+	 * and Node has neither (nor a page to keep responsive).
+	 */
+	static get canCompileInBackground() {
+
+		return typeof globalThis.requestAnimationFrame === 'function' || typeof globalThis.scheduler?.yield === 'function';
+
+	}
+
+	/**
+	 * Compiles the eager kernels without blocking the page: three.js generates their WGSL in steps that yield and
+	 * creates the GPU pipelines asynchronously. A dispatch after it compiles nothing.
+	 * @returns {Promise<void>}
+	 */
+	async compile() {
+
+		const eager = [ ...this.kernels ].filter( ( [ name ] ) => this.timing.get( name )?.eager );
+		const t0 = performance.now();
+		// One call per kernel, all at once: the GPU compiles them side by side rather than each after the last.
+		await Promise.all( eager.map( ( [ , node ] ) => this.renderer.compileComputeAsync( node ) ) );
+		for ( const [ name ] of eager ) {
+
+			const entry = this.timing.get( name );
+			if ( entry ) entry.compiledOnce = true;
+
+		}
+
+		log.info( `${eager.length} kernels compiled in the background in ${fmt.ms( performance.now() - t0 )}` );
 
 	}
 

package/src/Processor/MaterialPacking.js

@@ -15,8 +15,7 @@ const TRANSFORMS = [
 
 /** Floats no field writes; the packer gives them fixed values. */
 export const MATERIAL_RESERVED_FLOATS = Object.freeze( [
-	M.VISIBLE, M.SHEEN_COLOR + 3, M.DISPLACEMENT_MAP_INDEX + 1,
-	M.SPECULAR_COLOR_MAP_INDEX + 1, M.SPECULAR_COLOR_MAP_INDEX + 2, M.SPECULAR_COLOR_MAP_INDEX + 3,
+	M.VISIBLE, M.DISPLACEMENT_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1, M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2,
 ] );
 
 /**
@@ -25,7 +24,7 @@ export const MATERIAL_RESERVED_FLOATS = Object.freeze( [
  */
 export const UNIT_RANGE_PROPERTIES = Object.freeze( new Set( [
 	'metalness', 'roughness', 'transmission', 'opacity', 'clearcoat', 'clearcoatRoughness',
-	'sheen', 'sheenRoughness', 'specularIntensity', 'iridescence', 'subsurface', 'anisotropy',
+	'sheen', 'sheenRoughness', 'specularIntensity', 'iridescence', 'subsurface', 'anisotropy', 'diffuseTransmission',
 ] ) );
 
 export const clampUnit = ( value ) => Math.min( Math.max( value, 0 ), 1 );
@@ -116,6 +115,7 @@ export function packMaterial( data, base, mat ) {
 	u( M.SHEEN_ROUGHNESS, mat.sheenRoughness, D.sheenRoughness );
 
 	writeTriple( data, base + M.SHEEN_COLOR, mat.sheenColor, D.sheenColor );
+	u( M.DIFFUSE_TRANSMISSION, mat.diffuseTransmission, D.diffuseTransmission );
 
 	u( M.SPECULAR_INTENSITY, mat.specularIntensity, D.specularIntensity );
 	writeTriple( data, base + M.SPECULAR_COLOR, mat.specularColor, D.specularColor );
@@ -157,12 +157,13 @@ export function packMaterial( data, base, mat ) {
 	data[ base + M.SPECULAR_INTENSITY_MAP_INDEX ] = mapIndex( mat.specularIntensityMap );
 
 	data[ base + M.SPECULAR_COLOR_MAP_INDEX ] = mapIndex( mat.specularColorMap );
+	writeTriple( data, base + M.DIFFUSE_TRANSMISSION_COLOR, mat.diffuseTransmissionColor, D.diffuseTransmissionColor );
+	data[ base + M.DIFFUSE_TRANSMISSION_MAP_INDEX ] = mapIndex( mat.diffuseTransmissionMap );
+	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX ] = mapIndex( mat.diffuseTransmissionColorMap );
 
 	data[ base + M.VISIBLE ] = 1;
-	data[ base + M.SHEEN_COLOR + 3 ] = 1;
 	data[ base + M.DISPLACEMENT_MAP_INDEX + 1 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 1 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 2 ] = 0;
-	data[ base + M.SPECULAR_COLOR_MAP_INDEX + 3 ] = 0;
+	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 1 ] = 0;
+	data[ base + M.DIFFUSE_TRANSMISSION_COLOR_MAP_INDEX + 2 ] = 0;
 
 }