// 選擇模型、顯示外邊框
THREE.OutlinePass = function ( resolution, scene, camera, selectedObjects ) {
//場景、相機
this.renderScene = scene;
this.renderCamera = camera;
//要選擇的對象
this.selectedObjects = selectedObjects !== undefined ? selectedObjects : [];
//可是區域的顏色、隱藏區域的顏色
this.visibleEdgeColor = new THREE.Color( 1, 1, 1 );
this.hiddenEdgeColor = new THREE.Color( 0.1, 0.04, 0.02 );
this.edgeGlow = 0.0;
this.usePatternTexture = false;
this.edgeThickness = 1.0; //邊緣大小
this.edgeStrength = 3.0;
this.downSampleRatio = 2;
this.pulsePeriod = 0;
THREE.Pass.call( this );
//分辨率
this.resolution = ( resolution !== undefined ) ? new THREE.Vector2( resolution.x, resolution.y ) : new THREE.Vector2( 256, 256 );
//紋理格式
var pars = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBAFormat };
//
var resx = Math.round( this.resolution.x / this.downSampleRatio );
var resy = Math.round( this.resolution.y / this.downSampleRatio );
this.maskBufferMaterial = new THREE.MeshBasicMaterial( { color: 0xffffff } );
this.maskBufferMaterial.side = THREE.DoubleSide;
this.renderTargetMaskBuffer = new THREE.WebGLRenderTarget( this.resolution.x, this.resolution.y, pars );
this.renderTargetMaskBuffer.texture.name = "OutlinePass.mask";
this.renderTargetMaskBuffer.texture.generateMipmaps = false;
this.depthMaterial = new THREE.MeshDepthMaterial();
this.depthMaterial.side = THREE.DoubleSide;
this.depthMaterial.depthPacking = THREE.RGBADepthPacking;
this.depthMaterial.blending = THREE.NoBlending;
this.prepareMaskMaterial = this.getPrepareMaskMaterial();
this.prepareMaskMaterial.side = THREE.DoubleSide;
this.prepareMaskMaterial.fragmentShader = replaceDepthToViewZ( this.prepareMaskMaterial.fragmentShader, this.renderCamera );
this.renderTargetDepthBuffer = new THREE.WebGLRenderTarget( this.resolution.x, this.resolution.y, pars );
this.renderTargetDepthBuffer.texture.name = "OutlinePass.depth";
this.renderTargetDepthBuffer.texture.generateMipmaps = false;
this.renderTargetMaskDownSampleBuffer = new THREE.WebGLRenderTarget( resx, resy, pars );
this.renderTargetMaskDownSampleBuffer.texture.name = "OutlinePass.depthDownSample";
this.renderTargetMaskDownSampleBuffer.texture.generateMipmaps = false;
this.renderTargetBlurBuffer1 = new THREE.WebGLRenderTarget( resx, resy, pars );
this.renderTargetBlurBuffer1.texture.name = "OutlinePass.blur1";
this.renderTargetBlurBuffer1.texture.generateMipmaps = false;
this.renderTargetBlurBuffer2 = new THREE.WebGLRenderTarget( Math.round( resx / 2 ), Math.round( resy / 2 ), pars );
this.renderTargetBlurBuffer2.texture.name = "OutlinePass.blur2";
this.renderTargetBlurBuffer2.texture.generateMipmaps = false;
this.edgeDetectionMaterial = this.getEdgeDetectionMaterial();
this.renderTargetEdgeBuffer1 = new THREE.WebGLRenderTarget( resx, resy, pars );
this.renderTargetEdgeBuffer1.texture.name = "OutlinePass.edge1";
this.renderTargetEdgeBuffer1.texture.generateMipmaps = false;
this.renderTargetEdgeBuffer2 = new THREE.WebGLRenderTarget( Math.round( resx / 2 ), Math.round( resy / 2 ), pars );
this.renderTargetEdgeBuffer2.texture.name = "OutlinePass.edge2";
this.renderTargetEdgeBuffer2.texture.generateMipmaps = false;
var MAX_EDGE_THICKNESS = 4; //最大邊緣大小
var MAX_EDGE_GLOW = 4;
//水平模糊濾鏡
this.separableBlurMaterial1 = this.getSeperableBlurMaterial( MAX_EDGE_THICKNESS );
this.separableBlurMaterial1.uniforms[ "texSize" ].value = new THREE.Vector2( resx, resy );
this.separableBlurMaterial1.uniforms[ "kernelRadius" ].value = 1;
//垂直模糊濾鏡
this.separableBlurMaterial2 = this.getSeperableBlurMaterial( MAX_EDGE_GLOW );
this.separableBlurMaterial2.uniforms[ "texSize" ].value = new THREE.Vector2( Math.round( resx / 2 ), Math.round( resy / 2 ) );
this.separableBlurMaterial2.uniforms[ "kernelRadius" ].value = MAX_EDGE_GLOW;
// Overlay material
this.overlayMaterial = this.getOverlayMaterial();
// copy material
if ( THREE.CopyShader === undefined )
console.error( "THREE.OutlinePass relies on THREE.CopyShader" );
var copyShader = THREE.CopyShader;
this.copyUniforms = THREE.UniformsUtils.clone( copyShader.uniforms );
this.copyUniforms[ "opacity" ].value = 1.0;
this.materialCopy = new THREE.ShaderMaterial( {
uniforms: this.copyUniforms,
vertexShader: copyShader.vertexShader,
fragmentShader: copyShader.fragmentShader,
blending: THREE.NoBlending, //禁用混合
depthTest: false, //關閉深度測試
depthWrite: false, //關閉深度寫
transparent: true //設置透明
} );
this.enabled = true;
this.needsSwap = false;
this.oldClearColor = new THREE.Color();
this.oldClearAlpha = 1;
this.camera = new THREE.OrthographicCamera( - 1, 1, 1, - 1, 0, 1 ); //創建正交投影
this.scene = new THREE.Scene(); //創建新的場景
this.quad = new THREE.Mesh( new THREE.PlaneBufferGeometry( 2, 2 ), null ); //平面幾何數據
this.quad.frustumCulled = false; // Avoid getting clipped //關閉cpu剔除
this.scene.add( this.quad ); //添加窗口四邊形到場景
this.tempPulseColor1 = new THREE.Color();
this.tempPulseColor2 = new THREE.Color();
this.textureMatrix = new THREE.Matrix4();
function replaceDepthToViewZ( string, camera ) {
var type = camera.isPerspectiveCamera ? 'perspective' : 'orthographic';
return string.replace( /DEPTH_TO_VIEW_Z/g, type + 'DepthToViewZ' );
}
};
THREE.OutlinePass.prototype = Object.assign( Object.create( THREE.Pass.prototype ), {
constructor: THREE.OutlinePass,
dispose: function () {
this.renderTargetMaskBuffer.dispose();
this.renderTargetDepthBuffer.dispose();
this.renderTargetMaskDownSampleBuffer.dispose();
this.renderTargetBlurBuffer1.dispose();
this.renderTargetBlurBuffer2.dispose();
this.renderTargetEdgeBuffer1.dispose();
this.renderTargetEdgeBuffer2.dispose();
},
setSize: function ( width, height ) {
this.renderTargetMaskBuffer.setSize( width, height );
var resx = Math.round( width / this.downSampleRatio );
var resy = Math.round( height / this.downSampleRatio );
this.renderTargetMaskDownSampleBuffer.setSize( resx, resy );
this.renderTargetBlurBuffer1.setSize( resx, resy );
this.renderTargetEdgeBuffer1.setSize( resx, resy );
this.separableBlurMaterial1.uniforms[ "texSize" ].value = new THREE.Vector2( resx, resy );
resx = Math.round( resx / 2 );
resy = Math.round( resy / 2 );
this.renderTargetBlurBuffer2.setSize( resx, resy );
this.renderTargetEdgeBuffer2.setSize( resx, resy );
this.separableBlurMaterial2.uniforms[ "texSize" ].value = new THREE.Vector2( resx, resy );
},
//改變選擇物體的可見性
changeVisibilityOfSelectedObjects: function ( bVisible ) {
function gatherSelectedMeshesCallBack( object ) {
if ( object.isMesh ) {
if ( bVisible ) {
object.visible = object.userData.oldVisible;
delete object.userData.oldVisible;
} else {
object.userData.oldVisible = object.visible;
object.visible = bVisible;
}
}
}
for ( var i = 0; i < this.selectedObjects.length; i ++ ) {
var selectedObject = this.selectedObjects[ i ];
selectedObject.traverse( gatherSelectedMeshesCallBack );
}
},
//改變沒有選擇的物體的可見性
changeVisibilityOfNonSelectedObjects: function ( bVisible ) {
var selectedMeshes = [];
function gatherSelectedMeshesCallBack( object ) {
if ( object.isMesh ) selectedMeshes.push( object );
}
for ( var i = 0; i < this.selectedObjects.length; i ++ ) {
var selectedObject = this.selectedObjects[ i ];
selectedObject.traverse( gatherSelectedMeshesCallBack );
}
function VisibilityChangeCallBack( object ) {
if ( object.isMesh || object.isLine || object.isSprite ) {
var bFound = false;
for ( var i = 0; i < selectedMeshes.length; i ++ ) {
var selectedObjectId = selectedMeshes[ i ].id;
if ( selectedObjectId === object.id ) {
bFound = true;
break;
}
}
if ( ! bFound ) {
var visibility = object.visible;
if ( ! bVisible || object.bVisible ) object.visible = bVisible;
object.bVisible = visibility;
}
}
}
this.renderScene.traverse( VisibilityChangeCallBack );
},
//設置屏幕取深度的矩陣
updateTextureMatrix: function () {
this.textureMatrix.set( 0.5, 0.0, 0.0, 0.5,
0.0, 0.5, 0.0, 0.5,
0.0, 0.0, 0.5, 0.5,
0.0, 0.0, 0.0, 1.0 ); //將ndc座標[-1~1]轉化到[0~1]範圍
this.textureMatrix.multiply( this.renderCamera.projectionMatrix ); //投影空間
this.textureMatrix.multiply( this.renderCamera.matrixWorldInverse ); //視圖空間
},
//渲染
render: function ( renderer, writeBuffer, readBuffer, deltaTime, maskActive ) {
if ( this.selectedObjects.length > 0 ) {
//保存老的渲染設置【顏色、透明度、自動清除狀態】
this.oldClearColor.copy( renderer.getClearColor() );
this.oldClearAlpha = renderer.getClearAlpha();
var oldAutoClear = renderer.autoClear;
renderer.autoClear = false;
//屏幕模板測試
if ( maskActive ) renderer.context.disable( renderer.context.STENCIL_TEST );
//設置新的清除顏色
renderer.setClearColor( 0xffffff, 1 );
// Make selected objects invisible
//隱藏要選擇的模型
this.changeVisibilityOfSelectedObjects( false );
//保存背景
var currentBackground = this.renderScene.background;
this.renderScene.background = null; //不設置背景
// 1. Draw Non Selected objects in the depth buffer
// 渲染背景的深度
this.renderScene.overrideMaterial = this.depthMaterial;
renderer.setRenderTarget( this.renderTargetDepthBuffer );
renderer.clear();
renderer.render( this.renderScene, this.renderCamera );
// Make selected objects visible
//顯示選擇的物體
this.changeVisibilityOfSelectedObjects( true );
// Update Texture Matrix for Depth compare
//更新紋理矩陣【深度轉換 模型視圖變換、投影變換、屏幕座標轉換】
this.updateTextureMatrix();
// Make non selected objects invisible, and draw only the selected objects, by comparing the depth buffer of non selected objects
//隱藏不可見物體
this.changeVisibilityOfNonSelectedObjects( false );
//根據不可見物體的深度，設置可見物體的深度
this.renderScene.overrideMaterial = this.prepareMaskMaterial;
this.prepareMaskMaterial.uniforms[ "cameraNearFar" ].value = new THREE.Vector2( this.renderCamera.near, this.renderCamera.far );
this.prepareMaskMaterial.uniforms[ "depthTexture" ].value = this.renderTargetDepthBuffer.texture;
this.prepareMaskMaterial.uniforms[ "textureMatrix" ].value = this.textureMatrix;
renderer.setRenderTarget( this.renderTargetMaskBuffer );
renderer.clear();
renderer.render( this.renderScene, this.renderCamera );
this.renderScene.overrideMaterial = null;
//設置背景物體可見
this.changeVisibilityOfNonSelectedObjects( true );
//重置原來的背景
this.renderScene.background = currentBackground;
// 2. Downsample to Half resolution
// 下采樣到一半的分辨率
this.quad.material = this.materialCopy;
this.copyUniforms[ "tDiffuse" ].value = this.renderTargetMaskBuffer.texture; //經過選中物體和未選中物體深度比較後的紋理
renderer.setRenderTarget( this.renderTargetMaskDownSampleBuffer ); //設置下采樣的渲染目標
renderer.clear();//清空下采樣渲染目標
renderer.render( this.scene, this.camera ); //渲染四邊形，填充屏幕
this.tempPulseColor1.copy( this.visibleEdgeColor ); //設置選中物體中可見部分的顏色 脈衝
this.tempPulseColor2.copy( this.hiddenEdgeColor ); //設置選中物體中不可見部分的顏色 脈衝
if ( this.pulsePeriod > 0 ) {
var scalar = ( 1 + 0.25 ) / 2 + Math.cos( performance.now() * 0.01 / this.pulsePeriod ) * ( 1.0 - 0.25 ) / 2;
this.tempPulseColor1.multiplyScalar( scalar );
this.tempPulseColor2.multiplyScalar( scalar );
}
// 3. Apply Edge Detection Pass //使用邊緣監測
this.quad.material = this.edgeDetectionMaterial;
this.edgeDetectionMaterial.uniforms[ "maskTexture" ].value = this.renderTargetMaskDownSampleBuffer.texture; //設置下采樣的渲染目標
this.edgeDetectionMaterial.uniforms[ "texSize" ].value = new THREE.Vector2( this.renderTargetMaskDownSampleBuffer.width, this.renderTargetMaskDownSampleBuffer.height );
this.edgeDetectionMaterial.uniforms[ "visibleEdgeColor" ].value = this.tempPulseColor1; //設置可見部分的顏色
this.edgeDetectionMaterial.uniforms[ "hiddenEdgeColor" ].value = this.tempPulseColor2; //設置不可見部分的顏色
renderer.setRenderTarget( this.renderTargetEdgeBuffer1 ); //設置邊緣監測的渲染目標
renderer.clear(); //清空邊緣監測的渲染目標
renderer.render( this.scene, this.camera ); //渲染四邊形，填充屏幕
// 4. Apply Blur on Half res
// 在下采樣紋理中應用模糊
this.quad.material = this.separableBlurMaterial1;
this.separableBlurMaterial1.uniforms[ "colorTexture" ].value = this.renderTargetEdgeBuffer1.texture; //邊緣檢測後的紋理
this.separableBlurMaterial1.uniforms[ "direction" ].value = THREE.OutlinePass.BlurDirectionX; //水平方向的模糊
this.separableBlurMaterial1.uniforms[ "kernelRadius" ].value = this.edgeThickness; //模糊半徑
renderer.setRenderTarget( this.renderTargetBlurBuffer1 );
renderer.clear();
renderer.render( this.scene, this.camera );
this.separableBlurMaterial1.uniforms[ "colorTexture" ].value = this.renderTargetBlurBuffer1.texture; //水平模糊後的紋理
this.separableBlurMaterial1.uniforms[ "direction" ].value = THREE.OutlinePass.BlurDirectionY; //垂直方向的模糊
renderer.setRenderTarget( this.renderTargetEdgeBuffer1 ); //模糊半徑
renderer.clear();
renderer.render( this.scene, this.camera );
// Apply Blur on quarter res
this.quad.material = this.separableBlurMaterial2;
this.separableBlurMaterial2.uniforms[ "colorTexture" ].value = this.renderTargetEdgeBuffer1.texture; //水平擴大上次的模糊範圍
this.separableBlurMaterial2.uniforms[ "direction" ].value = THREE.OutlinePass.BlurDirectionX;
renderer.setRenderTarget( this.renderTargetBlurBuffer2 );
renderer.clear();
renderer.render( this.scene, this.camera );
this.separableBlurMaterial2.uniforms[ "colorTexture" ].value = this.renderTargetBlurBuffer2.texture; //垂直擴大上次的模糊範圍
this.separableBlurMaterial2.uniforms[ "direction" ].value = THREE.OutlinePass.BlurDirectionY;
renderer.setRenderTarget( this.renderTargetEdgeBuffer2 );
renderer.clear();
renderer.render( this.scene, this.camera );
// Blend it additively over the input texture
this.quad.material = this.overlayMaterial;
this.overlayMaterial.uniforms[ "maskTexture" ].value = this.renderTargetMaskBuffer.texture; //深度比較後的紋理
this.overlayMaterial.uniforms[ "edgeTexture1" ].value = this.renderTargetEdgeBuffer1.texture; //邊緣水平模糊後的紋理
this.overlayMaterial.uniforms[ "edgeTexture2" ].value = this.renderTargetEdgeBuffer2.texture; //邊緣垂直模糊後的紋理
this.overlayMaterial.uniforms[ "patternTexture" ].value = this.patternTexture; //填充圖案紋理
this.overlayMaterial.uniforms[ "edgeStrength" ].value = this.edgeStrength; //內邊緣的強度
this.overlayMaterial.uniforms[ "edgeGlow" ].value = this.edgeGlow; //外邊緣的顏色
this.overlayMaterial.uniforms[ "usePatternTexture" ].value = this.usePatternTexture; //不使用圖案填充
if ( maskActive ) renderer.context.enable( renderer.context.STENCIL_TEST ); //恢復模板測試
renderer.setRenderTarget( readBuffer ); //恢復渲染緩衝
renderer.render( this.scene, this.camera ); //渲染四邊形，合併背景
renderer.setClearColor( this.oldClearColor, this.oldClearAlpha ); //恢復清空顏色和透明度
renderer.autoClear = oldAutoClear; //恢復自動清空
}
if ( this.renderToScreen ) { //
this.quad.material = this.materialCopy;
this.copyUniforms[ "tDiffuse" ].value = readBuffer.texture;
renderer.setRenderTarget( null );
renderer.render( this.scene, this.camera );
}
},
//獲取邊緣遮罩層
getPrepareMaskMaterial: function () {
return new THREE.ShaderMaterial( {
uniforms: {
"depthTexture": { value: null }, //背景的深度
"cameraNearFar": { value: new THREE.Vector2( 0.5, 0.5 ) }, //相機的近裁切、遠裁切面
"textureMatrix": { value: new THREE.Matrix4() } //紋理投影矩陣
},
vertexShader: [
'varying vec4 projTexCoord;', //投影紋理座標【將來會轉換爲屏幕座標】
'varying vec4 vPosition;',
'uniform mat4 textureMatrix;',
'void main() {',
' vPosition = modelViewMatrix * vec4( position, 1.0 );', //相機空間座標
' vec4 worldPosition = modelMatrix * vec4( position, 1.0 );', //世界座標
' projTexCoord = textureMatrix * worldPosition;', //世界座標經過 視圖變換、投影變換、視口變換後轉換爲屏幕的像素座標
' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
'}'
].join( '\n' ),
fragmentShader: [
'#include <packing>',
'varying vec4 vPosition;',
'varying vec4 projTexCoord;',
'uniform sampler2D depthTexture;',
'uniform vec2 cameraNearFar;',
'void main() {',
' float depth = unpackRGBAToDepth(texture2DProj( depthTexture, projTexCoord ));', //還原背景深度
' float viewZ = - DEPTH_TO_VIEW_Z( depth, cameraNearFar.x, cameraNearFar.y );', //轉換深度到視圖空間
' float depthTest = (-vPosition.z > viewZ) ? 1.0 : 0.0;', //比較背景深度和選擇物體的深度，選擇的物體比背景深度大返回1，否則返回0
' gl_FragColor = vec4(0.0, depthTest, 1.0, 1.0);', //深度比較後的結果使用紋理的g通道存儲
'}'
].join( '\n' )
} );
},
//邊緣監測材質
getEdgeDetectionMaterial: function () {
return new THREE.ShaderMaterial( {
uniforms: {
"maskTexture": { value: null }, //遮罩紋理 深度比較後的紋理
"texSize": { value: new THREE.Vector2( 0.5, 0.5 ) }, //遮罩紋理大小
"visibleEdgeColor": { value: new THREE.Vector3( 1.0, 1.0, 1.0 ) }, //可見部分的顏色
"hiddenEdgeColor": { value: new THREE.Vector3( 1.0, 1.0, 1.0 ) }, //不可見部分的顏色
},
vertexShader:
"varying vec2 vUv;\n\
void main() {\n\
vUv = uv;\n\
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\
}",
fragmentShader:[
'varying vec2 vUv;',
'uniform sampler2D maskTexture;',
'uniform vec2 texSize;',
'uniform vec3 visibleEdgeColor;',
'uniform vec3 hiddenEdgeColor;',
'void main() {',
'vec2 invSize = 1.0 / texSize;',
'vec4 uvOffset = vec4(1.0, 0.0, 0.0, 1.0) * vec4(invSize, invSize);', //uv偏移
'vec4 c1 = texture2D( maskTexture, vUv + uvOffset.xy);', //右偏移一個像素
'vec4 c2 = texture2D( maskTexture, vUv - uvOffset.xy);', //左偏移一個像素
'vec4 c3 = texture2D( maskTexture, vUv + uvOffset.yw);', //上偏移一個像素
'vec4 c4 = texture2D( maskTexture, vUv - uvOffset.yw);', //下偏移一個像素
'float diff1 = (c1.r - c2.r)*0.5;', //邊緣檢測 填充背景用的是0xffffff, 填充選擇物體時用的是vec4(0.0, depthTest, 1.0, 1.0)
'float diff2 = (c3.r - c4.r)*0.5;', //邊緣檢測
'float d = length( vec2(diff1, diff2) );', //
'float a1 = min(c1.g, c2.g);', //獲取最小的深度
'float a2 = min(c3.g, c4.g);', //獲取最小的深度
'float visibilityFactor = min(a1, a2);', //獲取最小的深度
'vec3 edgeColor = 1.0 - visibilityFactor > 0.001 ? visibleEdgeColor : hiddenEdgeColor;', //根據深度紋理設置可見、不可見部分的顏色
'gl_FragColor = vec4(edgeColor, 1.0) * vec4(d);', //顏色值 * 深度變化
'}'
].join( '\n' )
} );
},
getSeperableBlurMaterial: function ( maxRadius ) {
return new THREE.ShaderMaterial( {
defines: {
"MAX_RADIUS": maxRadius, //模糊半徑
},
uniforms: {
"colorTexture": { value: null }, //邊緣檢測後紋理
"texSize": { value: new THREE.Vector2( 0.5, 0.5 ) }, //邊緣檢測後紋理大小
"direction": { value: new THREE.Vector2( 0.5, 0.5 ) }, //模糊方向
"kernelRadius": { value: 1.0 } //模糊權重矩陣
},
vertexShader:[
'varying vec2 vUv;',
'void main() {',
' vUv = uv;',
' gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
'}'].join( '\n' ),
fragmentShader:[
'#include <common>',
'varying vec2 vUv;',
'uniform sampler2D colorTexture;',
'uniform vec2 texSize;',
'uniform vec2 direction;',
'uniform float kernelRadius;',
'float gaussianPdf(in float x, in float sigma) {',
' return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;',
'}',
'void main() {',
' vec2 invSize = 1.0 / texSize;',
' float weightSum = gaussianPdf(0.0, kernelRadius);', //權重和
' vec3 diffuseSum = texture2D( colorTexture, vUv).rgb * weightSum;', //
' vec2 delta = direction * invSize * kernelRadius/float(MAX_RADIUS);', //模糊方向 * 像素偏移 * 模糊權重
' vec2 uvOffset = delta;',
' for( int i = 1; i <= MAX_RADIUS; i ++ ) {', //遍歷像素周圍【水平或者垂直方向】的像素，計算模糊結果
' float w = gaussianPdf(uvOffset.x, kernelRadius);', //計算權重
' vec3 sample1 = texture2D( colorTexture, vUv + uvOffset).rgb;', //採樣像素
' vec3 sample2 = texture2D( colorTexture, vUv - uvOffset).rgb;', //採樣像素
' diffuseSum += ((sample1 + sample2) * w);', //合併採樣 * 權重
' weightSum += (2.0 * w);', //權重的和
' uvOffset += delta;', //範圍一步一步的擴大
' }',
' gl_FragColor = vec4(diffuseSum/weightSum, 1.0);', //結果平均化
'}'
].join( '\n' ),
} );
},
getOverlayMaterial: function () {
return new THREE.ShaderMaterial( {
uniforms: {
"maskTexture": { value: null }, //選擇物體的遮罩紋理
"edgeTexture1": { value: null }, //水平邊緣檢測模糊後的紋理
"edgeTexture2": { value: null }, //垂直邊緣檢測模糊後的紋理
"patternTexture": { value: null }, //填充的圖案
"edgeStrength": { value: 1.0 }, //邊緣的強度
"edgeGlow": { value: 1.0 }, //外邊緣的顏色
"usePatternTexture": { value: 0.0 } //開啓圖案填充
},
vertexShader:
"varying vec2 vUv;\n\
void main() {\n\
vUv = uv;\n\
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n\
}",
fragmentShader:[
'varying vec2 vUv;',
'uniform sampler2D maskTexture;',
'uniform sampler2D edgeTexture1;',
'uniform sampler2D edgeTexture2;',
'uniform sampler2D patternTexture;',
'uniform float edgeStrength;',
'uniform float edgeGlow;',
'uniform bool usePatternTexture;',
'void main() {',
'vec4 edgeValue1 = texture2D(edgeTexture1, vUv);',
'vec4 edgeValue2 = texture2D(edgeTexture2, vUv);',
'vec4 maskColor = texture2D(maskTexture, vUv);',
'vec4 patternColor = texture2D(patternTexture, 6.0 * vUv);', //使用6倍的圖案密度填充
'float visibilityFactor = 1.0 - maskColor.g > 0.0 ? 1.0 : 0.5;', //可見部分使用0.5的顏色權重
'vec4 edgeValue = edgeValue1 + edgeValue2 * edgeGlow;', //邊緣的顏色，內邊緣使用edgeValue1， 外邊緣使用edgeValue2 * edgeGlow
'vec4 finalColor = edgeStrength * maskColor.r * edgeValue;', //顏色強度 * 邊緣標誌 * 邊緣的顏色
'if(usePatternTexture)', //使用圖案填充
' finalColor += + visibilityFactor * (1.0 - maskColor.r) * (1.0 - patternColor.r);', //可見部分的權重 * 選擇物體的區域 * 圖案
'gl_FragColor = finalColor;',
'}'
].join( '\n' ),
blending: THREE.AdditiveBlending,
depthTest: false,
depthWrite: false,
transparent: true //混合背景
} );
}
} );
THREE.OutlinePass.BlurDirectionX = new THREE.Vector2( 1.0, 0.0 );
THREE.OutlinePass.BlurDirectionY = new THREE.Vector2( 0.0, 1.0 );
