rayzee 8.5.0 → 8.6.0

package/src/TSL/ShadeKernel.js

@@ -7,7 +7,7 @@
 import {
 	Fn, float, vec2, vec3, vec4, int, uint,
 	bool as tslBool,
-	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep, mix,
+	If, Loop, normalize, max, min, exp, log, clamp, dot, length, select, smoothstep,
 	instanceIndex,
 	sampler,
 	atomicAdd, atomicLoad, atomicStore, uintBitsToFloat,
@@ -15,20 +15,21 @@ import {
 } from 'three/tsl';
 
 import { sampleEnvironment, sampleEquirectProbability, sampleEquirect, groundProjectedEnvDir } from './Environment.js';
-import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial } from './Common.js';
+import { getMaterial, powerHeuristic, balanceHeuristic, classifyMaterial, REC709_LUMINANCE_COEFFICIENTS, PI_INV, EPSILON, diffuseGroundMaterial, offsetRayOrigin, SHADOW_END } from './Common.js';
 import { cosineWeightedSample } from './MaterialSampling.js';
 import { sampleAllMaterialTextures, processAnisotropyMap, applyExtensionMaps, getTransformedUV, triangleUVTangent } from './TextureSampling.js';
 import { evaluateMaterialResponse } from './MaterialEvaluation.js';
 import { calculateDirectLightingUnified, calculateMaterialPDF } from './LightsSampling.js';
-import { traceShadowRay, calculateRayOffset } from './LightsDirect.js';
+import { traceShadowRay } from './LightsDirect.js';
+import { shadowTerminatorOrigin } from './ShadowTerminator.js';
+import { unpackHitFacet } from './HitFacet.js';
 import { traverseBVHShadow } from './BVHTraversal.js';
 import { handleMaterialTransparency, MaterialInteractionResult } from './MaterialTransmission.js';
 import { sampleChromaticCollision, sampleHenyeyGreenstein, subsurfaceCoefficients, CollisionSample, MediumCoeffs } from './Subsurface.js';
 import { calculateIndirectLighting } from './LightsIndirect.js';
 import { IndirectLightingResult, sampleCone } from './LightsCore.js';
 import { regularizePathContribution, generateSampledDirection, computeNDCDepth, handleRussianRoulette } from './PathTracerCore.js';
-import { evaluateDFG } from './MaterialProperties.js';
-import { dielectricF0 } from './Fresnel.js';
+import { evaluateSpecularDFG, baseFresnelParams } from './MaterialProperties.js';
 import { NRD_HIT_DIST_A, NRD_HIT_DIST_B } from '../EngineDefaults.js';
 import { sampleClearcoat, ClearcoatResult } from './Clearcoat.js';
 import { refineDisplacedIntersection, DisplacementResult } from './Displacement.js';
@@ -46,6 +47,7 @@ import {
 	MaterialCache,
 	DirectLightingDual,
 	DFGResult,
+	BaseFresnel,
 } from './Struct.js';
 import { getRandomSample, getRandomSample1D, getRandomSample2D, SAMPLER_DIMS_PER_BOUNCE, SAMPLER_DIM_AUX_BASE } from './Random.js';
 import { RAY_FLAG, COUNTER } from '../Processor/QueueManager.js';
@@ -56,7 +58,7 @@ import {
 	readTransparentCount,
 	readMisRayT,
 	readHitDistance, readHitBarycentrics, readHitNormal,
-	readHitMaterialIndex, readHitTriangleIndex, readHitInstanceLeaf,
+	readHitMaterialIndex, readHitTriangleIndex, readHitInstanceLeaf, readHitFacet,
 	writeRayOriginMeta, writeRayDirFlags, writeRayThroughputPdf, writeRayRadiance,
 	writeGBuffer, writeGBufferHitDist, readGBuffer, gbDecodeNormalDepth,
 	readRayRadiance,
@@ -96,6 +98,7 @@ export function buildShadeKernel( params ) {
 		globalIlluminationIntensity,
 		cameraProjectionMatrix, cameraViewMatrix,
 		fireflyThreshold, frame, resolution,
+		shadowTerminatorOffset, // Cycles' Shadow Terminator → Geometry Offset; 0 disables
 		// Accumulation index, NOT the free-running seed counter `frame` rides. The firefly clamp
 		// relaxes as sqrt(frame+1) so its bias decays as a render converges; keying that off the
 		// seed axis let it grow for the whole session and disabled suppression outright.
@@ -283,6 +286,7 @@ export function buildShadeKernel( params ) {
 						envTotalSum, envCompensationDelta, envResolution,
 						enableEnvironmentLight,
 						tslBool( true ), // wantUnoccluded
+						vec3( 0.0 ), planeN, float( 0.0 ),
 					) ).toVar();
 
 					const lumShad = max( dot( dual.shadowed, REC709_LUMINANCE_COEFFICIENTS ), float( 0.0 ) );
@@ -930,10 +934,9 @@ export function buildShadeKernel( params ) {
 
 			throughput.mulAssign( interaction.throughput );
 
-			// reflection stays on same side, transmission pushes through
-			const reflectOffsetDir = select( interaction.entering, N, N.negate() );
-			const offsetDir = select( interaction.didReflect, reflectOffsetDir, direction );
-			const newOrigin = hitPoint.add( offsetDir.mul( 0.001 ) );
+			// Off the side of the facet the new ray leaves on: reflection stays, transmission and alpha skip cross.
+			const Ng = unpackHitFacet( readHitFacet( hitBufferRO, rayID ) ).faceN;
+			const newOrigin = offsetRayOrigin( hitPoint, select( dot( Ng, interaction.direction ).lessThan( 0.0 ), Ng.negate(), Ng ) );
 
 			// SSS = free bounce (depth unchanged); transmission advances camera-bounce depth.
 			// Transmissive / alpha-skip / SSS-boundary are all FREE bounces — they do NOT advance camera depth (megakernel parity, gap #4). cameraDepth advances only on opaque scatter (below).
@@ -1062,6 +1065,14 @@ export function buildShadeKernel( params ) {
 		// face-forwarded geometric normal: horizon guard for NEE and the bounce continuation
 		const Ngeo = normalize( hitNormal );
 		const NgeoFF = select( dot( Ngeo, V ).lessThan( 0.0 ), Ngeo.negate(), Ngeo ).toVar();
+		// The facet on the viewer's side: every ray spawned from here is offset off it (HitFacet.js).
+		const facet = unpackHitFacet( readHitFacet( hitBufferRO, rayID ) );
+		const facetN = facet.faceN.toVar();
+		const terminatorLift = Ngeo.mul( facet.liftScale );
+		const lightShadowOrigin = L => shadowTerminatorOrigin( {
+			hitPoint, offsetNormal: facetN, lift: terminatorLift, faceN: facetN, smoothN: NgeoFF, L,
+			cutoff: shadowTerminatorOffset,
+		} );
 
 		// Two-sided shading: opaque path only (transmissive/SSS already continued). Decide the flip on the
 		// GEOMETRIC normal — an inward-normal / double-sided mesh (GLB/PBRT) faces away as a whole — so a
@@ -1094,11 +1105,11 @@ export function buildShadeKernel( params ) {
 				// smooth mirror / metal: DEFER — tint by the specular directional albedo (metal colour),
 				// matching the opaque throughput (≈ F at the near-delta mirror lobe). Achromatic energy excluded.
 				const NoV = max( dot( N, V ), float( 1e-3 ) );
-				const F0 = clamp(
-					mix( dielectricF0( material.ior ).mul( material.specularColor ), albedo, material.metalness ).mul( material.specularIntensity ),
-					vec3( 0.0 ), vec3( 1.0 ),
-				);
-				featCarry.mulAssign( DFGResult.wrap( evaluateDFG( F0, NoV, max( rawRough, float( 0.02 ) ) ) ).E_total );
+				const bf = BaseFresnel.wrap( baseFresnelParams( material, albedo ) );
+				featCarry.mulAssign( DFGResult.wrap( evaluateSpecularDFG(
+					bf.f0, bf.f90, bf.eta, bf.F0m, material.metalness, vec3( 0.0 ), float( 0.0 ), bf.F0,
+					NoV, max( rawRough, float( 0.02 ) ),
+				) ).E_total );
 
 			} );
 
@@ -1176,6 +1187,7 @@ export function buildShadeKernel( params ) {
 			envTotalSum, envCompensationDelta, envResolution,
 			enableEnvironmentLight,
 			tslBool( false ), // wantUnoccluded: false on real surfaces — dead-codes the unoccluded sum
+			terminatorLift, facetN, shadowTerminatorOffset,
 		) ).shadowed.toVar();
 
 		const giScale = select( bounceIndex.greaterThan( 0 ), globalIlluminationIntensity, float( 1.0 ) );
@@ -1230,11 +1242,12 @@ export function buildShadeKernel( params ) {
 
 							If( NoL.greaterThan( 0.0 ).and( dot( emissiveSample.direction, NgeoFF ).greaterThan( 0.0 ) ), () => {
 
-								const rayOffset = calculateRayOffset( hitPoint, NgeoFF, material );
-								const rayOrigin = hitPoint.add( rayOffset );
-								const shadowDist = emissiveSample.distance.sub( 0.001 );
+								// Aimed at the sampled point and stopped a relative hair short, as for area lights.
+								const rayOrigin = lightShadowOrigin( emissiveSample.direction ).toVar();
+								const toSample = emissiveSample.position.sub( rayOrigin ).toVar();
+								const shadowDist = length( toSample ).toVar();
 								const visibility = traceShadowRayWrapped(
-									rayOrigin, emissiveSample.direction, shadowDist,
+									rayOrigin, toSample.div( shadowDist ), shadowDist.mul( SHADOW_END ),
 								);
 
 								If( visibility.greaterThan( 0.0 ), () => {
@@ -1278,7 +1291,7 @@ export function buildShadeKernel( params ) {
 							lightBuffer, emissiveVec4Offset, emissiveTriangleCount, emissiveTotalPower,
 							triangleBuffer, bvhBuffer,
 							traceShadowRayWrapped,
-							calculateRayOffset,
+							Fn( ( [ p, , L ] ) => lightShadowOrigin( L ).sub( p ) ),
 						);
 
 						currentRadiance.assign( vec4(
@@ -1352,7 +1365,7 @@ export function buildShadeKernel( params ) {
 
 		} );
 
-		const newOrigin = hitPoint.add( N.mul( 0.001 ) );
+		const newOrigin = offsetRayOrigin( hitPoint, select( dot( facetN, bounceDir ).lessThan( 0.0 ), facetN.negate(), facetN ) );
 
 		// Opaque scatter: the only bounce that advances camera depth.
 		writeRayOriginMeta( rayBufferRW, rayID, newOrigin, cameraDepth.add( 1 ), sssSteps, transparentCount );

package/src/TSL/ShadowTerminator.js

@@ -0,0 +1,125 @@
+/**
+ * Cycles' shadow terminator geometry offset (kernel/light/sample.h, Blender 5.1).
+ *
+ * Near the terminator of a smooth-shaded low-poly surface, a light's shadow ray leaving the flat
+ * facet is blocked by that facet or its neighbours although the smooth normal says the point is lit,
+ * which draws the mesh's outline into the shading. Starting the ray on the smooth surface the vertex
+ * normals describe — lifted along the normal by a parabolic estimate, bounded by each vertex's
+ * tangent plane — removes it. Only light and environment shadow rays use it, as in Cycles.
+ *
+ * Extend computes the lift with the facet normal (HitFacet.js), where the triangle's corners were just
+ * read, and packs both into the hit record's spare lane.
+ */
+
+import { vec3, float, max, min, dot, length, clamp, select, If } from 'three/tsl';
+import { instanceRows, instanceDirToWorld, offsetRayOrigin } from './Common.js';
+
+/**
+ * The lift at full strength, as a signed length along the hit's smooth normal, from the triangle's
+ * corners (see HitFacet.js). Cycles lifts along the object-to-world image of that normal; the two
+ * agree unless the placement scales non-uniformly. Zero on a flat-shaded triangle.
+ *
+ * @param {Object} p - corners and vertex normals as stored (object space when `instanced`), and
+ *   `faceN`, the world facet normal on the viewer's side
+ */
+export function shadowTerminatorLift( { V0, V1, V2, N0, N1, N2, hitPoint, instanced, bvhBuffer, instanceLeaf, faceN } ) {
+
+	const scale = float( 0.0 ).toVar();
+
+	const P = hitPoint.toVar();
+	If( instanced, () => {
+
+		const rows = instanceRows( bvhBuffer, instanceLeaf );
+		P.assign( vec3(
+			rows[ 0 ].xyz.dot( hitPoint ).add( rows[ 0 ].w ),
+			rows[ 1 ].xyz.dot( hitPoint ).add( rows[ 1 ].w ),
+			rows[ 2 ].xyz.dot( hitPoint ).add( rows[ 2 ].w ),
+		) );
+
+	} );
+
+	// The hit record keeps texture UVs, not barycentrics.
+	const e1 = V1.sub( V0 ).toVar();
+	const e2 = V2.sub( V0 ).toVar();
+	const ep = P.sub( V0 ).toVar();
+	const d11 = dot( e1, e1 );
+	const d12 = dot( e1, e2 );
+	const d22 = dot( e2, e2 );
+	const den = d11.mul( d22 ).sub( d12.mul( d12 ) ).toVar();
+
+	If( den.greaterThan( d11.mul( d22 ).mul( 1e-12 ) ), () => {
+
+		const dp1 = dot( ep, e1 );
+		const dp2 = dot( ep, e2 );
+		const v = clamp( d22.mul( dp1 ).sub( d12.mul( dp2 ) ).div( den ), 0.0, 1.0 ).toVar();
+		const w = clamp( d11.mul( dp2 ).sub( d12.mul( dp1 ) ).div( den ), 0.0, float( 1.0 ).sub( v ) ).toVar();
+		const u = float( 1.0 ).sub( v ).sub( w ).toVar();
+
+		const Pl = V0.mul( u ).add( V1.mul( v ) ).add( V2.mul( w ) ).toVar();
+		const nLocal = N0.mul( u ).add( N1.mul( v ) ).add( N2.mul( w ) ).toVar();
+		const n = nLocal.toVar();
+		If( instanced, () => {
+
+			const rows = instanceRows( bvhBuffer, instanceLeaf );
+			n.assign( instanceDirToWorld( { r0: rows[ 0 ].xyz, r1: rows[ 1 ].xyz, r2: rows[ 2 ].xyz, v: nLocal } ) );
+
+		} );
+
+		// Parabolic approximation.
+		const a = dot( N2.sub( N0 ), V0.sub( V2 ) );
+		const b = dot( N2.sub( N1 ), V1.sub( V2 ) );
+		const c = dot( N1.sub( N0 ), V1.sub( V0 ) );
+		const h = a.mul( u ).mul( u.sub( 1.0 ) ).add( a.add( b ).add( c ).mul( u ).mul( v ) ).add( b.mul( v ).mul( v.sub( 1.0 ) ) ).toVar();
+
+		// Bounded by the local linear envelope of the vertices' tangent planes.
+		If( dot( n, faceN ).greaterThan( 0.0 ), () => {
+
+			const h0 = max( dot( V0.sub( Pl ), N0 ).add( max( max( dot( V1.sub( V0 ), N0 ), dot( V2.sub( V0 ), N0 ) ), 0.0 ) ), 0.0 );
+			const h1 = max( dot( V1.sub( Pl ), N1 ).add( max( max( dot( V0.sub( V1 ), N1 ), dot( V2.sub( V1 ), N1 ) ), 0.0 ) ), 0.0 );
+			const h2 = max( dot( V2.sub( Pl ), N2 ).add( max( max( dot( V0.sub( V2 ), N2 ), dot( V1.sub( V2 ), N2 ) ), 0.0 ) ), 0.0 );
+			h.assign( max( min( min( h0, h1 ), h2 ), h.mul( 0.5 ) ) );
+
+		} ).Else( () => {
+
+			const h0 = max( dot( Pl.sub( V0 ), N0 ).add( max( max( dot( V0.sub( V1 ), N0 ), dot( V0.sub( V2 ), N0 ) ), 0.0 ) ), 0.0 );
+			const h1 = max( dot( Pl.sub( V1 ), N1 ).add( max( max( dot( V1.sub( V0 ), N1 ), dot( V1.sub( V2 ), N1 ) ), 0.0 ) ), 0.0 );
+			const h2 = max( dot( Pl.sub( V2 ), N2 ).add( max( max( dot( V2.sub( V0 ), N2 ), dot( V2.sub( V1 ), N2 ) ), 0.0 ) ), 0.0 );
+			h.assign( min( min( min( h0, h1 ), h2 ).negate(), h.mul( 0.5 ) ) );
+
+		} );
+
+		scale.assign( length( n ).mul( h ) );
+
+	} );
+
+	return scale;
+
+}
+
+/**
+ * A shadow ray's origin towards direction `L`: lifted by the share of the lift Cycles gives a
+ * direction this close to the terminator, then offset as every spawned ray is.
+ *
+ * @param {Object} p
+ * @param {Node} p.lift - the hit's unit smooth normal times the lift's scale
+ * @param {Node} p.smoothN - the interpolated normal on the viewer's side (Cycles' sd->N)
+ * @param {Node} p.cutoff - the geometry offset setting; 0 disables
+ */
+export function shadowTerminatorOrigin( { hitPoint, offsetNormal, lift, faceN, smoothN, L, cutoff } ) {
+
+	// Cycles lifts towards the back for a transmitted direction; NEE here only lights the front.
+	const NL = dot( smoothN, L );
+	const NgL = dot( faceN, L );
+	const c = max( cutoff, 1e-6 );
+	const amount = select(
+		cutoff.greaterThan( 0.0 ).and( NL.greaterThan( 0.0 ) ),
+		select(
+			NL.lessThan( cutoff ),
+			clamp( float( 2.0 ).sub( NgL.add( NL ).div( c ) ), 0.0, 1.0 ),
+			clamp( float( 1.0 ).sub( NgL.div( c ) ), 0.0, 1.0 ),
+		),
+		float( 0.0 ),
+	);
+	return offsetRayOrigin( hitPoint.add( lift.mul( amount ) ), offsetNormal );
+
+}

package/src/TSL/Struct.js

@@ -198,6 +198,15 @@ export const DFGResult = struct( {
 	E_total: 'vec3', // clamp(E_ss * compensation, 0, 1)
 } );
 
+// Base-layer Fresnel inputs (see baseFresnelParams).
+export const BaseFresnel = struct( {
+	f0: 'vec3', // dielectric reflectance head-on: min(F0(ior) * specularColor, 1) * specularIntensity
+	f90: 'float', // dielectric reflectance at grazing: specularIntensity
+	eta: 'float', // max(ior, 1)
+	F0m: 'vec3', // metal F0: color * specularIntensity
+	F0: 'vec3', // the two blended by metalness — the multiscatter tint and the iridescence substrate
+} );
+
 export const MaterialSamples = struct( {
 	albedo: 'vec4',
 	emissive: 'vec3',

package/src/TSL/Subsurface.js

@@ -30,7 +30,7 @@ import {
 import { struct } from './patches.js';
 import { TWO_PI, EPSILON, constructTBN } from './Common.js';
 import { getRandomSample1D, getRandomSample2D } from './Random.js';
-import { iorToFresnel0, fresnelSchlickFloat } from './Fresnel.js';
+import { fresnelDielectric } from './Fresnel.js';
 import { ImportanceSampleGGX } from './MaterialSampling.js';
 
 // ================================================================================
@@ -189,8 +189,7 @@ export const handleSubsurfaceEntry = Fn( ( [
 	const sinThetaT2 = n1.mul( n1 ).div( max( n2.mul( n2 ), EPSILON ) ).mul( float( 1.0 ).sub( cosThetaI.mul( cosThetaI ) ) );
 	const tir = sinThetaT2.greaterThan( 1.0 ).toVar();
 
-	const F0 = iorToFresnel0( n2, n1 );
-	const Fr = select( tir, float( 1.0 ), fresnelSchlickFloat( cosThetaI, F0 ) ).toVar();
+	const Fr = fresnelDielectric( cosThetaI, n2.div( max( n1, EPSILON ) ) ).toVar();
 	const reflectProb = clamp( Fr, 0.02, 0.98 ).toVar();
 
 	const doReflect = tir.or( getRandomSample1D( pixelCoord, int( 0 ), dimBase.add( int( 11 ) ), rngState, resolution, frame ).lessThan( reflectProb ) ).toVar();

package/src/index.js

@@ -27,7 +27,7 @@ export { SETTING_SOURCE } from './RenderSettings.js';
 export { configureAssets, getAssetConfig } from './AssetConfig.js';
 
 // glTF alphaMode derivation — the one definition, shared with hosts that edit materials
-export { deriveAlphaMode } from './Processor/GeometryExtractor.js';
+export { deriveAlphaMode, MATERIAL_VALUE_SOURCE } from './Processor/GeometryExtractor.js';
 
 // Scene-level authoring metadata embedded in model files (glTF `extras`)
 export { extractSceneMetadata, parseSceneMetadata } from './Processor/SceneMetadata.js';
@@ -53,6 +53,7 @@ export {
 	BVH_LEAF_MARKERS,
 	TEXTURE_CONSTANTS,
 	DEFAULT_TEXTURE_MATRIX,
+	MATERIAL_DEFAULTS,
 	MEMORY_CONSTANTS,
 	PRODUCTION_RENDER_CONFIG,
 	INTERACTIVE_RENDER_CONFIG,
@@ -103,3 +104,30 @@ export { InteractionManager } from './managers/InteractionManager.js';
 // host needs to build UI against.
 export { renderUpscaled, SR_SCALE, SR_MAX_INPUT } from './dlss/DLSSSuperRes.js';
 export { DLSS_NR_DEFAULTS, DLSS_NR_RANGES, DLSS_NR_MAX_PIXELS } from './dlss/DLSSNeural.js';
+
+// ── Colour management ───────────────────────────────────────────────────────────────────────────
+// `app.color` is the instance a host normally uses; these are for building UI against it, and for
+// code that needs the view-transform registry without an app.
+export {
+	ColorManagement, getActiveColorManagement, setActiveColorManagement,
+	isColorManaged, DEFAULT_WORKING_SPACE, findNativeLinearSpace, canvasColorSpaceFor,
+} from './Color/ColorManagement.js';
+export { displayCanvasFit } from './Color/Displays.js';
+export {
+	VIEW_TRANSFORMS, listViewTransforms, getViewTransform, addViewTransform, removeViewTransform,
+	onRegistryChange, getRegistryVersion, buildToneMapWGSL,
+	OCIO_VIEW_BASE, MAX_TABLE_TRANSFORMS,
+} from './Color/ViewTransforms.js';
+export {
+	buildOcioView, addOcioView, addAllOcioViews,
+	DEFAULT_LUT_SIZE, DEFAULT_MIN_EV, DEFAULT_MAX_EV,
+} from './Color/OcioViews.js';
+export {
+	resolveInputSpace, textureInputSpace, setInputOverride, clearInputOverrides,
+	listInputOverrides, listFileRules, isDataTexture,
+} from './Color/InputColorSpaces.js';
+export {
+	convertColor, convertPixelsF32, convertEncodedRGBA8, applyMatrixRGBA8, extractMatrix,
+	hasColorSpace, isDataSpace, srgbToLinear, linearToSrgb,
+} from './Color/ColorSpaces.js';
+export { measureBakeError, bakeLut, makeCpuSampler } from './Color/LutBake.js';

package/src/managers/EnvironmentManager.js

@@ -17,6 +17,7 @@ import { createLogger, fmt } from '../utils/Logger.js';
 
 const log = createLogger( 'env' );
 import { ENGINE_DEFAULTS as DEFAULT_STATE } from '../EngineDefaults.js';
+import { getActiveColorManagement } from '../Color/ColorManagement.js';
 
 export class EnvironmentManager {
 
@@ -234,6 +235,25 @@ export class EnvironmentManager {
 
 		if ( ! envTex ) return;
 
+		// Before the CDF is built, so importance sampling sees the same pixels the shader will.
+		// Inert unless a working space has been adopted; the texture's own space is honoured when
+		// the host tagged it, otherwise it is taken as linear Rec.709, which is what every HDRI
+		// loader produces.
+		const cm = getActiveColorManagement();
+		if ( cm?.hasConfig ) {
+
+			try {
+
+				cm.convertTexturePixels( envTex, { space: envTex.userData?.ocioColorSpace ?? null } );
+
+			} catch ( error ) {
+
+				log.warn( `environment colour conversion failed, left in its original space: ${error.message}` );
+
+			}
+
+		}
+
 		this.environmentTexture = envTex;
 		this.envTexSize.set( envTex.image.width, envTex.image.height );