three-gpu-pathtracer 0.0.4 → 0.0.5

package/src/shader/shaderLightSampling.js

@@ -0,0 +1,87 @@
+export const shaderLightSampling = /* glsl */`
+
+struct LightSampleRec {
+	bool hit;
+	float dist;
+	vec3 direction;
+	float pdf;
+	vec3 emission;
+};
+
+LightSampleRec lightsClosestHit( sampler2D lights, uint lightCount, vec3 rayOrigin, vec3 rayDirection ) {
+
+	LightSampleRec lightSampleRec;
+	lightSampleRec.hit = false;
+
+	uint l;
+	for ( l = 0u; l < lightCount; l++ ) {
+
+		Light light = readLightInfo( lights, l );
+
+		vec3 u = light.u;
+		vec3 v = light.v;
+
+		// check for backface
+		vec3 normal = normalize( cross( u, v ) );
+		if ( dot( normal, rayDirection ) < 0.0 ) {
+			continue;
+		}
+
+		u *= 1.0 / dot(u, u);
+		v *= 1.0 / dot(v, v);
+
+		float dist;
+		if ( intersectsRectangle( light.position, normal, u, v, rayOrigin, rayDirection, dist ) ) {
+
+			if ( dist < lightSampleRec.dist || !lightSampleRec.hit ) {
+
+				lightSampleRec.hit = true;
+				lightSampleRec.dist = dist;
+				float cosTheta = dot( rayDirection, normal );
+				lightSampleRec.pdf = ( dist * dist ) / ( light.area * cosTheta );
+				lightSampleRec.emission = light.color * light.intensity;
+				lightSampleRec.direction = rayDirection;
+			}
+
+		}
+
+	}
+
+	return lightSampleRec;
+
+}
+
+LightSampleRec randomRectAreaLightSample( Light light, vec3 rayOrigin ) {
+
+	LightSampleRec lightSampleRec;
+	lightSampleRec.hit = true;
+
+	lightSampleRec.emission = light.color * light.intensity;
+
+	vec3 randomPos = light.position + light.u * ( rand() - 0.5 ) + light.v * ( rand() - 0.5 );
+	vec3 toLight = randomPos - rayOrigin;
+	float lightDistSq = dot( toLight, toLight );
+	lightSampleRec.dist = length( toLight );
+
+	vec3 direction = normalize( toLight );
+	lightSampleRec.direction = direction;
+
+	vec3 lightNormal = normalize( cross( light.u, light.v ) );
+	lightSampleRec.pdf = lightDistSq / ( light.area * dot( direction, lightNormal ) );
+
+	return lightSampleRec;
+
+}
+
+LightSampleRec randomLightSample( sampler2D lights, uint lightCount, vec3 rayOrigin ) {
+
+	// pick a random light
+	uint l = uint( rand() * float( lightCount ) );
+	Light light = readLightInfo( lights, l );
+
+	// sample the light
+	return randomRectAreaLightSample( light, rayOrigin );
+
+}
+
+`;

package/src/shader/shaderMaterialSampling.js

@@ -13,12 +13,16 @@ struct SurfaceRec {
 	vec3 emission;
 	float transmission;
 	float ior;
+	float clearcoat;
+	float clearcoatRoughness;
+	float filteredClearcoatRoughness;
 };
 
 struct SampleRec {
 	float specularPdf;
 	float pdf;
 	vec3 direction;
+	vec3 clearcoatDirection;
 	vec3 color;
 };
 
@@ -57,10 +61,10 @@ vec3 diffuseColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 // specular
 float specularPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
-	// See equation (17) in http://jcgt.org/published/0003/02/03/
+	// See equation (27) in http://jcgt.org/published/0003/02/03/
 	float filteredRoughness = surf.filteredRoughness;
 	vec3 halfVector = getHalfVector( wi, wo );
-	return ggxPDF( wi, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+	return ggxPDF( wo, halfVector, filteredRoughness ) / ( 4.0 * dot( wi, halfVector ) );
 
 }
 
@@ -214,7 +218,97 @@ vec3 transmissionColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 }
 
-float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf, out float specularPdf ) {
+// clearcoat
+float clearcoatPDF( vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	// See equation (27) in http://jcgt.org/published/0003/02/03/
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = getHalfVector( wi, wo );
+	return ggxPDF( wo, halfVector, filteredClearcoatRoughness ) / ( 4.0 * dot( wi, halfVector ) );
+
+}
+
+vec3 clearcoatDirection( vec3 wo, SurfaceRec surf ) {
+
+	// sample ggx vndf distribution which gives a new normal
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+	vec3 halfVector = ggxDirection(
+		wo,
+		filteredClearcoatRoughness,
+		filteredClearcoatRoughness,
+		rand(),
+		rand()
+	);
+
+	// apply to new ray by reflecting off the new normal
+	return - reflect( wo, halfVector );
+
+}
+
+void clearcoatColor( inout vec3 color, vec3 wo, vec3 wi, SurfaceRec surf ) {
+
+	float ior = 1.5;
+	bool frontFace = surf.frontFace;
+	float filteredClearcoatRoughness = surf.filteredClearcoatRoughness;
+
+	vec3 halfVector = getHalfVector( wo, wi );
+	float iorRatio = frontFace ? 1.0 / ior : ior;
+	float G = ggxShadowMaskG2( wi, wo, filteredClearcoatRoughness );
+	float D = ggxDistribution( halfVector, filteredClearcoatRoughness );
+
+	float F = schlickFresnelFromIor( dot( wi, halfVector ), ior );
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	bool cannotRefract = iorRatio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		F = 1.0;
+
+	}
+
+	float fClearcoat = F * D * G / ( 4.0 * abs( wi.z * wo.z ) );
+
+	color = color * ( 1.0 - surf.clearcoat * F ) + fClearcoat * surf.clearcoat * wi.z;
+
+}
+
+void getLobeWeights( vec3 wo, vec3 clearcoatWo, SurfaceRec surf, out float diffuseWeight, out float specularWeight, out float transmissionWeight, out float clearcoatWeight ) {
+
+	float ior = surf.ior;
+	float metalness = surf.metalness;
+	float transmission = surf.transmission;
+	bool frontFace = surf.frontFace;
+
+	float ratio = frontFace ? 1.0 / ior : ior;
+	float cosTheta = min( wo.z, 1.0 );
+	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
+	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
+	bool cannotRefract = ratio * sinTheta > 1.0;
+	if ( cannotRefract ) {
+
+		reflectance = 1.0;
+
+	}
+
+	float transSpecularProb = mix( reflectance, 1.0, metalness );
+	float diffSpecularProb = 0.5 + 0.5 * metalness;
+
+	clearcoatWeight = surf.clearcoat * schlickFresnel( clearcoatWo.z, 0.04 );
+	diffuseWeight = ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb ) * ( 1.0 - clearcoatWeight );
+	specularWeight = transmission * transSpecularProb + ( 1.0 - transmission ) * diffSpecularProb * ( 1.0 - clearcoatWeight );
+	transmissionWeight = transmission * ( 1.0 - transSpecularProb ) * ( 1.0 - clearcoatWeight );
+
+	float totalWeight = diffuseWeight + specularWeight + transmissionWeight + clearcoatWeight;
+	float invTotalWeight = 1.0 / totalWeight;
+
+	diffuseWeight *= invTotalWeight;
+	specularWeight *= invTotalWeight;
+	transmissionWeight *= invTotalWeight;
+	clearcoatWeight *= invTotalWeight;
+
+}
+
+float bsdfPdf( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out float specularPdf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
 
 	float ior = surf.ior;
 	float metalness = surf.metalness;
@@ -235,46 +329,82 @@ float bsdfPdf( vec3 wo, vec3 wi, SurfaceRec surf, out float specularPdf ) {
 	float spdf = 0.0;
 	float dpdf = 0.0;
 	float tpdf = 0.0;
+	float cpdf = 0.0;
 
 	if ( wi.z < 0.0 ) {
 
-		tpdf = transmissionPDF( wo, wi, surf );
+		if( transmissionWeight > 0.0 ) {
+
+			tpdf = transmissionPDF( wo, wi, surf );
+
+		}
 
 	} else {
 
-		spdf = specularPDF( wo, wi, surf );
-		dpdf = diffusePDF( wo, wi, surf );
+		if( diffuseWeight > 0.0 ) {
+
+			dpdf = diffusePDF( wo, wi, surf );
+
+		}
+
+		if( specularWeight > 0.0 ) {
+
+			spdf = specularPDF( wo, wi, surf );
+
+		}
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		cpdf = clearcoatPDF( clearcoatWo, clearcoatWi, surf );
 
 	}
 
-	float transSpecularProb = mix( reflectance, 1.0, metalness );
-	float diffSpecularProb = 0.5 + 0.5 * metalness;
 	float pdf =
-		spdf * transmission * transSpecularProb
-		+ tpdf * transmission * ( 1.0 - transSpecularProb )
-		+ spdf * ( 1.0 - transmission ) * diffSpecularProb
-		+ dpdf * ( 1.0 - transmission ) * ( 1.0 - diffSpecularProb );
+		  dpdf * diffuseWeight
+		+ spdf * specularWeight
+		+ tpdf * transmissionWeight
+		+ cpdf * clearcoatWeight;
 
 	// retrieve specular rays for the shadows flag
-	specularPdf = spdf * transmission * transSpecularProb + spdf * ( 1.0 - transmission ) * diffSpecularProb;
+	specularPdf = spdf * specularWeight + cpdf * clearcoatWeight;
 
 	return pdf;
 
 }
 
-vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
+vec3 bsdfColor( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, float diffuseWeight, float specularWeight, float transmissionWeight, float clearcoatWeight ) {
 
 	vec3 color = vec3( 0.0 );
 	if ( wi.z < 0.0 ) {
 
-		color = transmissionColor( wo, wi, surf );
+		if( transmissionWeight > 0.0 ) {
+
+			color = transmissionColor( wo, wi, surf );
+
+		}
 
 	} else {
 
-		color = diffuseColor( wo, wi, surf );
-		color *= 1.0 - surf.transmission;
+		if( diffuseWeight > 0.0 ) {
+
+			color = diffuseColor( wo, wi, surf );
+			color *= 1.0 - surf.transmission;
+
+		}
+
+		if( specularWeight > 0.0 ) {
 
-		color += specularColor( wo, wi, surf );
+			color += specularColor( wo, wi, surf );
+
+		}
+
+	}
+
+	if( clearcoatWi.z >= 0.0 && clearcoatWeight > 0.0 ) {
+
+		clearcoatColor( color, clearcoatWo, clearcoatWi, surf );
 
 	}
 
@@ -282,63 +412,89 @@ vec3 bsdfColor( vec3 wo, vec3 wi, SurfaceRec surf ) {
 
 }
 
-float bsdfResult( vec3 wo, vec3 wi, SurfaceRec surf, out vec3 color ) {
+float bsdfResult( vec3 wo, vec3 clearcoatWo, vec3 wi, vec3 clearcoatWi, SurfaceRec surf, out vec3 color ) {
+
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
 	float specularPdf;
-	color = bsdfColor( wo, wi, surf );
-	return bsdfPdf( wo, wi, surf, specularPdf );
+	color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	return bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
 }
 
-SampleRec bsdfSample( vec3 wo, SurfaceRec surf ) {
+SampleRec bsdfSample( vec3 wo, vec3 clearcoatWo, mat3 normalBasis, mat3 invBasis, mat3 clearcoatNormalBasis, mat3 clearcoatInvBasis, SurfaceRec surf ) {
 
-	float ior = surf.ior;
-	float metalness = surf.metalness;
-	float transmission = surf.transmission;
-	bool frontFace = surf.frontFace;
+	float diffuseWeight;
+	float specularWeight;
+	float transmissionWeight;
+	float clearcoatWeight;
+	getLobeWeights( wo, clearcoatWo, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
 
-	float ratio = frontFace ? 1.0 / ior : ior;
-	float cosTheta = min( wo.z, 1.0 );
-	float sinTheta = sqrt( 1.0 - cosTheta * cosTheta );
-	float reflectance = schlickFresnelFromIor( cosTheta, ratio );
-	bool cannotRefract = ratio * sinTheta > 1.0;
-	if ( cannotRefract ) {
+	float pdf[4];
+	pdf[0] = diffuseWeight;
+	pdf[1] = specularWeight;
+	pdf[2] = transmissionWeight;
+	pdf[3] = clearcoatWeight;
 
-		reflectance = 1.0;
+	float cdf[4];
+	cdf[0] = pdf[0];
+	cdf[1] = pdf[1] + cdf[0];
+	cdf[2] = pdf[2] + cdf[1];
+	cdf[3] = pdf[3] + cdf[2];
 
-	}
+	if( cdf[3] != 0.0 ) {
 
-	SampleRec result;
-	if ( rand() < transmission ) {
+		float invMaxCdf = 1.0 / cdf[3];
+		cdf[0] *= invMaxCdf;
+		cdf[1] *= invMaxCdf;
+		cdf[2] *= invMaxCdf;
+		cdf[3] *= invMaxCdf;
+
+	} else {
 
-		float specularProb = mix( reflectance, 1.0, metalness );
-		if ( rand() < specularProb ) {
+		cdf[0] = 1.0;
+		cdf[1] = 0.0;
+		cdf[2] = 0.0;
+		cdf[3] = 0.0;
 
-			result.direction = specularDirection( wo, surf );
+	}
 
-		} else {
+	vec3 wi;
+	vec3 clearcoatWi;
 
-			result.direction = transmissionDirection( wo, surf );
+	float r = rand();
+	if ( r <= cdf[0] ) {
 
-		}
+		wi = diffuseDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-	} else {
+	} else if ( r <= cdf[1] ) {
 
-		float specularProb = 0.5 + 0.5 * metalness;
-		if ( rand() < specularProb ) {
+		wi = specularDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-			result.direction = specularDirection( wo, surf );
+	} else if ( r <= cdf[2] ) {
 
-		} else {
+		wi = transmissionDirection( wo, surf );
+		clearcoatWi = normalize( clearcoatInvBasis * normalize( normalBasis * wi ) );
 
-			result.direction = diffuseDirection( wo, surf );
+	} else if ( r <= cdf[3] ) {
 
-		}
+		clearcoatWi = clearcoatDirection( clearcoatWo, surf );
+		wi = normalize( invBasis * normalize( clearcoatNormalBasis * clearcoatWi ) );
 
 	}
 
-	result.pdf = bsdfPdf( wo, result.direction, surf, result.specularPdf );
-	result.color = bsdfColor( wo, result.direction, surf );
+	SampleRec result;
+	result.pdf = bsdfPdf( wo, clearcoatWo, wi, clearcoatWi, surf, result.specularPdf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.color = bsdfColor( wo, clearcoatWo, wi, clearcoatWi, surf, diffuseWeight, specularWeight, transmissionWeight, clearcoatWeight );
+	result.direction = wi;
+	result.clearcoatDirection = clearcoatWi;
+
 	return result;
 
 }

package/src/shader/shaderStructs.js

@@ -41,6 +41,13 @@ export const shaderMaterialStructs = /* glsl */ `
 		int normalMap;
 		vec2 normalScale;
 
+		float clearcoat;
+		int clearcoatMap;
+		int clearcoatNormalMap;
+		vec2 clearcoatNormalScale;
+		float clearcoatRoughness;
+		int clearcoatRoughnessMap;
+
 		int alphaMap;
 
 		bool castShadow;
@@ -56,6 +63,9 @@ export const shaderMaterialStructs = /* glsl */ `
 		mat3 transmissionMapTransform;
 		mat3 emissiveMapTransform;
 		mat3 normalMapTransform;
+		mat3 clearcoatMapTransform;
+		mat3 clearcoatNormalMapTransform;
+		mat3 clearcoatRoughnessMapTransform;
 
 	};
 
@@ -76,7 +86,7 @@ export const shaderMaterialStructs = /* glsl */ `
 
 	Material readMaterialInfo( sampler2D tex, uint index ) {
 
-		uint i = index * 19u;
+		uint i = index * 26u;
 
 		vec4 s0 = texelFetch1D( tex, i + 0u );
 		vec4 s1 = texelFetch1D( tex, i + 1u );
@@ -85,6 +95,7 @@ export const shaderMaterialStructs = /* glsl */ `
 		vec4 s4 = texelFetch1D( tex, i + 4u );
 		vec4 s5 = texelFetch1D( tex, i + 5u );
 		vec4 s6 = texelFetch1D( tex, i + 6u );
+		vec4 s7 = texelFetch1D( tex, i + 7u );
 
 		Material m;
 		m.color = s0.rgb;
@@ -106,16 +117,23 @@ export const shaderMaterialStructs = /* glsl */ `
 		m.normalMap = int( round( s4.r ) );
 		m.normalScale = s4.gb;
 
-		m.alphaMap = int( round( s4.a ) );
+		m.clearcoat = s4.a;
+		m.clearcoatMap = int( round( s5.r ) );
+		m.clearcoatRoughness = s5.g;
+		m.clearcoatRoughnessMap = int( round( s5.b ) );
+		m.clearcoatNormalMap = int( round( s5.a ) );
+		m.clearcoatNormalScale = s6.rg;
+
+		m.alphaMap = int( round( s6.b ) );
 
-		m.opacity = s5.r;
-		m.alphaTest = s5.g;
-		m.side = s5.b;
-		m.matte = bool( s5.a );
+		m.opacity = s6.a;
+		m.alphaTest = s7.r;
+		m.side = s7.g;
+		m.matte = bool( s7.b );
 
-		m.castShadow = ! bool( s6.r );
+		m.castShadow = ! bool( s7.a );
 
-		uint firstTextureTransformIdx = i + 7u;
+		uint firstTextureTransformIdx = i + 8u;
 
 		m.mapTransform = m.map == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx);
 		m.metalnessMapTransform = m.metalnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 2u );
@@ -123,9 +141,51 @@ export const shaderMaterialStructs = /* glsl */ `
 		m.transmissionMapTransform = m.transmissionMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 6u );
 		m.emissiveMapTransform = m.emissiveMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 8u );
 		m.normalMapTransform = m.normalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 10u );
+		m.clearcoatMapTransform = m.clearcoatMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 12u );
+		m.clearcoatNormalMapTransform = m.clearcoatNormalMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 14u );
+		m.clearcoatRoughnessMapTransform = m.clearcoatRoughnessMap == - 1 ? mat3( 0 ) : readTextureTransform( tex, firstTextureTransformIdx + 16u );
 
 		return m;
 
 	}
 
 `;
+
+export const shaderLightStruct = /* glsl */ `
+	struct Light {
+
+		vec3 position;
+
+		vec3 color;
+		float intensity;
+
+		vec3 u;
+		vec3 v;
+		float area;
+
+	};
+
+	Light readLightInfo( sampler2D tex, uint index ) {
+
+		uint i = index * 4u;
+
+		vec4 s0 = texelFetch1D( tex, i + 0u );
+		vec4 s1 = texelFetch1D( tex, i + 1u );
+		vec4 s2 = texelFetch1D( tex, i + 2u );
+		vec4 s3 = texelFetch1D( tex, i + 3u );
+
+		Light l;
+		l.position = s0.rgb;
+
+		l.color = s1.rgb;
+		l.intensity = s1.a;
+
+		l.u = s2.rgb;
+		l.v = s3.rgb;
+		l.area = s3.a;
+
+		return l;
+
+	}
+
+`;

package/src/shader/shaderUtils.js

@@ -236,6 +236,47 @@ export const shaderUtils = /* glsl */`
 
 	}
 
+	// Finds the point where the ray intersects the plane defined by u and v and checks if this point
+	// falls in the bounds of the rectangle on that same plane.
+	// Plane intersection: https://lousodrome.net/blog/light/2020/07/03/intersection-of-a-ray-and-a-plane/
+	bool intersectsRectangle( vec3 center, vec3 normal, vec3 u, vec3 v, vec3 rayOrigin, vec3 rayDirection, out float dist ) {
+
+		float t = dot( center - rayOrigin, normal ) / dot( rayDirection, normal );
+
+		if ( t > EPSILON ) {
+
+			vec3 p = rayOrigin + rayDirection * t;
+			vec3 vi = p - center;
+
+			// check if p falls inside the rectangle
+			float a1 = dot( u, vi );
+			if ( abs( a1 ) <= 0.5 ) {
+
+				float a2 = dot( v, vi );
+				if ( abs( a2 ) <= 0.5 ) {
+
+					dist = t;
+					return true;
+
+				}
+
+			}
+
+		}
+
+		return false;
+
+	}
+
+	// power heuristic for multiple importance sampling
+	float misHeuristic( float a, float b ) {
+
+		float aa = a * a;
+		float bb = b * b;
+		return aa / ( aa + bb );
+
+	}
+
 	// An acos with input values bound to the range [-1, 1].
 	float acosSafe( float x ) {
 

package/src/uniforms/LightsTexture.js

@@ -0,0 +1,83 @@
+import { DataTexture, RGBAFormat, ClampToEdgeWrapping, FloatType, Vector3, Quaternion } from 'three';
+
+const LIGHT_PIXELS = 4;
+
+export class LightsTexture extends DataTexture {
+
+	constructor() {
+
+		super( new Float32Array( 4 ), 1, 1 );
+
+		this.format = RGBAFormat;
+		this.type = FloatType;
+		this.wrapS = ClampToEdgeWrapping;
+		this.wrapT = ClampToEdgeWrapping;
+		this.generateMipmaps = false;
+
+	}
+
+	updateFrom( lights ) {
+
+		let index = 0;
+		const pixelCount = lights.length * LIGHT_PIXELS;
+		const dimension = Math.ceil( Math.sqrt( pixelCount ) );
+
+		if ( this.image.width !== dimension ) {
+
+			this.dispose();
+
+			this.image.data = new Float32Array( dimension * dimension * 4 );
+			this.image.width = dimension;
+			this.image.height = dimension;
+
+		}
+
+		const floatArray = this.image.data;
+
+		const u = new Vector3();
+		const v = new Vector3();
+		const worldQuaternion = new Quaternion();
+
+		for ( let i = 0, l = lights.length; i < l; i ++ ) {
+
+			const l = lights[ i ];
+
+			// position
+			l.getWorldPosition( v );
+			floatArray[ index ++ ] = v.x;
+			floatArray[ index ++ ] = v.y;
+			floatArray[ index ++ ] = v.z;
+			index ++;
+
+			// color
+			floatArray[ index ++ ] = l.color.r;
+			floatArray[ index ++ ] = l.color.g;
+			floatArray[ index ++ ] = l.color.b;
+
+			// intensity
+			floatArray[ index ++ ] = l.intensity;
+
+			// u vector
+			l.getWorldQuaternion( worldQuaternion );
+			u.set( l.width, 0, 0 ).applyQuaternion( worldQuaternion );
+			floatArray[ index ++ ] = u.x;
+			floatArray[ index ++ ] = u.y;
+			floatArray[ index ++ ] = u.z;
+			index ++;
+
+			// v vector
+			v.set( 0, l.height, 0 ).applyQuaternion( worldQuaternion );
+			floatArray[ index ++ ] = v.x;
+			floatArray[ index ++ ] = v.y;
+			floatArray[ index ++ ] = v.z;
+
+			// area
+			floatArray[ index ++ ] = u.cross( v ).length();
+
+		}
+
+		this.needsUpdate = true;
+
+	}
+
+}