Three.js OutlineEffect错误启用雾时，着色器无效错误：0:204:'；雾深'；：重新定义

我正在尝试使用示例（）中的OutlineEffect.js构建一个3.js场景。这很有效

但是，当我将雾添加到场景中时，会出现此错误，并且轮廓不会显示：

THREE.WebGLProgram: shader error:  1282 gl.VALIDATE_STATUS false gl.getProgramInfoLog invalid shaders ERROR: 0:204: 'fogDepth' : redefinition

守则的有关部分（我希望）是：

如果这个问题太天真，我道歉；我不是一个真正的js或threejs人，我是一个数据科学家，试图找到解决这个问题的方法

提前感谢您的建议

编辑：

日志中的更多信息：

第一个错误是

three.module.js:16963 three.WebGLShader:Shader无法编译。

具有以下源转储：

THREE.WebGLShader: gl.getShaderInfoLog() vertex ERROR: 0:178: 'fogDepth' : redefinition
 1: precision highp float;
2: precision highp int;
3: #define SHADER_NAME ShaderMaterial
4: #define VERTEX_TEXTURES
5: #define GAMMA_FACTOR 2
6: #define MAX_BONES 0
7: #define USE_FOG
8: #define BONE_TEXTURE
9: #define FLIP_SIDED
10: uniform mat4 modelMatrix;
11: uniform mat4 modelViewMatrix;
12: uniform mat4 projectionMatrix;
13: uniform mat4 viewMatrix;
14: uniform mat3 normalMatrix;
15: uniform vec3 cameraPosition;
16: attribute vec3 position;
17: attribute vec3 normal;
18: attribute vec2 uv;
19: #ifdef USE_COLOR
20:     attribute vec3 color;
21: #endif
22: #ifdef USE_MORPHTARGETS
23:     attribute vec3 morphTarget0;
24:     attribute vec3 morphTarget1;
25:     attribute vec3 morphTarget2;
26:     attribute vec3 morphTarget3;
27:     #ifdef USE_MORPHNORMALS
28:         attribute vec3 morphNormal0;
29:         attribute vec3 morphNormal1;
30:         attribute vec3 morphNormal2;
31:         attribute vec3 morphNormal3;
32:     #else
33:         attribute vec3 morphTarget4;
34:         attribute vec3 morphTarget5;
35:         attribute vec3 morphTarget6;
36:         attribute vec3 morphTarget7;
37:     #endif
38: #endif
39: #ifdef USE_SKINNING
40:     attribute vec4 skinIndex;
41:     attribute vec4 skinWeight;
42: #endif
43: 
44: #define PI 3.14159265359
45: #define PI2 6.28318530718
46: #define PI_HALF 1.5707963267949
47: #define RECIPROCAL_PI 0.31830988618
48: #define RECIPROCAL_PI2 0.15915494
49: #define LOG2 1.442695
50: #define EPSILON 1e-6
51: #define saturate(a) clamp( a, 0.0, 1.0 )
52: #define whiteCompliment(a) ( 1.0 - saturate( a ) )
53: float pow2( const in float x ) { return x*x; }
54: float pow3( const in float x ) { return x*x*x; }
55: float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
56: float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
57: highp float rand( const in vec2 uv ) {
58:     const highp float a = 12.9898, b = 78.233, c = 43758.5453;
59:     highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
60:     return fract(sin(sn) * c);
61: }
62: struct IncidentLight {
63:     vec3 color;
64:     vec3 direction;
65:     bool visible;
66: };
67: struct ReflectedLight {
68:     vec3 directDiffuse;
69:     vec3 directSpecular;
70:     vec3 indirectDiffuse;
71:     vec3 indirectSpecular;
72: };
73: struct GeometricContext {
74:     vec3 position;
75:     vec3 normal;
76:     vec3 viewDir;
77: };
78: vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
79:     return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
80: }
81: vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
82:     return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
83: }
84: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
85:     float distance = dot( planeNormal, point - pointOnPlane );
86:     return - distance * planeNormal + point;
87: }
88: float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
89:     return sign( dot( point - pointOnPlane, planeNormal ) );
90: }
91: vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
92:     return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
93: }
94: mat3 transposeMat3( const in mat3 m ) {
95:     mat3 tmp;
96:     tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
97:     tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
98:     tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
99:     return tmp;
100: }
101: float linearToRelativeLuminance( const in vec3 color ) {
102:    vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
103:    return dot( weights, color.rgb );
104: }
105: 
106: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
107:    varying vec2 vUv;
108:    uniform mat3 uvTransform;
109: #endif
110: 
111: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
112:    attribute vec2 uv2;
113:    varying vec2 vUv2;
114: #endif
115: #ifdef USE_ENVMAP
116:    #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
117:        varying vec3 vWorldPosition;
118:    #else
119:        varying vec3 vReflect;
120:        uniform float refractionRatio;
121:    #endif
122: #endif
123: 
124: #ifdef USE_COLOR
125:    varying vec3 vColor;
126: #endif
127: #ifdef USE_FOG
128:   varying float fogDepth;
129: #endif
130: 
131: #ifdef USE_MORPHTARGETS
132:    #ifndef USE_MORPHNORMALS
133:    uniform float morphTargetInfluences[ 8 ];
134:    #else
135:    uniform float morphTargetInfluences[ 4 ];
136:    #endif
137: #endif
138: #ifdef USE_SKINNING
139:    uniform mat4 bindMatrix;
140:    uniform mat4 bindMatrixInverse;
141:    #ifdef BONE_TEXTURE
142:        uniform sampler2D boneTexture;
143:        uniform int boneTextureSize;
144:        mat4 getBoneMatrix( const in float i ) {
145:            float j = i * 4.0;
146:            float x = mod( j, float( boneTextureSize ) );
147:            float y = floor( j / float( boneTextureSize ) );
148:            float dx = 1.0 / float( boneTextureSize );
149:            float dy = 1.0 / float( boneTextureSize );
150:            y = dy * ( y + 0.5 );
151:            vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
152:            vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
153:            vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
154:            vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
155:            mat4 bone = mat4( v1, v2, v3, v4 );
156:            return bone;
157:        }
158:    #else
159:        uniform mat4 boneMatrices[ MAX_BONES ];
160:        mat4 getBoneMatrix( const in float i ) {
161:            mat4 bone = boneMatrices[ int(i) ];
162:            return bone;
163:        }
164:    #endif
165: #endif
166: 
167: #ifdef USE_LOGDEPTHBUF
168:    #ifdef USE_LOGDEPTHBUF_EXT
169:        varying float vFragDepth;
170:    #endif
171:    uniform float logDepthBufFC;
172: #endif
173: #if 0 > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
174:    varying vec3 vViewPosition;
175: #endif
176: 
177: #ifdef USE_FOG
178:   varying float fogDepth;
179: #endif
180: 
181: uniform float outlineThickness;
182: vec4 calculateOutline( vec4 pos, vec3 objectNormal, vec4 skinned ) {
183:    float thickness = outlineThickness;
184:    const float ratio = 1.0;
185:    vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + objectNormal, 1.0 );
186:    vec4 norm = normalize( pos - pos2 );
187:    return pos + norm * thickness * pos.w * ratio;
188: }
189: void main() {
190: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
191:    vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
192: #endif
193: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
194:    vUv2 = uv2;
195: #endif
196: #ifdef USE_COLOR
197:    vColor.xyz = color.xyz;
198: #endif
199: #ifdef USE_SKINNING
200:    mat4 boneMatX = getBoneMatrix( skinIndex.x );
201:    mat4 boneMatY = getBoneMatrix( skinIndex.y );
202:    mat4 boneMatZ = getBoneMatrix( skinIndex.z );
203:    mat4 boneMatW = getBoneMatrix( skinIndex.w );
204: #endif
205:    #ifdef USE_ENVMAP
206: 
207: vec3 objectNormal = vec3( normal );
208: 
209: #ifdef USE_MORPHNORMALS
210:    objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];
211:    objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];
212:    objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];
213:    objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];
214: #endif
215: 
216: #ifdef USE_SKINNING
217:    mat4 skinMatrix = mat4( 0.0 );
218:    skinMatrix += skinWeight.x * boneMatX;
219:    skinMatrix += skinWeight.y * boneMatY;
220:    skinMatrix += skinWeight.z * boneMatZ;
221:    skinMatrix += skinWeight.w * boneMatW;
222:    skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;
223:    objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
224: #endif
225: 
226: vec3 transformedNormal = normalMatrix * objectNormal;
227: #ifdef FLIP_SIDED
228:    transformedNormal = - transformedNormal;
229: #endif
230: 
231:    #endif
232: 
233: vec3 transformed = vec3( position );
234: 
235: #ifdef USE_MORPHTARGETS
236:    transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];
237:    transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];
238:    transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];
239:    transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];
240:    #ifndef USE_MORPHNORMALS
241:    transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];
242:    transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];
243:    transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];
244:    transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];
245:    #endif
246: #endif
247: 
248: #ifdef USE_SKINNING
249:    vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
250:    vec4 skinned = vec4( 0.0 );
251:    skinned += boneMatX * skinVertex * skinWeight.x;
252:    skinned += boneMatY * skinVertex * skinWeight.y;
253:    skinned += boneMatZ * skinVertex * skinWeight.z;
254:    skinned += boneMatW * skinVertex * skinWeight.w;
255:    transformed = ( bindMatrixInverse * skinned ).xyz;
256: #endif
257: 
258: vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
259: gl_Position = projectionMatrix * mvPosition;
260: 
261: #ifdef USE_LOGDEPTHBUF
262:    #ifdef USE_LOGDEPTHBUF_EXT
263:        vFragDepth = 1.0 + gl_Position.w;
264:    #else
265:        gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
266:        gl_Position.z *= gl_Position.w;
267:    #endif
268: #endif
269: 
270: #if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )
271:    vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );
272: #endif
273: 
274: #if 0 > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
275:    vViewPosition = - mvPosition.xyz;
276: #endif
277: 
278: #ifdef USE_ENVMAP
279:    #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
280:        vWorldPosition = worldPosition.xyz;
281:    #else
282:        vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
283:        vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
284:        #ifdef ENVMAP_MODE_REFLECTION
285:            vReflect = reflect( cameraToVertex, worldNormal );
286:        #else
287:            vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
288:        #endif
289:    #endif
290: #endif
291: 
292: 
293: #ifdef USE_FOG
294: fogDepth = -mvPosition.z;
295: #endif
296: #if ! defined( LAMBERT ) && ! defined( PHONG ) && ! defined( TOON ) && ! defined( PHYSICAL )
297:    #ifndef USE_ENVMAP
298:        vec3 objectNormal = normalize( normal );
299:    #endif
300: #endif
301: #ifdef FLIP_SIDED
302:    objectNormal = -objectNormal;
303: #endif
304: #ifdef DECLARE_TRANSFORMED
305:    vec3 transformed = vec3( position );
306: #endif
307: gl_Position = calculateOutline( gl_Position, objectNormal, vec4( transformed, 1.0 ) );
308: 
309: #ifdef USE_FOG
310: fogDepth = -mvPosition.z;
311: #endif
312: }

该代码不在OutlineEffect源代码中。但OutlineEffect的工作方式包括以下代码，其中使用正则表达式重新定义顶点着色器代码：

var vertexShader = originalVertexShader
            // put vertexShaderChunk right before "void main() {...}"
            .replace( /void\s+main\s*\(\s*\)/, vertexShaderChunk + '\nvoid main()' )
            // put vertexShaderChunk2 the end of "void main() {...}"
            // Note: here assums originalVertexShader ends with "}" of "void main() {...}"
            .replace( /\}\s*$/, vertexShaderChunk2 + '\n}' )
            // remove any light related lines
            // Note: here is very sensitive to originalVertexShader
            // TODO: consider safer way
            .replace( /#include\s+<[\w_]*light[\w_]*>/g, '' );

---

听起来可能是图书馆里的一个bug。您是否正在运行最新的THREE.js？您可以发布一个运行的示例来查看吗？可能是示例中的一个bug：正如@manthrax所指出的，这可能是大纲示例中的一个bug。大纲的事情是扩展着色器（并且使用了大量的正则表达式），所以它可能没有正确解释这一点。发布一个运行的示例将非常非常困难。我唯一需要做的是我们的内部原型，这是保密的，我只是没有js/threejs的经验来构建一个可重复性最低的示例。我仅限于修补我的代码，并尝试应用我在示例中看到的代码。我确实在OutlineEffect代码中看到了，我没有看到任何对

fogDepth

的引用，但是它导入了大量与fog相关的标题。我希望这个例子的作者能看到这个问题……嗯，任何东西都可以在你的

3.Scene

中，这是一个非常复杂的例子。它使用每个材质创建特定的着色器。我只看到有一块会提到这一点，但我看不出有任何方式可以让它与其他东西相冲突。你的场景中有哪些材质？

var vertexShader = originalVertexShader
            // put vertexShaderChunk right before "void main() {...}"
            .replace( /void\s+main\s*\(\s*\)/, vertexShaderChunk + '\nvoid main()' )
            // put vertexShaderChunk2 the end of "void main() {...}"
            // Note: here assums originalVertexShader ends with "}" of "void main() {...}"
            .replace( /\}\s*$/, vertexShaderChunk2 + '\n}' )
            // remove any light related lines
            // Note: here is very sensitive to originalVertexShader
            // TODO: consider safer way
            .replace( /#include\s+<[\w_]*light[\w_]*>/g, '' );

gl.getShaderInfoLog() vertex ERROR: 0:204: 'fogDepth' : redefinition
 1: precision highp float;
2: precision highp int;
3: #define SHADER_NAME ShaderMaterial
4: #define VERTEX_TEXTURES
5: #define GAMMA_FACTOR 2
6: #define MAX_BONES 0
7: #define USE_FOG
8: #define BONE_TEXTURE
9: #define FLIP_SIDED
10: uniform mat4 modelMatrix;
11: uniform mat4 modelViewMatrix;
12: uniform mat4 projectionMatrix;
13: uniform mat4 viewMatrix;
14: uniform mat3 normalMatrix;
15: uniform vec3 cameraPosition;
16: attribute vec3 position;
17: attribute vec3 normal;
18: attribute vec2 uv;
19: #ifdef USE_COLOR
20:     attribute vec3 color;
21: #endif
22: #ifdef USE_MORPHTARGETS
23:     attribute vec3 morphTarget0;
24:     attribute vec3 morphTarget1;
25:     attribute vec3 morphTarget2;
26:     attribute vec3 morphTarget3;
27:     #ifdef USE_MORPHNORMALS
28:         attribute vec3 morphNormal0;
29:         attribute vec3 morphNormal1;
30:         attribute vec3 morphNormal2;
31:         attribute vec3 morphNormal3;
32:     #else
33:         attribute vec3 morphTarget4;
34:         attribute vec3 morphTarget5;
35:         attribute vec3 morphTarget6;
36:         attribute vec3 morphTarget7;
37:     #endif
38: #endif
39: #ifdef USE_SKINNING
40:     attribute vec4 skinIndex;
41:     attribute vec4 skinWeight;
42: #endif
43: 
44: #define PHONG
45: varying vec3 vViewPosition;
46: #ifndef FLAT_SHADED
47:     varying vec3 vNormal;
48: #endif
49: #define PI 3.14159265359
50: #define PI2 6.28318530718
51: #define PI_HALF 1.5707963267949
52: #define RECIPROCAL_PI 0.31830988618
53: #define RECIPROCAL_PI2 0.15915494
54: #define LOG2 1.442695
55: #define EPSILON 1e-6
56: #define saturate(a) clamp( a, 0.0, 1.0 )
57: #define whiteCompliment(a) ( 1.0 - saturate( a ) )
58: float pow2( const in float x ) { return x*x; }
59: float pow3( const in float x ) { return x*x*x; }
60: float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
61: float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
62: highp float rand( const in vec2 uv ) {
63:     const highp float a = 12.9898, b = 78.233, c = 43758.5453;
64:     highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );
65:     return fract(sin(sn) * c);
66: }
67: struct IncidentLight {
68:     vec3 color;
69:     vec3 direction;
70:     bool visible;
71: };
72: struct ReflectedLight {
73:     vec3 directDiffuse;
74:     vec3 directSpecular;
75:     vec3 indirectDiffuse;
76:     vec3 indirectSpecular;
77: };
78: struct GeometricContext {
79:     vec3 position;
80:     vec3 normal;
81:     vec3 viewDir;
82: };
83: vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
84:     return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
85: }
86: vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
87:     return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
88: }
89: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
90:     float distance = dot( planeNormal, point - pointOnPlane );
91:     return - distance * planeNormal + point;
92: }
93: float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
94:     return sign( dot( point - pointOnPlane, planeNormal ) );
95: }
96: vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
97:     return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
98: }
99: mat3 transposeMat3( const in mat3 m ) {
100:    mat3 tmp;
101:    tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
102:    tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
103:    tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
104:    return tmp;
105: }
106: float linearToRelativeLuminance( const in vec3 color ) {
107:    vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
108:    return dot( weights, color.rgb );
109: }
110: 
111: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
112:    varying vec2 vUv;
113:    uniform mat3 uvTransform;
114: #endif
115: 
116: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
117:    attribute vec2 uv2;
118:    varying vec2 vUv2;
119: #endif
120: #ifdef USE_DISPLACEMENTMAP
121:    uniform sampler2D displacementMap;
122:    uniform float displacementScale;
123:    uniform float displacementBias;
124: #endif
125: 
126: #ifdef USE_ENVMAP
127:    #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
128:        varying vec3 vWorldPosition;
129:    #else
130:        varying vec3 vReflect;
131:        uniform float refractionRatio;
132:    #endif
133: #endif
134: 
135: #ifdef USE_COLOR
136:    varying vec3 vColor;
137: #endif
138: #ifdef USE_FOG
139:   varying float fogDepth;
140: #endif
141: 
142: #ifdef USE_MORPHTARGETS
143:    #ifndef USE_MORPHNORMALS
144:    uniform float morphTargetInfluences[ 8 ];
145:    #else
146:    uniform float morphTargetInfluences[ 4 ];
147:    #endif
148: #endif
149: #ifdef USE_SKINNING
150:    uniform mat4 bindMatrix;
151:    uniform mat4 bindMatrixInverse;
152:    #ifdef BONE_TEXTURE
153:        uniform sampler2D boneTexture;
154:        uniform int boneTextureSize;
155:        mat4 getBoneMatrix( const in float i ) {
156:            float j = i * 4.0;
157:            float x = mod( j, float( boneTextureSize ) );
158:            float y = floor( j / float( boneTextureSize ) );
159:            float dx = 1.0 / float( boneTextureSize );
160:            float dy = 1.0 / float( boneTextureSize );
161:            y = dy * ( y + 0.5 );
162:            vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
163:            vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
164:            vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
165:            vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
166:            mat4 bone = mat4( v1, v2, v3, v4 );
167:            return bone;
168:        }
169:    #else
170:        uniform mat4 boneMatrices[ MAX_BONES ];
171:        mat4 getBoneMatrix( const in float i ) {
172:            mat4 bone = boneMatrices[ int(i) ];
173:            return bone;
174:        }
175:    #endif
176: #endif
177: 
178: #ifdef USE_SHADOWMAP
179:    #if 1 > 0
180:        uniform mat4 directionalShadowMatrix[ 1 ];
181:        varying vec4 vDirectionalShadowCoord[ 1 ];
182:    #endif
183:    #if 0 > 0
184:        uniform mat4 spotShadowMatrix[ 0 ];
185:        varying vec4 vSpotShadowCoord[ 0 ];
186:    #endif
187:    #if 4 > 0
188:        uniform mat4 pointShadowMatrix[ 4 ];
189:        varying vec4 vPointShadowCoord[ 4 ];
190:    #endif
191: #endif
192: 
193: #ifdef USE_LOGDEPTHBUF
194:    #ifdef USE_LOGDEPTHBUF_EXT
195:        varying float vFragDepth;
196:    #endif
197:    uniform float logDepthBufFC;
198: #endif
199: #if 0 > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
200:    varying vec3 vViewPosition;
201: #endif
202: 
203: #ifdef USE_FOG
204:   varying float fogDepth;
205: #endif
206: 
207: uniform float outlineThickness;
208: vec4 calculateOutline( vec4 pos, vec3 objectNormal, vec4 skinned ) {
209:    float thickness = outlineThickness;
210:    const float ratio = 1.0;
211:    vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + objectNormal, 1.0 );
212:    vec4 norm = normalize( pos - pos2 );
213:    return pos + norm * thickness * pos.w * ratio;
214: }
215: void main() {
216: #if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )
217:    vUv = ( uvTransform * vec3( uv, 1 ) ).xy;
218: #endif
219: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
220:    vUv2 = uv2;
221: #endif
222: #ifdef USE_COLOR
223:    vColor.xyz = color.xyz;
224: #endif
225: 
226: vec3 objectNormal = vec3( normal );
227: 
228: #ifdef USE_MORPHNORMALS
229:    objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];
230:    objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];
231:    objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];
232:    objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];
233: #endif
234: 
235: #ifdef USE_SKINNING
236:    mat4 boneMatX = getBoneMatrix( skinIndex.x );
237:    mat4 boneMatY = getBoneMatrix( skinIndex.y );
238:    mat4 boneMatZ = getBoneMatrix( skinIndex.z );
239:    mat4 boneMatW = getBoneMatrix( skinIndex.w );
240: #endif
241: #ifdef USE_SKINNING
242:    mat4 skinMatrix = mat4( 0.0 );
243:    skinMatrix += skinWeight.x * boneMatX;
244:    skinMatrix += skinWeight.y * boneMatY;
245:    skinMatrix += skinWeight.z * boneMatZ;
246:    skinMatrix += skinWeight.w * boneMatW;
247:    skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;
248:    objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
249: #endif
250: 
251: vec3 transformedNormal = normalMatrix * objectNormal;
252: #ifdef FLIP_SIDED
253:    transformedNormal = - transformedNormal;
254: #endif
255: 
256: #ifndef FLAT_SHADED
257:    vNormal = normalize( transformedNormal );
258: #endif
259: 
260: vec3 transformed = vec3( position );
261: 
262: #ifdef USE_MORPHTARGETS
263:    transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];
264:    transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];
265:    transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];
266:    transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];
267:    #ifndef USE_MORPHNORMALS
268:    transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];
269:    transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];
270:    transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];
271:    transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];
272:    #endif
273: #endif
274: 
275: #ifdef USE_SKINNING
276:    vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
277:    vec4 skinned = vec4( 0.0 );
278:    skinned += boneMatX * skinVertex * skinWeight.x;
279:    skinned += boneMatY * skinVertex * skinWeight.y;
280:    skinned += boneMatZ * skinVertex * skinWeight.z;
281:    skinned += boneMatW * skinVertex * skinWeight.w;
282:    transformed = ( bindMatrixInverse * skinned ).xyz;
283: #endif
284: 
285: #ifdef USE_DISPLACEMENTMAP
286:    transformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );
287: #endif
288: 
289: vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );
290: gl_Position = projectionMatrix * mvPosition;
291: 
292: #ifdef USE_LOGDEPTHBUF
293:    #ifdef USE_LOGDEPTHBUF_EXT
294:        vFragDepth = 1.0 + gl_Position.w;
295:    #else
296:        gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
297:        gl_Position.z *= gl_Position.w;
298:    #endif
299: #endif
300: 
301: #if 0 > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )
302:    vViewPosition = - mvPosition.xyz;
303: #endif
304: 
305:    vViewPosition = - mvPosition.xyz;
306: #if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )
307:    vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );
308: #endif
309: 
310: #ifdef USE_ENVMAP
311:    #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )
312:        vWorldPosition = worldPosition.xyz;
313:    #else
314:        vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
315:        vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
316:        #ifdef ENVMAP_MODE_REFLECTION
317:            vReflect = reflect( cameraToVertex, worldNormal );
318:        #else
319:            vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
320:        #endif
321:    #endif
322: #endif
323: 
324: #ifdef USE_SHADOWMAP
325:    #if 1 > 0
326:    
327:        vDirectionalShadowCoord[ 0 ] = directionalShadowMatrix[ 0 ] * worldPosition;
328:    
329:    #endif
330:    #if 0 > 0
331:    
332:    #endif
333:    #if 4 > 0
334:    
335:        vPointShadowCoord[ 0 ] = pointShadowMatrix[ 0 ] * worldPosition;
336:    
337:        vPointShadowCoord[ 1 ] = pointShadowMatrix[ 1 ] * worldPosition;
338:    
339:        vPointShadowCoord[ 2 ] = pointShadowMatrix[ 2 ] * worldPosition;
340:    
341:        vPointShadowCoord[ 3 ] = pointShadowMatrix[ 3 ] * worldPosition;
342:    
343:    #endif
344: #endif
345: 
346: 
347: #ifdef USE_FOG
348: fogDepth = -mvPosition.z;
349: #endif
350: #if ! defined( LAMBERT ) && ! defined( PHONG ) && ! defined( TOON ) && ! defined( PHYSICAL )
351:    #ifndef USE_ENVMAP
352:        vec3 objectNormal = normalize( normal );
353:    #endif
354: #endif
355: #ifdef FLIP_SIDED
356:    objectNormal = -objectNormal;
357: #endif
358: #ifdef DECLARE_TRANSFORMED
359:    vec3 transformed = vec3( position );
360: #endif
361: gl_Position = calculateOutline( gl_Position, objectNormal, vec4( transformed, 1.0 ) );
362: 
363: #ifdef USE_FOG
364: fogDepth = -mvPosition.z;
365: #endif
366: }