webgl/2d/08e-warp-mask-smoothstep.html

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta http-equiv="X-UA-Compatible" content="ie=edge">
  <title>WebGL</title>
</head>
<body>
  <canvas id="c"></canvas>

  <script>
  {

    const createShader = (gl, type, source) => {
      const shader = gl.createShader(type);
      gl.shaderSource(shader, source);
      gl.compileShader(shader);
      const success = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
      if (success) {
        return shader;
      }
      console.error(gl.getShaderInfoLog(shader));
      gl.deleteShader(shader);
    };

    const createProgram = (gl, vertexShader, fragmentShader) => {
      const program = gl.createProgram();
      gl.attachShader(program, vertexShader);
      gl.attachShader(program, fragmentShader);
      gl.linkProgram(program);
      const success = gl.getProgramParameter(program, gl.LINK_STATUS);
      if (success) {
        return program;
      }
      console.error(gl.getProgramInfoLog(program));
      gl.deleteProgram(program);
    };

    const canvas = document.querySelector('#c');
    const gl = canvas.getContext('webgl');
    const vertexShader = createShader(gl, gl.VERTEX_SHADER, `
    precision mediump float;
    
    attribute vec2 a_position;
    attribute vec2 a_texCoord;

    varying vec2 uv;
    varying vec2 vertPos;
    
    void main() {     
      gl_Position = vec4(a_position, 1, 1);
      uv = a_texCoord;
      vertPos = gl_Position.xy;
    }
    `);
    const fragmentShader = createShader(gl, gl.FRAGMENT_SHADER, `
    precision mediump float;

    uniform sampler2D texture;
    uniform float u_distortion;

    varying vec2 uv;
    varying vec2 vertPos;
    
    void main() {

      vec2 ndc_pos = vertPos;
      vec2 testVec = ndc_pos.xy / max(abs(ndc_pos.x), abs(ndc_pos.y));
      float len = max(1.0,length( testVec ));
      ndc_pos *= mix(1.0, mix(1.0,len,max(abs(ndc_pos.x), abs(ndc_pos.y))), u_distortion);
      vec2 texCoord = vec2(ndc_pos.s, -ndc_pos.t) * 0.5 + 0.5;

      vec4 sampleColor = texture2D(texture, texCoord);

      float mask = 1.0;
      mask *= smoothstep(0.0, 0.1, texCoord.x);
      mask *= 1.0 - smoothstep(0.9, 1.0, texCoord.x);
      mask *= smoothstep(0.0, 0.1, texCoord.y);
      mask *= 1.0 - smoothstep(0.9, 1.0, texCoord.y);

      vec4 maskPreview = vec4(mask, mask, mask, 1.0);

      gl_FragColor = maskPreview;
    }
    `);
    const program = createProgram(gl, vertexShader, fragmentShader);
    const positionAttributeLocation = gl.getAttribLocation(program, "a_position");
    const positionBuffer = gl.createBuffer();
    const texCoordAttributeLocation = gl.getAttribLocation(program, "a_texCoord");
    const texCoordBuffer = gl.createBuffer();

    const distortionLocation = gl.getUniformLocation(program, "u_distortion");

    let distortion = 1.0;

    const init = async () => {
      const imgTexture = await loadImage("images/devine_selectie-087.jpg");

      gl.useProgram(program);

      gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
      gl.bufferData(
        gl.ARRAY_BUFFER,
        new Float32Array([
            -1.0, 1.0,
            1.0, 1.0,
            -1.0, -1.0,

            -1.0, -1.0,
            1.0, 1.0,
            1.0, -1.0
        ]),
        gl.STATIC_DRAW);
      gl.enableVertexAttribArray(positionAttributeLocation);
      gl.vertexAttribPointer(positionAttributeLocation, 2, gl.FLOAT, false, 0, 0);

      gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
      gl.bufferData(
        gl.ARRAY_BUFFER,
        new Float32Array([
            0.0, 0.0,
            1.0, 0.0,
            0.0, 1.0,

            0.0, 1.0,
            1.0, 0.0,
            1.0, 1.0,
        ]),
        gl.STATIC_DRAW);
      gl.enableVertexAttribArray(texCoordAttributeLocation);
      gl.vertexAttribPointer(texCoordAttributeLocation, 2, gl.FLOAT, false, 0, 0);

      uploadImageToTexture(imgTexture, "texture", 0);

      canvas.width = imgTexture.width;
      canvas.height = imgTexture.height;

      drawScene();
    };

    const drawScene = () => {
      gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
      gl.clearColor(0, 0, 0, 0);
      gl.clear(gl.COLOR_BUFFER_BIT);
      gl.useProgram(program);

      gl.uniform1f(distortionLocation, distortion);

      gl.drawArrays(gl.TRIANGLES, 0, 6);

      requestAnimationFrame(drawScene);
    };

    const loadImage = (src) => {
      return new Promise((resolve, reject) => {
        const img = new Image();
        img.addEventListener("load", () => resolve(img));
        img.addEventListener("error", err => reject(err));
        img.src = src;
      });
    };

    const map = (value, x1, y1, x2, y2) => (value - x1) * (y2 - x2) / (y1 - x1) + x2;

    const uploadImageToTexture = (img, uniformName, textureUnitIndex) => {
      const u_imageLoc = gl.getUniformLocation(program, uniformName);
      gl.uniform1i(u_imageLoc, textureUnitIndex);

      const texture = gl.createTexture();
      gl.activeTexture(gl.TEXTURE0 + textureUnitIndex);
      gl.bindTexture(gl.TEXTURE_2D, texture);
    
      // Set the parameters so we can render any size image.
      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
      gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
    
      // Upload the image into the texture.
      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, img);
    };

    init();
  }
  </script>
</body>
</html>