GLSL:未绑定任何制服时的强制错误

(function() {
  const gl = null;  // just to make sure we don't see global gl
  const progDB = new Map();
  let currentUniformMap;
  const limits = {};
  const origGetUniformLocationFn = WebGLRenderingContext.prototype.getUniformLocation;

  function init(gl) {
    [gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS].forEach((pname) => {
      limits[pname] = gl.getParameter(pname);
    });
  }

  function isBuiltIn(info) {
    const name = info.name;
    return name.startsWith("gl_") || name.startsWith("webgl_");
  }

  function addProgramToDB(gl, prg) {
    const uniformMap = new Map();
    const numUniforms = gl.getProgramParameter(prg, gl.ACTIVE_UNIFORMS);
    for (let ii = 0; ii < numUniforms; ++ii) {
      const uniformInfo = gl.getActiveUniform(prg, ii);
      if (isBuiltIn(uniformInfo)) {
        continue;
      }
      const location = origGetUniformLocationFn.call(gl, prg, uniformInfo.name);
      uniformMap.set(location, {set: false, name: uniformInfo.name, type: uniformInfo.type, size: uniformInfo.size});
    }
    progDB.set(prg, uniformMap);
  }

  HTMLCanvasElement.prototype.getContext = function(origFn) {
    return function(type, ...args) {
      const ctx = origFn.call(this, type, ...args);
      if (ctx && type === 'webgl') {
        init(ctx);
      }
      return ctx;
    }
  }(HTMLCanvasElement.prototype.getContext);

  // getUniformLocation does not return the same location object
  // for the same location so mapping a location to uniform data
  // would be a PITA. So, let's make it return the same location objects.
  WebGLRenderingContext.prototype.getUniformLocation = function(origFn) {
    return function(prg, name) {
      const uniformMap = progDB.get(prg);
      for (const [location, uniformInfo] of uniformMap.entries()) {
        // note: not handling names like foo[0] vs foo
        if (uniformInfo.name === name) {
          return location;
        }
      }
      return null;
    };
  }(WebGLRenderingContext.prototype.getUniformLocation);

  WebGLRenderingContext.prototype.linkProgram = function(origFn) {
    return function(prg) {
      origFn.call(this, prg);
      const success = this.getProgramParameter(prg, this.LINK_STATUS);
      if (success) {
        addProgramToDB(this, prg);
      }
    };
  }(WebGLRenderingContext.prototype.linkProgram);

  WebGLRenderingContext.prototype.useProgram = function(origFn) {
    return function(prg) {
      origFn.call(this, prg);
      currentUniformMap = progDB.get(prg);
    };
  }(WebGLRenderingContext.prototype.useProgram);

  WebGLRenderingContext.prototype.uniform1i = function(origFn) {
    return function(location, v) {
      const uniformInfo = currentUniformMap.get(location);
      if (v === undefined) {
        throw new Error(`bad value for uniform: ${uniformInfo.name}`);  // do you care? undefined will get converted to 0
      }
      const val = parseFloat(v);
      if (isNaN(val) || !isFinite(val)) {
        throw new Error(`bad value NaN or Infinity for uniform: ${uniformInfo.name}`);  // do you care?
      }
      switch (uniformInfo.type) {
        case this.SAMPLER_2D:
        case this.SAMPLER_CUBE:
          if (val < 0 || val > limits[this.MAX_COMBINED_TEXTURE_IMAGE_UNITS]) {
            throw new Error(`texture unit out of range for uniform: ${uniformInfo.name}`);
          }
          break;
        default:
          break;
      }
      uniformInfo.set = true;
      origFn.call(this, location, v);
    };
  }(WebGLRenderingContext.prototype.uniform1i);

  WebGLRenderingContext.prototype.drawArrays = function(origFn) {
    return function(...args) {
      const unsetUniforms = [...currentUniformMap.values()].filter(u => !u.set);
      if (unsetUniforms.length) {
        throw new Error(`unset uniforms: ${unsetUniforms.map(u => u.name).join(', ')}`);
      }
      origFn.call(this, ...args);
    };
  }(WebGLRenderingContext.prototype.drawArrays);
}());

// ------------------- above is wrapper ------------------------
// ------------------- below is test ---------------------------

const gl = document.createElement('canvas').getContext('webgl');

const vs = `
uniform float foo;
uniform float bar;
void main() {
  gl_PointSize = 1.;
  gl_Position = vec4(foo, bar, 0, 1);
}
`;

const fs = `
precision mediump float;
uniform sampler2D tex;
void main() {
  gl_FragColor = texture2D(tex, vec2(0));
}
`;

const prg = twgl.createProgram(gl, [vs, fs]);
const fooLoc = gl.getUniformLocation(prg, 'foo');
const barLoc = gl.getUniformLocation(prg, 'bar');
const texLoc = gl.getUniformLocation(prg, 'tex');

gl.useProgram(prg);

test('fails with undefined', () => {
  gl.uniform1i(fooLoc, undefined);
});
test('fails with non number string', () => {
  gl.uniform1i(barLoc, 'abc');
});
test('fails with NaN', () => {
  gl.uniform1i(barLoc, 1/0);
});
test('fails with too large texture unit', () => {
  gl.uniform1i(texLoc, 1000);
})
test('fails with not all uniforms set', () => {
  gl.drawArrays(gl.POINTS, 0, 1);
});
test('fails with not all uniforms set',() => {
  gl.uniform1i(fooLoc, 0);
  gl.uniform1i(barLoc, 0);
  gl.drawArrays(gl.POINTS, 0, 1);
});
test('passes with all uniforms set', () => {
  gl.uniform1i(fooLoc, 0);
  gl.uniform1i(barLoc, 0);
  gl.uniform1i(texLoc, 0);
  gl.drawArrays(gl.POINTS, 0, 1);   // note there is no texture so will actually generate warning
});

function test(msg, fn) {
  const expectFail = msg.startsWith('fails');
  let result = 'success';
  let fail = false;
  try {
    fn();
  } catch (e) {
    result = e;
    fail = true;
  }
  log('black', msg);
  log(expectFail === fail ? 'green' : 'red', '  ', result);
}

function log(color, ...args) {
  const elem = document.createElement('pre');
  elem.textContent = [...args].join(' ');
  elem.style.color = color;
  document.body.appendChild(elem);
}

pre { margin: 0; }

<script src="https://twgljs.org/dist/4.x/twgl-full.min.js"></script>