anchor.diff:  vec3 fresnelSchlick(vec3 incidentVector, vec3 excidentVector, vec3 f0);
   vec4 getLightColor(LightSource l, vec3 p);
   float ShadowCalculation(vec4 fragPosLightSpace, vec3 normal, vec3 lightDir);
  +vec3 getFilteredTexel(sampler2D texture, vec2 off);
   
   // Normal Mapping Without Precomputed Tangents by Christian Schüler
   mat3 cotangent_frame(vec3 N, vec3 p, vec2 uv);
  -vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord );
  +vec3 perturb_normal( vec3 N, vec3 V, vec2 texcoord);
   
   // Number rendering code below by P_Malin
   float DigitBin( const int x );
   float PrintValue( const vec2 vStringCoords, const float fValue, const float fMaxDigits, const float fDecimalPlaces );
  +
  +// Texture Filtering: https://www.codeproject.com/Articles/236394/Bi-Cubic-and-Bi-Linear-Interpolation-with-GLSL
  +vec4 BiCubic( sampler2D textureSampler, vec2 TexCoord );
  +float CatMullRom( float f );
   
   void main(void) {
       vec3 specular = vec3(0.);
  
positive.code:     return floor(mod((fCharBin / pow(2.0, floor(fract(vStringCoords.x) * 4.0) + (floor(vStringCoords.y * 5.0) * 4.0))), 2.0));
  }
  
  `;
  
negative.code:     vec3 ambient = vec3(0.015) * albedo * ao;
      vec3 resultingColor = ambient + LO * shadowFactor;
  
      // Debug: print numbers
      /*vec2 vFontSize = vec2(8.0, 15.0);
      resultingColor = mix( resultingColor, vec3(1.0, 1.0, 1.0), PrintValue( (gl_FragCoord.xy - vec2(0.0, 5.0)) / vFontSize, 
          xy.x, 4.0, 10.0));*/
  
      // Tone mapping by reinhart operator
      //resultingColor = resultingColor / (resultingColor + vec3(1.0));
      // Exposure tone mapping
      float exposure = 1.0; // => should be a uniform
      resultingColor = vec3(1.0) - exp(-resultingColor * exposure);
      // Gamma correction
      resultingColor = pow(resultingColor, vec3(1.0/2.2));
      
      color = vec4(resultingColor,1.0);
  
  }
  
  // Blaise-Guthmann texture filtering
  vec3 getFilteredTexel(sampler2D textureMap, vec2 off){
      //vec2 off = 2.999 * texelSize / 2.0;
      //vec2 off = vTexCoords;
      vec2 texelSize = 1.0 / vec2(textureSize(textureMap, 0));
      vec2 texelNumber = floor(off / texelSize);
      vec2 xy = 2.0 * (off - texelNumber*texelSize) / texelSize;
  
      vec3 ta,tx,ty,tc;
      float xoff = xy.x > 1.0 ? 1.0 : -1.0;
      float yoff = xy.y > 1.0 ? 1.0 : -1.0;
  
      ta = texture(textureMap, off).rgb;
  
      if(xy.x>=1.0){
          xy.x-=1.0;
          tx = texture(textureMap, off + vec2(texelSize.x,0.0)).rgb;
      }else{
          xy.x = 1.0 - xy.x;
          tx = texture(textureMap, off - vec2(texelSize.x,0.0)).rgb;
      }
  
      if(xy.y>=1.0){
          xy.y-=1.0;
          ty = texture(textureMap, off + vec2(0.0,texelSize.y)).rgb;
      }else{
          xy.y = 1.0 - xy.y;
          ty = texture(textureMap, off - vec2(0.0,texelSize.y)).rgb;
      }
  
      tc = texture(textureMap, off + texelSize * vec2(xoff, yoff)).rgb;
  
      float d1 = sqrt(xy.x * xy.x + xy.y * xy.y);
      float d = d1 > 1.0 ? (d1 - 1.0) / (sqrt(2.0) - 1.0) : 0.0;
  
      return (xy.x * tx + (1.0-xy.x) * ta + xy.y * ty + (1.0-xy.y) * ta + d * tc + (1.0-d) * ta ) / 3.0;
  }
  
  // Light intensity attenuation
  