When using the 3d-text module I get this error. It seems that something is wrong with DerivedShader:
THREE.WebGLShader: gl.getShaderInfoLog() vertex
ERROR: 0:390: 'uTroikaSDFTextureSize' : redefinition
ERROR: 0:391: 'uTroikaSDFGlyphSize' : redefinition
ERROR: 0:392: 'uTroikaTotalBounds' : redefinition
ERROR: 0:393: 'uTroikaClipRect' : redefinition
ERROR: 0:394: 'uTroikaOrient' : redefinition
ERROR: 0:395: 'uTroikaUseGlyphColors' : redefinition
ERROR: 0:396: 'aTroikaGlyphBounds' : redefinition
ERROR: 0:397: 'aTroikaGlyphIndex' : redefinition
ERROR: 0:398: 'aTroikaGlyphColor' : redefinition
ERROR: 0:399: 'vTroikaSDFTextureUV' : redefinition
ERROR: 0:400: 'vTroikaGlyphUV' : redefinition
ERROR: 0:401: 'vTroikaGlyphColor' : redefinition
�1: precision highp float;
2: precision highp int;
3: #define HIGH_PRECISION
4: #define SHADER_NAME MeshBasicMaterial
5: #define TROIKA_DERIVED_MATERIAL 3
6: #define VERTEX_TEXTURES
7: #define GAMMA_FACTOR 2
8: #define MAX_BONES 0
9: #define BONE_TEXTURE
10: #define DOUBLE_SIDED
11: #define USE_LOGDEPTHBUF
12: #define USE_LOGDEPTHBUF_EXT
13: uniform mat4 modelMatrix;
14: uniform mat4 modelViewMatrix;
15: uniform mat4 projectionMatrix;
16: uniform mat4 viewMatrix;
17: uniform mat3 normalMatrix;
18: uniform vec3 cameraPosition;
19: uniform bool isOrthographic;
20: #ifdef USE_INSTANCING
21: attribute mat4 instanceMatrix;
22: #endif
23: attribute vec3 position;
24: attribute vec3 normal;
25: attribute vec2 uv;
26: #ifdef USE_TANGENT
27: attribute vec4 tangent;
28: #endif
29: #ifdef USE_COLOR
30: attribute vec3 color;
31: #endif
32: #ifdef USE_MORPHTARGETS
33: attribute vec3 morphTarget0;
34: attribute vec3 morphTarget1;
35: attribute vec3 morphTarget2;
36: attribute vec3 morphTarget3;
37: #ifdef USE_MORPHNORMALS
38: attribute vec3 morphNormal0;
39: attribute vec3 morphNormal1;
40: attribute vec3 morphNormal2;
41: attribute vec3 morphNormal3;
42: #else
43: attribute vec3 morphTarget4;
44: attribute vec3 morphTarget5;
45: attribute vec3 morphTarget6;
46: attribute vec3 morphTarget7;
47: #endif
48: #endif
49: #ifdef USE_SKINNING
50: attribute vec4 skinIndex;
51: attribute vec4 skinWeight;
52: #endif
53:
54: #define PI 3.14159265359
55: #define PI2 6.28318530718
56: #define PI_HALF 1.5707963267949
57: #define RECIPROCAL_PI 0.31830988618
58: #define RECIPROCAL_PI2 0.15915494
59: #define LOG2 1.442695
60: #define EPSILON 1e-6
61: #ifndef saturate
62: #define saturate(a) clamp( a, 0.0, 1.0 )
63: #endif
64: #define whiteComplement(a) ( 1.0 - saturate( a ) )
65: float pow2( const in float x ) { return x*x; }
66: float pow3( const in float x ) { return x*x*x; }
67: float pow4( const in float x ) { float x2 = x*x; return x2*x2; }
68: float average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }
69: highp float rand( const in vec2 troika_uv_1 ) {
70: const highp float a = 12.9898, b = 78.233, c = 43758.5453;
71: highp float dt = dot( troika_uv_1.xy, vec2( a,b ) ), sn = mod( dt, PI );
72: return fract(sin(sn) * c);
73: }
74: #ifdef HIGH_PRECISION
75: float precisionSafeLength( vec3 v ) { return length( v ); }
76: #else
77: float max3( vec3 v ) { return max( max( v.x, v.y ), v.z ); }
78: float precisionSafeLength( vec3 v ) {
79: float maxComponent = max3( abs( v ) );
80: return length( v / maxComponent ) * maxComponent;
81: }
82: #endif
83: struct IncidentLight {
84: vec3 color;
85: vec3 direction;
86: bool visible;
87: };
88: struct ReflectedLight {
89: vec3 directDiffuse;
90: vec3 directSpecular;
91: vec3 indirectDiffuse;
92: vec3 indirectSpecular;
93: };
94: struct GeometricContext {
95: vec3 troika_position_1;
96: vec3 troika_normal_1;
97: vec3 viewDir;
98: #ifdef CLEARCOAT
99: vec3 clearcoatNormal;
100: #endif
101: };
102: vec3 transformDirection( in vec3 dir, in mat4 matrix ) {
103: return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );
104: }
105: vec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {
106: return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );
107: }
108: vec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
109: float distance = dot( planeNormal, point - pointOnPlane );
110: return - distance * planeNormal + point;
111: }
112: float sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {
113: return sign( dot( point - pointOnPlane, planeNormal ) );
114: }
115: vec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {
116: return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;
117: }
118: mat3 transposeMat3( const in mat3 m ) {
119: mat3 tmp;
120: tmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );
121: tmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );
122: tmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );
123: return tmp;
124: }
125: float linearToRelativeLuminance( const in vec3 color ) {
126: vec3 weights = vec3( 0.2126, 0.7152, 0.0722 );
127: return dot( weights, color.rgb );
128: }
129: bool isPerspectiveMatrix( mat4 m ) {
130: return m[ 2 ][ 3 ] == - 1.0;
131: }
132: #ifdef USE_UV
133: #ifdef UVS_VERTEX_ONLY
134: vec2 vUv;
135: #else
136: varying vec2 vUv;
137: #endif
138: uniform mat3 uvTransform;
139: #endif
140: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
141: attribute vec2 uv2;
142: varying vec2 vUv2;
143: uniform mat3 uv2Transform;
144: #endif
145: #ifdef USE_ENVMAP
146: #if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) ||defined( PHONG )
147: #define ENV_WORLDPOS
148: #endif
149: #ifdef ENV_WORLDPOS
150:
151: varying vec3 vWorldPosition;
152: #else
153: varying vec3 vReflect;
154: uniform float refractionRatio;
155: #endif
156: #endif
157: #ifdef USE_COLOR
158: varying vec3 vColor;
159: #endif
160: #ifdef USE_FOG
161: varying float fogDepth;
162: #endif
163: #ifdef USE_MORPHTARGETS
164: uniform float morphTargetBaseInfluence;
165: #ifndef USE_MORPHNORMALS
166: uniform float morphTargetInfluences[ 8 ];
167: #else
168: uniform float morphTargetInfluences[ 4 ];
169: #endif
170: #endif
171: #ifdef USE_SKINNING
172: uniform mat4 bindMatrix;
173: uniform mat4 bindMatrixInverse;
174: #ifdef BONE_TEXTURE
175: uniform highp sampler2D boneTexture;
176: uniform int boneTextureSize;
177: mat4 getBoneMatrix( const in float i ) {
178: float j = i * 4.0;
179: float x = mod( j, float( boneTextureSize ) );
180: float y = floor( j / float( boneTextureSize ) );
181: float dx = 1.0 / float( boneTextureSize );
182: float dy = 1.0 / float( boneTextureSize );
183: y = dy * ( y + 0.5 );
184: vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );
185: vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );
186: vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );
187: vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );
188: mat4 bone = mat4( v1, v2, v3, v4 );
189: return bone;
190: }
191: #else
192: uniform mat4 boneMatrices[ MAX_BONES ];
193: mat4 getBoneMatrix( const in float i ) {
194: mat4 bone = boneMatrices[ int(i) ];
195: return bone;
196: }
197: #endif
198: #endif
199: #ifdef USE_LOGDEPTHBUF
200: #ifdef USE_LOGDEPTHBUF_EXT
201: varying float vFragDepth;
202: varying float vIsPerspective;
203: #else
204: uniform float logDepthBufFC;
205: #endif
206: #endif
207: #if 0 > 0
208: varying vec3 vClipPosition;
209: #endif
210: uniform vec3 diffuse;
211:
212:
213: uniform vec2 uTroikaSDFTextureSize;
214: uniform float uTroikaSDFGlyphSize;
215: uniform vec4 uTroikaTotalBounds;
216: uniform vec4 uTroikaClipRect;
217: uniform mat3 uTroikaOrient;
218: uniform bool uTroikaUseGlyphColors;
219: attribute vec4 aTroikaGlyphBounds;
220: attribute float aTroikaGlyphIndex;
221: attribute vec3 aTroikaGlyphColor;
222: varying vec2 vTroikaSDFTextureUV;
223: varying vec2 vTroikaGlyphUV;
224: varying vec3 vTroikaGlyphColor;
225:
226: vec3 troika_position_1;
227: vec3 troika_normal_1;
228: vec2 troika_uv_1;
229: void troikaVertexTransform1(inout vec3 troika_position_3, inout vec3 troika_normal_3, inout vec2 troika_uv_3) {
230:
231: vec4 bounds = aTroikaGlyphBounds;
232: vec4 clippedBounds = vec4(
233: clamp(bounds.xy, uTroikaClipRect.xy, uTroikaClipRect.zw),
234: clamp(bounds.zw, uTroikaClipRect.xy, uTroikaClipRect.zw)
235: );
236: vec2 clippedXY = (mix(clippedBounds.xy, clippedBounds.zw, troika_position_3.xy) - bounds.xy) / (bounds.zw - bounds.xy);
237: vTroikaGlyphUV = clippedXY.xy;
238:
239: float cols = uTroikaSDFTextureSize.x / uTroikaSDFGlyphSize;
240: vTroikaSDFTextureUV = vec2(
241: mod(aTroikaGlyphIndex, cols) + clippedXY.x,
242: floor(aTroikaGlyphIndex / cols) + clippedXY.y
243: ) * uTroikaSDFGlyphSize / uTroikaSDFTextureSize;
244:
245: troika_position_3.xy = mix(bounds.xy, bounds.zw, clippedXY);
246:
247: troika_uv_3 = vec2(
248: (troika_position_3.x - uTroikaTotalBounds.x) / (uTroikaTotalBounds.z - uTroikaTotalBounds.x),
249: (troika_position_3.y - uTroikaTotalBounds.y) / (uTroikaTotalBounds.w - uTroikaTotalBounds.y)
250: );
251:
252: troika_position_3 = uTroikaOrient * troika_position_3;
253: troika_normal_3 = uTroikaOrient * troika_normal_3;
254:
255: }
256:
257: void troikaOrigMain1() {
258: vTroikaGlyphColor = uTroikaUseGlyphColors ? aTroikaGlyphColor / 255.0 : diffuse;
259:
260: #ifdef USE_UV
261: vUv = ( uvTransform * vec3( troika_uv_1, 1 ) ).xy;
262: #endif
263: #if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )
264: vUv2 = ( uv2Transform * vec3( uv2, 1 ) ).xy;
265: #endif
266: #ifdef USE_COLOR
267: vColor.xyz = color.xyz;
268: #endif
269: #ifdef USE_SKINNING
270: mat4 boneMatX = getBoneMatrix( skinIndex.x );
271: mat4 boneMatY = getBoneMatrix( skinIndex.y );
272: mat4 boneMatZ = getBoneMatrix( skinIndex.z );
273: mat4 boneMatW = getBoneMatrix( skinIndex.w );
274: #endif
275: #ifdef USE_ENVMAP
276: vec3 objectNormal = vec3( troika_normal_1 );
277: #ifdef USE_TANGENT
278: vec3 objectTangent = vec3( tangent.xyz );
279: #endif
280: #ifdef USE_MORPHNORMALS
281: objectNormal *= morphTargetBaseInfluence;
282: objectNormal += morphNormal0 * morphTargetInfluences[ 0 ];
283: objectNormal += morphNormal1 * morphTargetInfluences[ 1 ];
284: objectNormal += morphNormal2 * morphTargetInfluences[ 2 ];
285: objectNormal += morphNormal3 * morphTargetInfluences[ 3 ];
286: #endif
287: #ifdef USE_SKINNING
288: mat4 skinMatrix = mat4( 0.0 );
289: skinMatrix += skinWeight.x * boneMatX;
290: skinMatrix += skinWeight.y * boneMatY;
291: skinMatrix += skinWeight.z * boneMatZ;
292: skinMatrix += skinWeight.w * boneMatW;
293: skinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;
294: objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;
295: #ifdef USE_TANGENT
296: objectTangent = vec4( skinMatrix * vec4( objectTangent, 0.0 ) ).xyz;
297: #endif
298: #endif
299: vec3 transformedNormal = objectNormal;
300: #ifdef USE_INSTANCING
301: mat3 m = mat3( instanceMatrix );
302: transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );
303: transformedNormal = m * transformedNormal;
304: #endif
305: transformedNormal = normalMatrix * transformedNormal;
306: #ifdef FLIP_SIDED
307: transformedNormal = - transformedNormal;
308: #endif
309: #ifdef USE_TANGENT
310: vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;
311: #ifdef FLIP_SIDED
312: transformedTangent = - transformedTangent;
313: #endif
314: #endif
315: #endif
316: vec3 transformed = vec3( troika_position_1 );
317: #ifdef USE_MORPHTARGETS
318: transformed *= morphTargetBaseInfluence;
319: transformed += morphTarget0 * morphTargetInfluences[ 0 ];
320: transformed += morphTarget1 * morphTargetInfluences[ 1 ];
321: transformed += morphTarget2 * morphTargetInfluences[ 2 ];
322: transformed += morphTarget3 * morphTargetInfluences[ 3 ];
323: #ifndef USE_MORPHNORMALS
324: transformed += morphTarget4 * morphTargetInfluences[ 4 ];
325: transformed += morphTarget5 * morphTargetInfluences[ 5 ];
326: transformed += morphTarget6 * morphTargetInfluences[ 6 ];
327: transformed += morphTarget7 * morphTargetInfluences[ 7 ];
328: #endif
329: #endif
330: #ifdef USE_SKINNING
331: vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );
332: vec4 skinned = vec4( 0.0 );
333: skinned += boneMatX * skinVertex * skinWeight.x;
334: skinned += boneMatY * skinVertex * skinWeight.y;
335: skinned += boneMatZ * skinVertex * skinWeight.z;
336: skinned += boneMatW * skinVertex * skinWeight.w;
337: transformed = ( bindMatrixInverse * skinned ).xyz;
338: #endif
339: vec4 mvPosition = vec4( transformed, 1.0 );
340: #ifdef USE_INSTANCING
341: mvPosition = instanceMatrix * mvPosition;
342: #endif
343: mvPosition = modelViewMatrix * mvPosition;
344: gl_Position = projectionMatrix * mvPosition;
345: #ifdef USE_LOGDEPTHBUF
346: #ifdef USE_LOGDEPTHBUF_EXT
347: vFragDepth = 1.0 + gl_Position.w;
348: vIsPerspective = float( isPerspectiveMatrix( projectionMatrix ) );
349: #else
350: if ( isPerspectiveMatrix( projectionMatrix ) ) {
351: gl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;
352: gl_Position.z *= gl_Position.w;
353: }
354: #endif
355: #endif
356: #if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )
357: vec4 worldPosition = vec4( transformed, 1.0 );
358: #ifdef USE_INSTANCING
359: worldPosition = instanceMatrix * worldPosition;
360: #endif
361: worldPosition = modelMatrix * worldPosition;
362: #endif
363: #if 0 > 0
364: vClipPosition = - mvPosition.xyz;
365: #endif
366: #ifdef USE_ENVMAP
367: #ifdef ENV_WORLDPOS
368: vWorldPosition = worldPosition.xyz;
369: #else
370: vec3 cameraToVertex;
371: if ( isOrthographic ) {
372: cameraToVertex = normalize( vec3( - viewMatrix[ 0 ][ 2 ], - viewMatrix[ 1 ][ 2 ], - viewMatrix[ 2 ][ 2 ] ) );
373: } else {
374: cameraToVertex = normalize( worldPosition.xyz - cameraPosition );
375: }
376: vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );
377: #ifdef ENVMAP_MODE_REFLECTION
378: vReflect = reflect( cameraToVertex, worldNormal );
379: #else
380: vReflect = refract( cameraToVertex, worldNormal, refractionRatio );
381: #endif
382: #endif
383: #endif
384: #ifdef USE_FOG
385: fogDepth = -mvPosition.z;
386: #endif
387: }
388:
389:
390: uniform vec2 uTroikaSDFTextureSize;
391: uniform float uTroikaSDFGlyphSize;
392: uniform vec4 uTroikaTotalBounds;
393: uniform vec4 uTroikaClipRect;
394: uniform mat3 uTroikaOrient;
395: uniform bool uTroikaUseGlyphColors;
396: attribute vec4 aTroikaGlyphBounds;
397: attribute float aTroikaGlyphIndex;
398: attribute vec3 aTroikaGlyphColor;
399: varying vec2 vTroikaSDFTextureUV;
400: varying vec2 vTroikaGlyphUV;
401: varying vec3 vTroikaGlyphColor;
402:
403: vec3 troika_position_3;
404: vec3 troika_normal_3;
405: vec2 troika_uv_3;
406: void troikaVertexTransform3(inout vec3 position, inout vec3 normal, inout vec2 uv) {
407:
408: vec4 bounds = aTroikaGlyphBounds;
409: vec4 clippedBounds = vec4(
410: clamp(bounds.xy, uTroikaClipRect.xy, uTroikaClipRect.zw),
411: clamp(bounds.zw, uTroikaClipRect.xy, uTroikaClipRect.zw)
412: );
413: vec2 clippedXY = (mix(clippedBounds.xy, clippedBounds.zw, position.xy) - bounds.xy) / (bounds.zw - bounds.xy);
414: vTroikaGlyphUV = clippedXY.xy;
415:
416: float cols = uTroikaSDFTextureSize.x / uTroikaSDFGlyphSize;
417: vTroikaSDFTextureUV = vec2(
418: mod(aTroikaGlyphIndex, cols) + clippedXY.x,
419: floor(aTroikaGlyphIndex / cols) + clippedXY.y
420: ) * uTroikaSDFGlyphSize / uTroikaSDFTextureSize;
421:
422: position.xy = mix(bounds.xy, bounds.zw, clippedXY);
423:
424: uv = vec2(
425: (position.x - uTroikaTotalBounds.x) / (uTroikaTotalBounds.z - uTroikaTotalBounds.x),
426: (position.y - uTroikaTotalBounds.y) / (uTroikaTotalBounds.w - uTroikaTotalBounds.y)
427: );
428:
429: position = uTroikaOrient * position;
430: normal = uTroikaOrient * normal;
431:
432: }
433:
434: void troikaOrigMain3() {
435:
436: troika_position_1 = vec3(troika_position_3);
437: troika_normal_1 = vec3(troika_normal_3);
438: troika_uv_1 = vec2(troika_uv_3);
439: troikaVertexTransform1(troika_position_1, troika_normal_1, troika_uv_1);
440:
441:
442: troikaOrigMain1();
443:
444: }
445: void main() {
446:
447: troika_position_3 = vec3(position);
448: troika_normal_3 = vec3(normal);
449: troika_uv_3 = vec2(uv);
450: troikaVertexTransform3(troika_position_3, troika_normal_3, troika_uv_3);
451:
452:
453: troikaOrigMain3();
454:
455: }