/**
|
*
|
* Supersample Anti-Aliasing Render Pass
|
*
|
* @author bhouston / http://clara.io/
|
*
|
* This manual approach to SSAA re-renders the scene ones for each sample with camera jitter and accumulates the results.
|
*
|
* References: https://en.wikipedia.org/wiki/Supersampling
|
*
|
*/
|
|
THREE.SSAARenderPass = function (scene, camera, clearColor, clearAlpha) {
|
|
THREE.Pass.call(this);
|
|
this.scene = scene;
|
this.camera = camera;
|
|
this.sampleLevel = 4; // specified as n, where the number of samples is 2^n, so sampleLevel = 4, is 2^4 samples, 16.
|
this.unbiased = true;
|
|
// as we need to clear the buffer in this pass, clearColor must be set to something, defaults to black.
|
this.clearColor = (clearColor !== undefined) ? clearColor : 0x000000;
|
this.clearAlpha = (clearAlpha !== undefined) ? clearAlpha : 0;
|
|
if (THREE.CopyShader === undefined) console.error("THREE.SSAARenderPass relies on THREE.CopyShader");
|
|
var copyShader = THREE.CopyShader;
|
this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
|
|
this.copyMaterial = new THREE.ShaderMaterial({
|
uniforms: this.copyUniforms,
|
vertexShader: copyShader.vertexShader,
|
fragmentShader: copyShader.fragmentShader,
|
premultipliedAlpha: true,
|
transparent: true,
|
blending: THREE.AdditiveBlending,
|
depthTest: false,
|
depthWrite: false
|
});
|
|
this.camera2 = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
|
this.scene2 = new THREE.Scene();
|
this.quad2 = new THREE.Mesh(new THREE.PlaneBufferGeometry(2, 2), this.copyMaterial);
|
this.quad2.frustumCulled = false; // Avoid getting clipped
|
this.scene2.add(this.quad2);
|
|
};
|
|
THREE.SSAARenderPass.prototype = Object.assign(Object.create(THREE.Pass.prototype), {
|
|
constructor: THREE.SSAARenderPass,
|
|
dispose: function () {
|
|
if (this.sampleRenderTarget) {
|
|
this.sampleRenderTarget.dispose();
|
this.sampleRenderTarget = null;
|
|
}
|
|
},
|
|
setSize: function (width, height) {
|
|
if (this.sampleRenderTarget) this.sampleRenderTarget.setSize(width, height);
|
|
},
|
|
render: function (renderer, writeBuffer, readBuffer) {
|
|
if (!this.sampleRenderTarget) {
|
|
this.sampleRenderTarget = new THREE.WebGLRenderTarget(readBuffer.width, readBuffer.height, { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBAFormat });
|
this.sampleRenderTarget.texture.name = "SSAARenderPass.sample";
|
|
}
|
|
var jitterOffsets = THREE.SSAARenderPass.JitterVectors[Math.max(0, Math.min(this.sampleLevel, 5))];
|
|
var autoClear = renderer.autoClear;
|
renderer.autoClear = false;
|
|
var oldClearColor = renderer.getClearColor().getHex();
|
var oldClearAlpha = renderer.getClearAlpha();
|
|
var baseSampleWeight = 1.0 / jitterOffsets.length;
|
var roundingRange = 1 / 32;
|
this.copyUniforms["tDiffuse"].value = this.sampleRenderTarget.texture;
|
|
var width = readBuffer.width, height = readBuffer.height;
|
|
// render the scene multiple times, each slightly jitter offset from the last and accumulate the results.
|
for (var i = 0; i < jitterOffsets.length; i++) {
|
|
var jitterOffset = jitterOffsets[i];
|
|
if (this.camera.setViewOffset) {
|
|
this.camera.setViewOffset(width, height,
|
jitterOffset[0] * 0.0625, jitterOffset[1] * 0.0625, // 0.0625 = 1 / 16
|
width, height);
|
|
}
|
|
var sampleWeight = baseSampleWeight;
|
|
if (this.unbiased) {
|
|
// the theory is that equal weights for each sample lead to an accumulation of rounding errors.
|
// The following equation varies the sampleWeight per sample so that it is uniformly distributed
|
// across a range of values whose rounding errors cancel each other out.
|
|
var uniformCenteredDistribution = (-0.5 + (i + 0.5) / jitterOffsets.length);
|
sampleWeight += roundingRange * uniformCenteredDistribution;
|
|
}
|
|
this.copyUniforms["opacity"].value = sampleWeight;
|
renderer.setClearColor(this.clearColor, this.clearAlpha);
|
renderer.render(this.scene, this.camera, this.sampleRenderTarget, true);
|
|
if (i === 0) {
|
|
renderer.setClearColor(0x000000, 0.0);
|
|
}
|
|
renderer.render(this.scene2, this.camera2, this.renderToScreen ? null : writeBuffer, (i === 0));
|
|
}
|
|
if (this.camera.clearViewOffset) this.camera.clearViewOffset();
|
|
renderer.autoClear = autoClear;
|
renderer.setClearColor(oldClearColor, oldClearAlpha);
|
|
}
|
|
});
|
|
|
// These jitter vectors are specified in integers because it is easier.
|
// I am assuming a [-8,8) integer grid, but it needs to be mapped onto [-0.5,0.5)
|
// before being used, thus these integers need to be scaled by 1/16.
|
//
|
// Sample patterns reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476218%28v=vs.85%29.aspx?f=255&MSPPError=-2147217396
|
THREE.SSAARenderPass.JitterVectors = [
|
[
|
[0, 0]
|
],
|
[
|
[4, 4], [-4, -4]
|
],
|
[
|
[-2, -6], [6, -2], [-6, 2], [2, 6]
|
],
|
[
|
[1, -3], [-1, 3], [5, 1], [-3, -5],
|
[-5, 5], [-7, -1], [3, 7], [7, -7]
|
],
|
[
|
[1, 1], [-1, -3], [-3, 2], [4, -1],
|
[-5, -2], [2, 5], [5, 3], [3, -5],
|
[-2, 6], [0, -7], [-4, -6], [-6, 4],
|
[-8, 0], [7, -4], [6, 7], [-7, -8]
|
],
|
[
|
[-4, -7], [-7, -5], [-3, -5], [-5, -4],
|
[-1, -4], [-2, -2], [-6, -1], [-4, 0],
|
[-7, 1], [-1, 2], [-6, 3], [-3, 3],
|
[-7, 6], [-3, 6], [-5, 7], [-1, 7],
|
[5, -7], [1, -6], [6, -5], [4, -4],
|
[2, -3], [7, -2], [1, -1], [4, -1],
|
[2, 1], [6, 2], [0, 4], [4, 4],
|
[2, 5], [7, 5], [5, 6], [3, 7]
|
]
|
];
|
