Глюки текстурных координат

uniform vec3 lightPos_1;
uniform vec3 lightDir_1;
uniform vec3 lightPos_2;
uniform vec3 viewPos;

uniform mat4 lightMatrix;
uniform mat4 lightMatrix2;

varying vec2 vTexCoord;
varying vec3 vLightVec_1;
varying vec3 vLightDir_1;
varying vec3 vLightVec_2;
varying vec3 vViewPos;

varying vec4 lpos;
varying vec4 lpos2;

void main(void)
{
   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

   vec4 vViewMatrix = (gl_ModelViewMatrix * gl_Vertex);  
   
   lpos  = lightMatrix * vViewMatrix ;
   lpos2 = lightMatrix2 * vViewMatrix;

   vTexCoord = vec2(gl_MultiTexCoord0);

   vec3 n = gl_NormalMatrix *  gl_Normal;
   vec3 t = gl_NormalMatrix *  gl_MultiTexCoord1.xyz;
   vec3 b = gl_NormalMatrix *  (cross(gl_Normal,gl_MultiTexCoord1.xyz) * gl_MultiTexCoord1.w);;

   mat3 tbnMatrix = mat3(t.x,b.x,n.x,
                         t.y,b.y,n.y,
                         t.z,b.z,n.z);

   vec3 fvObjectPosition = vec3(gl_ModelViewMatrix   * gl_Vertex);
   //Light 1
   vec3 tempVec = lightPos_1 - fvObjectPosition;
   vLightVec_1 = tbnMatrix * tempVec;

   tempVec = lightDir_1 - fvObjectPosition;
   vLightDir_1 = tbnMatrix * tempVec;

   //Light2
   tempVec = lightPos_2 - fvObjectPosition;
   vLightVec_2 = tbnMatrix * tempVec;

   //All sample
   tempVec = viewPos - fvObjectPosition;
   vViewPos = tbnMatrix * tempVec;
              
}

uniform float spread;
uniform float sharpness;

uniform sampler2D BumpMap;
uniform sampler2D BaseMap;
uniform sampler2DShadow shadowMap;
uniform sampler2DShadow shadowMap2;

uniform vec4 fvAmbient_1;
uniform vec4 fvSpecular_1;
uniform vec4 fvDiffuse_1;

uniform vec4 fvAmbient_2;
uniform vec4 fvSpecular_2;
uniform vec4 fvDiffuse_2;

varying vec3 vLightVec_1;
varying vec3 vLightDir_1;
varying vec3 vLightVec_2;
varying vec2 vTexCoord;
varying vec3 vViewPos;

varying vec4 lpos;
varying vec4 lpos2;

float saturate( float inValue)
{
   return clamp(inValue, 0.0, 1.0);
}

float CalculateShadow(sampler2DShadow sh,float size,vec4 l)
{
   vec3 smcoord = l.xyz / l.w;
   float shadow = 0.0;
   shadow += shadow2D(sh, smcoord).x;
  
   return shadow;
}


void main(void)
{

   vec4  base =           texture2D(BaseMap    , vTexCoord ).xyzw;
   vec3  bump = normalize(texture2D(BumpMap   , vTexCoord ).xyz * 2.0 - 1.0);
   vec3  fvNormal         = ( bump);


   float Shadow1 = CalculateShadow(shadowMap,1024.0,lpos);
   float Shadow2 = CalculateShadow(shadowMap2,2048.0,lpos2);

   
   //Light 1
   float fSpot_1     = saturate(sharpness * pow(saturate(dot(normalize(vLightVec_1), -normalize(vLightDir_1))), spread));

   vec3  fvLightDirection_1 = normalize( vLightVec_1 );
   float fNDotL_1           = dot( fvNormal, fvLightDirection_1 );

   vec3  fvReflection_1     = normalize( ( ( 2.0 * fvNormal ) * fNDotL_1 ) - fvLightDirection_1 );
   vec3  fvViewDirection_1  = normalize( vViewPos );
   float fRDotV_1           = max( 0.0, dot( fvReflection_1, fvViewDirection_1 ) );
   
   vec4  fvTotalAmbient_1   = fvAmbient_1 * base;
   vec4  fvTotalDiffuse_1   = fvDiffuse_1 * fNDotL_1 * base;
   vec4  fvTotalSpecular_1  = fvSpecular_1 * ( pow( fRDotV_1, 5.0 ) );
   
   
   vec4  fvTotalColor_1     = fvTotalAmbient_1 + (((fvTotalDiffuse_1 + fvTotalSpecular_1) * fSpot_1 ) * Shadow1);

   //Light 2
   vec3  fvLightDirection_2 = normalize(vLightVec_2);

   float fNDotL_2           = dot( fvNormal, fvLightDirection_2 );

   vec3  fvReflection_2     = normalize( ( ( 2.0 * fvNormal ) * fNDotL_2 ) - fvLightDirection_2 );
   vec3  fvViewDirection_2  = normalize( vViewPos );
   float fRDotV_2           = max( 0.0, dot( fvReflection_2, fvViewDirection_2 ) );
   
   vec4  fvTotalAmbient_2   = fvAmbient_2 * base;
   vec4  fvTotalDiffuse_2   = fvDiffuse_2 * fNDotL_2 * base;
   vec4  fvTotalSpecular_2  = fvSpecular_2 * ( pow( fRDotV_2, 5.0 ) );
   vec4  fvTotalColor_2     = fvTotalAmbient_2 + ((fvTotalDiffuse_2 + fvTotalSpecular_2) * Shadow2);




  gl_FragColor = (fvTotalColor_1 + fvTotalColor_2) ;

}