octo-deno/lib/make/webgl.ts

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

import random from "../random/random.ts";
import numbers from "./numbers.ts";

export default class webgl {
  static get internalFormat() {
    return {
      RGB: { format: "RGB", type: ["UNSIGNED_BYTE", "UNSIGNED_SHORT_5_6_5"] },
      RGBA: {
        format: "RGBA",
        type: [
          "UNSIGNED_BYTE",
          "UNSIGNED_SHORT_4_4_4_4",
          "UNSIGNED_SHORT_5_5_5_1"
        ]
      },
      LUMINANCE_ALPHA: { format: "LUMINANCE_ALPHA", type: ["UNSIGNED_BYTE"] },
      LUMINANCE: { format: "LUMINANCE", type: ["UNSIGNED_BYTE"] },
      ALPHA: { format: "ALPHA", type: ["UNSIGNED_BYTE"] },
      R8: { format: "RED", type: ["UNSIGNED_BYTE"] },
      R16F: { format: "RED", type: ["HALF_FLOAT", "FLOAT"] },
      R32F: { format: "RED", type: ["FLOAT"] },
      R8UI: { format: "RED_INTEGER", type: ["UNSIGNED_BYTE"] },
      RG8: { format: "RG", type: ["UNSIGNED_BYTE"] },
      RG16F: { format: "RG", type: ["HALF_FLOAT", "FLOAT"] },
      RG32F: { format: "RG", type: ["FLOAT"] },
      RG8UI: { format: "RG_INTEGER", type: ["UNSIGNED_BYTE"] },
      RGB8: { format: "RGB", type: ["UNSIGNED_BYTE"] },
      SRGB8: { format: "RGB", type: ["UNSIGNED_BYTE"] },
      RGB565: {
        format: "RGB",
        type: ["RGB", "UNSIGNED_BYTE", "UNSIGNED_SHORT_5_6_5"]
      },
      R11F_G11F_B10F: {
        format: "RGB",
        type: ["UNSIGNED_INT_10F_11F_11F_REV", "HALF_FLOAT", "FLOAT"]
      },
      RGB9_E5: { format: "RGB", type: ["HALF_FLOAT", "FLOAT"] },
      RGB16F: { format: "RGB", type: ["HALF_FLOAT", "FLOAT"] },
      RGB32F: { format: "RGB", type: ["FLOAT"] },
      RGB8UI: { format: "RGB_INTEGER", type: ["UNSIGNED_BYTE"] },
      RGBA8: { format: "RGBA", type: ["UNSIGNED_BYTE"] },
      SRGB8_ALPHA8: { format: "RGBA", type: ["UNSIGNED_BYTE"] },
      RGB5_A1: {
        format: "RGBA",
        type: ["UNSIGNED_BYTE", "UNSIGNED_SHORT_5_5_5_1"]
      },
      RGB10_A2: { format: "RGBA", type: ["UNSIGNED_INT_2_10_10_10_REV"] },
      RGBA4: {
        format: "RGBA",
        type: ["UNSIGNED_BYTE", "UNSIGNED_SHORT_4_4_4_4"]
      },
      RGBA16F: { format: "RGBA", type: ["HALF_FLOAT", "FLOAT"] },
      RGBA32F: { format: "RGBA", type: ["FLOAT"] },
      RGBA8UI: { format: "RGBA_INTEGER", type: ["UNSIGNED_BYTE"] }
    };
  }

  static WebGLFormat() {
    let internalformat = random.item(Object.keys(webgl.internalFormat));
    let format = webgl.internalFormat[internalformat].format;
    let type = random.item(webgl.internalFormat[internalformat].type);
    return [internalformat, format, type];
  }

  static textureSources() {
    let sources = [
      "HTMLCanvasElement",
      "HTMLImageElement",
      "HTMLVideoElement",
      "ImageData"
    ];
    return random.item(sources);
  }

  static match(shader, regex, group = 1) {
    let matches = [];
    while (true) {
      let match = regex.exec(shader);
      if (match) {
        matches.push(match[group]);
      } else {
        break;
      }
    }
    return matches;
  }

  static parseUniforms(shader, group = 1) {
    /* Todo: Parse their individual data types into categories. */
    return webgl.match(shader, /uniform .+? (\w+)(?=[\[;])/gm, group); // eslint-disable-line no-useless-escape
  }

  static parseAttributes(shader, group = 1) {
    return webgl.match(shader, /attribute .+? (\w+)(?=;)/gm, group);
  }

  static parseVaryings(shader, group = 1) {
    return webgl.match(shader, /varying .+? (\w+)(?=;)/gm, group);
  }

  static parseFragDatav2(shader, group = 1) {
    // #version 200
    return webgl.match(shader, /(gl_Frag[^[ =]+)/gm, group);
  }

  static parseFragDatav3(shader, group = 1) {
    // #version 300
    return webgl.match(shader, /out .+? (\w+)(?=[\[;])/gm, group); // eslint-disable-line no-useless-escape
  }

  static parseFrag(shader, group = 1) {
    let matches = webgl.parseFragDatav2(shader);
    if (matches.length) {
      return matches;
    }
    return webgl.parseFragDatav3(shader);
  }

  static randomBitmask() {
    const values = [];
    for (let i = 0; i < 8; i++) {
      values.push(random.item([1, 0]));
    }

    return parseInt(values.join(""));
  }

  static randomBufferTarget(isWebGL2) {
    let target = ["ARRAY_BUFFER", "ELEMENT_ARRAY_BUFFER"];
    if (isWebGL2) {
      target = [
        ...target,
        "COPY_READ_BUFFER",
        "COPY_WRITE_BUFFER",
        "TRANSFORM_FEEDBACK_BUFFER",
        "UNIFORM_BUFFER",
        "PIXEL_PACK_BUFFER",
        "PIXEL_UNPACK_BUFFER"
      ];
    }
    return random.item(target);
  }

  static randomTexParameter(isWebGL2) {
    let pname = [
      "TEXTURE_MAG_FILTER",
      "TEXTURE_MIN_FILTER",
      "TEXTURE_WRAP_S",
      "TEXTURE_WRAP_T"
    ];
    if (isWebGL2) {
      pname = [
        ...pname,
        "TEXTURE_BASE_LEVEL",
        "TEXTURE_COMPARE_FUNC",
        "TEXTURE_COMPARE_MODE",
        "TEXTURE_MAX_LEVEL",
        "TEXTURE_MAX_LOD",
        "TEXTURE_MIN_LOD",
        "TEXTURE_WRAP_R"
      ];
    }
    return random.item(pname);
  }

  static randomTexParameterValue(isWebGL2) {
    let pnameparam = {
      TEXTURE_MAG_FILTER: ["LINEAR", "NEAREST"],
      TEXTURE_MIN_FILTER: [
        "LINEAR",
        "NEAREST",
        "NEAREST_MIPMAP_NEAREST",
        "LINEAR_MIPMAP_NEAREST",
        "NEAREST_MIPMAP_LINEA",
        "LINEAR_MIPMAP_LINEAR"
      ],
      TEXTURE_WRAP_S: ["REPEAT", "CLAMP_TO_EDGE", "MIRRORED_REPEAT"],
      TEXTURE_WRAP_T: ["REPEAT", "CLAMP_TO_EDGE", "MIRRORED_REPEAT"]
    };
    if (isWebGL2) {
      pnameparam = Object.assign(pnameparam, {
        TEXTURE_BASE_LEVEL: [numbers.any()],
        TEXTURE_COMPARE_FUNC: [
          "LEQUAL",
          "GEQUAL",
          "LESS",
          "GREATER",
          "EQUAL",
          "NOTEQUAL",
          "ALWAYS",
          "NEVER"
        ],
        TEXTURE_COMPARE_MODE: ["NONE", "COMPARE_REF_TO_TEXTURE"],
        TEXTURE_MAX_LEVEL: [numbers.any()],
        TEXTURE_MAX_LOD: [numbers.float()],
        TEXTURE_MIN_LOD: [numbers.float()],
        TEXTURE_WRAP_R: ["REPEAT", "CLAMP_TO_EDGE", "MIRRORED_REPEAT"]
      });
    }
    let pname = random.item(Object.keys(pnameparam));
    let param = random.item(pnameparam[pname]);
    return [pname, param];
  }

  static randomBlendMode(isWebGL2) {
    let mode = ["FUNC_ADD", "FUNC_SUBTRACT", "FUNC_REVERSE_SUBTRACT"];
    if (isWebGL2) {
      mode = [...mode, "MIN", "MAX"];
    }
    return random.item(mode);
  }

  static randomBlendFactor(isWebGL2) {
    let factor = [
      "ZERO",
      "ONE",
      "SRC_COLOR",
      "ONE_MINUS_SRC_COLOR",
      "DST_COLOR",
      "ONE_MINUS_DST_COLOR",
      "SRC_ALPHA",
      "ONE_MINUS_SRC_ALPHA",
      "DST_ALPHA",
      "ONE_MINUS_DST_ALPHA",
      "CONSTANT_COLOR",
      "ONE_MINUS_CONSTANT_COLOR",
      "CONSTANT_ALPHA",
      "ONE_MINUS_CONSTANT_ALPHA",
      "SRC_ALPHA_SATURATE"
    ];
    return random.item(factor);
  }

  static randomFace(isWebGL2) {
    let mode = ["FRONT", "BACK", "FRONT_AND_BACK"];
    return random.item(mode);
  }

  static randomTexImage2DTarget(isWebGL2) {
    let target = [
      "TEXTURE_2D",
      "TEXTURE_CUBE_MAP_POSITIVE_X",
      "TEXTURE_CUBE_MAP_NEGATIVE_X",
      "TEXTURE_CUBE_MAP_POSITIVE_Y",
      "TEXTURE_CUBE_MAP_NEGATIVE_Y",
      "TEXTURE_CUBE_MAP_POSITIVE_Z",
      "TEXTURE_CUBE_MAP_NEGATIVE_Z"
    ];
    return random.item(target);
  }

  static randomTextureTarget(isWebGL2) {
    let target = ["TEXTURE_2D", "TEXTURE_CUBE_MAP"];
    if (isWebGL2) {
      target = [...target, "TEXTURE_3D", "TEXTURE_2D_ARRAY"];
    }
    return random.item(target);
  }

  static randomFunc(isWebGL2) {
    let func = [
      "NEVER",
      "LESS",
      "EQUAL",
      "LEQUAL",
      "GREATER",
      "NOTEQUAL",
      "GEQUAL",
      "ALWAYS"
    ];
    return random.item(func);
  }

  static randomCap(isWebGL2) {
    let cap = [
      "BLEND",
      "CULL_FACE",
      "DEPTH_TEST",
      "DITHER",
      "POLYGON_OFFSET_FILL",
      "SAMPLE_ALPHA_TO_COVERAGE",
      "SAMPLE_COVERAGE",
      "SCISSOR_TEST",
      "STENCIL_TEST"
    ];
    if (isWebGL2) {
      cap = [...cap, "RASTERIZER_DISCARD"];
    }
    return random.item(cap);
  }

  static randomPrimitive(isWebGL2) {
    let mode = [
      "POINTS",
      "LINE_STRIP",
      "LINE_LOOP",
      "LINES",
      "TRIANGLE_STRIP",
      "TRIANGLE_FAN",
      "TRIANGLES"
    ];
    return random.item(mode);
  }

  static randomTextureAttachment(isWebGL2) {
    let attachment = [
      "COLOR_ATTACHMENT0",
      "DEPTH_ATTACHMENT",
      "STENCIL_ATTACHMENT",
      "DEPTH_STENCIL_ATTACHMENT"
    ];
    if (isWebGL2) {
      attachment = [...attachment, `COLOR_ATTACHMENT${random.range(0, 15)}`];
    }
    return random.item(attachment);
  }

  static randomAttachmentQuery(isWebGL2) {
    let pname = [
      "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",
      "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",
      "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",
      "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"
    ];
    if (isWebGL2) {
      pname = [
        ...pname,
        "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE",
        "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE",
        "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING",
        "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE",
        "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE",
        "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE",
        "FRAMEBUFFER_ATTACHMENT_RED_SIZE",
        "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE",
        "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"
      ];
    }
    return random.item(pname);
  }

  static randomShaderPrecision(isWebGL2) {
    let precisiontype = [
      "LOW_FLOAT",
      "MEDIUM_FLOAT",
      "HIGH_FLOAT",
      "LOW_INT",
      "MEDIUM_INT",
      "HIGH_INT"
    ];
    return random.item(precisiontype);
  }

  static randomStencilRefParameter(isWebGL2) {
    let param = [
      "STENCIL_FUNC",
      "STENCIL_VALUE_MASK",
      "STENCIL_REF",
      "STENCIL_BACK_FUNC",
      "STENCIL_BACK_VALUE_MASK",
      "STENCIL_BACK_REF",
      "STENCIL_BITS"
    ];
    return random.item(param);
  }

  static randomStencilMaskParameter(isWebGL2) {
    let param = ["STENCIL_WRITEMASK", "STENCIL_BACK_WRITEMASK", "STENCIL_BITS"];
    return random.item(param);
  }

  static randomVertexAttribParameter(isWebGL2) {
    let pname = [
      "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",
      "VERTEX_ATTRIB_ARRAY_ENABLED",
      "VERTEX_ATTRIB_ARRAY_SIZE",
      "VERTEX_ATTRIB_ARRAY_STRIDE",
      "VERTEX_ATTRIB_ARRAY_TYPE",
      "VERTEX_ATTRIB_ARRAY_NORMALIZED",
      "CURRENT_VERTEX_ATTRIB"
    ];
    if (isWebGL2) {
      pname = [
        ...pname,
        "VERTEX_ATTRIB_ARRAY_INTEGER",
        "VERTEX_ATTRIB_ARRAY_DIVISOR",
        "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE"
      ];
    }
    return random.item(pname);
  }

  static randomHint(isWebGL2) {
    let target = ["GENERATE_MIPMAP_HINT"];
    if (isWebGL2) {
      target = [...target, "FRAGMENT_SHADER_DERIVATIVE_HINT"];
    }
    return random.item(target);
  }

  static randomHintMode(isWebGL2) {
    let mode = ["FASTEST", "NICEST", "DONT_CARE"];
    return random.item(mode);
  }

  static randomPixelStorage(isWebGL2) {
    let pname = {
      PACK_ALIGNMENT: random.item([1, 2, 4, 8]),
      UNPACK_ALIGNMENT: random.item([1, 2, 4, 8]),
      UNPACK_FLIP_Y_WEBGL: random.bool(),
      UNPACK_PREMULTIPLY_ALPHA_WEBGL: random.bool(),
      UNPACK_COLORSPACE_CONVERSION_WEBGL: random.item([0, 0x9244])
    };
    if (isWebGL2) {
      Object.assign(pname, {
        PACK_ROW_LENGTH: numbers.any(),
        PACK_SKIP_PIXELS: numbers.any(),
        PACK_SKIP_ROWS: numbers.any(),
        UNPACK_ROW_LENGTH: numbers.any(),
        UNPACK_IMAGE_HEIGHT: numbers.any(),
        UNPACK_SKIP_PIXELS: numbers.any(),
        UNPACK_SKIP_ROWS: numbers.any(),
        UNPACK_SKIP_IMAGES: numbers.any()
      });
    }
    let name = random.item(Object.keys(pname));
    return [name, pname[name]];
  }

  static randomStencilAction(isWebGL2) {
    let action = [
      "KEEP",
      "ZERO",
      "REPLACE",
      "INCR",
      "INCR_WRAP",
      "DECR",
      "DECR_WRAP",
      "INVERT"
    ];
    return random.item(action);
  }

  static randomQueryTarget(isWebGL2) {
    let target = [
      "ANY_SAMPLES_PASSED",
      "ANY_SAMPLES_PASSED_CONSERVATIVE",
      "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"
    ];
    return random.item(target);
  }

  static randomQueryPname(isWebGL2) {
    let pname = ["CURRENT_QUERY", "QUERY_RESULT", "QUERY_RESULT_AVAILABLE"];
    return random.item(pname);
  }

  static randomSamplerParameter(isWebGL2) {
    let pname = [
      "TEXTURE_MAG_FILTER",
      "TEXTURE_MIN_FILTER",
      "TEXTURE_WRAP_S",
      "TEXTURE_WRAP_T",
      "TEXTURE_BASE_LEVEL",
      "TEXTURE_COMPARE_FUNC",
      "TEXTURE_COMPARE_MODE",
      "TEXTURE_MAX_LEVEL",
      "TEXTURE_WRAP_R",
      "TEXTURE_MAX_LOD",
      "TEXTURE_MIN_LOD",
      "TEXTURE_MAX_ANISOTROPY_EXT"
    ];
    return random.item(pname);
  }

  static randomSyncParameter(isWebGL2) {
    let pname = ["OBJECT_TYPE", "SYNC_STATUS", "SYNC_CONDITION", "SYNC_FLAGS"];
    return random.item(pname);
  }

  static randomClearBuffer(isWebGL2) {
    let buffer = ["COLOR", "DEPTH", "STENCIL", "DEPTH_STENCIL"];
    return random.item(buffer);
  }

  static randomBindBufferTarget(isWebGL2) {
    let target = ["TRANSFORM_FEEDBACK_BUFFER", "UNIFORM_BUFFER"];
    return random.item(target);
  }

  static randomIndexedParameterTarget(isWebGL2) {
    let target = [
      "TRANSFORM_FEEDBACK_BUFFER_BINDING",
      "TRANSFORM_FEEDBACK_BUFFER_SIZE",
      "TRANSFORM_FEEDBACK_BUFFER_START",
      "UNIFORM_BUFFER_BINDING",
      "UNIFORM_BUFFER_SIZE",
      "UNIFORM_BUFFER_START"
    ];
    return random.item(target);
  }

  static randomUniformParameter(isWebGL2) {
    let pname = [
      "UNIFORM_TYPE",
      "UNIFORM_SIZE",
      "UNIFORM_BLOCK_INDEX",
      "UNIFORM_OFFSET",
      "UNIFORM_ARRAY_STRIDE",
      "UNIFORM_MATRIX_STRIDE",
      "UNIFORM_IS_ROW_MAJOR"
    ];
    return random.item(pname);
  }

  static randomUniformBlockParameter(isWebGL2) {
    let pname = [
      "UNIFORM_BLOCK_BINDING",
      "UNIFORM_BLOCK_DATA_SIZE",
      "UNIFORM_BLOCK_ACTIVE_UNIFORMS",
      "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES",
      "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
      "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"
    ];
    return random.item(pname);
  }

  static randomPixelDatatype(isWebGL2) {
    let type = [
      "UNSIGNED_BYTE",
      "UNSIGNED_SHORT",
      "UNSIGNED_SHORT_5_6_5",
      "UNSIGNED_SHORT_4_4_4_4",
      "UNSIGNED_SHORT_5_5_5_1",
      "UNSIGNED_INT",
      "FLOAT"
    ];
    return random.item(type);
  }

  static randomBufferUsage(isWebGL2) {
    let usage = ["STATIC_DRAW", "DYNAMIC_DRAW", "STREAM_DRAW"];
    if (isWebGL2) {
      usage = [
        ...usage,
        "STATIC_READ",
        "DYNAMIC_READ",
        "STREAM_READ",
        "STATIC_COPY",
        "DYNAMIC_COPY",
        "STREAM_COPY"
      ];
    }
    return random.item(usage);
  }

  static randomParameter(isWebGL2) {
    let pname = [
      "ACTIVE_TEXTURE",
      "ALIASED_LINE_WIDTH_RANGE",
      "ALIASED_POINT_SIZE_RANGE",
      "ALPHA_BITS",
      "ARRAY_BUFFER_BINDING",
      "BLEND",
      "BLEND_COLOR",
      "BLEND_DST_ALPHA",
      "BLEND_DST_RGB",
      "BLEND_EQUATION_ALPHA",
      "BLEND_EQUATION_RGB",
      "BLEND_SRC_ALPHA",
      "BLEND_SRC_RGB",
      "BLUE_BITS",
      "COLOR_CLEAR_VALUE",
      "COLOR_WRITEMASK",
      "COMPRESSED_TEXTURE_FORMATS",
      "CULL_FACE",
      "CULL_FACE_MODE",
      "CURRENT_PROGRAM",
      "DEPTH_BITS",
      "DEPTH_CLEAR_VALUE",
      "DEPTH_FUNC",
      "DEPTH_RANGE",
      "DEPTH_TEST",
      "DEPTH_WRITEMASK",
      "DITHER",
      "ELEMENT_ARRAY_BUFFER_BINDING",
      "FRAMEBUFFER_BINDING",
      "FRONT_FACE",
      "GENERATE_MIPMAP_HINT",
      "GREEN_BITS",
      "IMPLEMENTATION_COLOR_READ_FORMAT",
      "IMPLEMENTATION_COLOR_READ_TYPE",
      "LINE_WIDTH",
      "MAX_COMBINED_TEXTURE_IMAGE_UNITS",
      "MAX_CUBE_MAP_TEXTURE_SIZE",
      "MAX_FRAGMENT_UNIFORM_VECTORS",
      "MAX_RENDERBUFFER_SIZE",
      "MAX_TEXTURE_IMAGE_UNITS",
      "MAX_TEXTURE_SIZE",
      "MAX_VARYING_VECTORS",
      "MAX_VERTEX_ATTRIBS",
      "MAX_VERTEX_TEXTURE_IMAGE_UNITS",
      "MAX_VERTEX_UNIFORM_VECTORS",
      "MAX_VIEWPORT_DIMS",
      "PACK_ALIGNMENT",
      "POLYGON_OFFSET_FACTOR",
      "POLYGON_OFFSET_FILL",
      "POLYGON_OFFSET_UNITS",
      "RED_BITS",
      "RENDERBUFFER_BINDING",
      "RENDERER",
      "SAMPLE_ALPHA_TO_COVERAGE",
      "SAMPLE_BUFFERS",
      "SAMPLE_COVERAGE",
      "SAMPLE_COVERAGE_INVERT",
      "SAMPLE_COVERAGE_VALUE",
      "SAMPLES",
      "SCISSOR_BOX",
      "SCISSOR_TEST",
      "SHADING_LANGUAGE_VERSION",
      "STENCIL_BACK_FAIL",
      "STENCIL_BACK_FUNC",
      "STENCIL_BACK_PASS_DEPTH_FAIL",
      "STENCIL_BACK_PASS_DEPTH_PASS",
      "STENCIL_BACK_REF",
      "STENCIL_BACK_VALUE_MASK",
      "STENCIL_BACK_WRITEMASK",
      "STENCIL_BITS",
      "STENCIL_CLEAR_VALUE",
      "STENCIL_FAIL",
      "STENCIL_FUNC",
      "STENCIL_PASS_DEPTH_FAIL",
      "STENCIL_PASS_DEPTH_PASS",
      "STENCIL_REF",
      "STENCIL_TEST",
      "STENCIL_VALUE_MASK",
      "STENCIL_WRITEMASK",
      "SUBPIXEL_BITS",
      "TEXTURE_BINDING_2D",
      "TEXTURE_BINDING_CUBE_MAP",
      "UNPACK_ALIGNMENT",
      "UNPACK_COLORSPACE_CONVERSION_WEBGL",
      "UNPACK_FLIP_Y_WEBGL",
      "UNPACK_PREMULTIPLY_ALPHA_WEBGL",
      "VENDOR",
      "VERSION",
      "VIEWPORT",
      "VERSION",
      "SHADING_LANGUAGE_VERSION",
      "VENDOR",
      "RENDERER"
    ];

    if (isWebGL2) {
      pname = [
        ...pname,
        "COPY_READ_BUFFER_BINDING",
        "COPY_WRITE_BUFFER_BINDING",
        "DRAW_BUFFERi",
        "DRAW_FRAMEBUFFER_BINDING",
        "FRAGMENT_SHADER_DERIVATIVE_HINT",
        "MAX_3D_TEXTURE_SIZE",
        "MAX_ARRAY_TEXTURE_LAYERS",
        "MAX_CLIENT_WAIT_TIMEOUT_WEBGL",
        "MAX_COLOR_ATTACHMENTS",
        "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",
        "MAX_COMBINED_UNIFORM_BLOCKS",
        "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS",
        "MAX_DRAW_BUFFERS",
        "MAX_ELEMENT_INDEX",
        "MAX_ELEMENTS_INDICE",
        "MAX_ELEMENTS_VERTICES",
        "MAX_FRAGMENT_INPUT_COMPONENTS",
        "MAX_FRAGMENT_UNIFORM_BLOCKS",
        "MAX_FRAGMENT_UNIFORM_COMPONENTS",
        "MAX_PROGRAM_TEXEL_OFFSET",
        "MAX_SAMPLES",
        "MAX_SERVER_WAIT_TIMEOUT",
        "MAX_TEXTURE_LOD_BIAS",
        "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",
        "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",
        "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",
        "MAX_UNIFORM_BLOCK_SIZE",
        "MAX_UNIFORM_BUFFER_BINDINGS",
        "MAX_VARYING_COMPONENTS",
        "MAX_VERTEX_OUTPUT_COMPONENTS",
        "MAX_VERTEX_UNIFORM_BLOCKS",
        "MAX_VERTEX_UNIFORM_COMPONENTS",
        "MIN_PROGRAM_TEXEL_OFFSET",
        "PACK_ROW_LENGTH",
        "PACK_SKIP_PIXELS",
        "PACK_SKIP_ROWS",
        "PIXEL_PACK_BUFFER_BINDING",
        "PIXEL_UNPACK_BUFFER_BINDING",
        "RASTERIZER_DISCARD",
        "READ_BUFFER",
        "READ_FRAMEBUFFER_BINDING",
        "SAMPLER_BINDING",
        "TEXTURE_BINDING_2D_ARRAY",
        "TEXTURE_BINDING_3D",
        "TRANSFORM_FEEDBACK_ACTIVE",
        "TRANSFORM_FEEDBACK_BINDING",
        "TRANSFORM_FEEDBACK_BUFFER_BINDING",
        "TRANSFORM_FEEDBACK_PAUSED",
        "UNIFORM_BUFFER_BINDING",
        "UNIFORM_BUFFER_OFFSET_ALIGNMENT",
        "UNPACK_IMAGE_HEIGHT",
        "UNPACK_ROW_LENGTH",
        "UNPACK_SKIP_IMAGES",
        "UNPACK_SKIP_PIXELS",
        "UNPACK_SKIP_ROWS",
        "VERTEX_ARRAY_BINDING"
      ];
    }
    return random.item(pname);
  }

  static randomProgramParameter() {
    let pname = [
      "DELETE_STATUS",
      "LINK_STATUS",
      "VALIDATE_STATUS",
      "ATTACHED_SHADERS",
      "ACTIVE_ATTRIBUTES",
      "ACTIVE_UNIFORMS",
      "TRANSFORM_FEEDBACK_BUFFER_MODE",
      "TRANSFORM_FEEDBACK_VARYINGS",
      "ACTIVE_UNIFORM_BLOCKS"
    ];
    return random.item(pname);
  }

  static randomRenderBufferParameter() {
    let pname = [
      "RENDERBUFFER_WIDTH",
      "RENDERBUFFER_HEIGHT",
      "RENDERBUFFER_INTERNAL_FORMAT",
      "RENDERBUFFER_RED_SIZE",
      "RENDERBUFFER_GREEN_SIZE",
      "RENDERBUFFER_BLUE_SIZE",
      "RENDERBUFFER_ALPHA_SIZE",
      "RENDERBUFFER_DEPTH_SIZE",
      "RENDERBUFFER_STENCIL_SIZE"
    ];
    return random.item(pname);
  }

  static randomExtension(pattern) {
    let extensions = [
      "ANGLE_instanced_arrays",
      "EXT_blend_minmax",
      "EXT_color_buffer_half_float",
      "EXT_frag_depth",
      "EXT_sRGB",
      "EXT_shader_texture_lod",
      "EXT_texture_filter_anisotropic",
      "EXT_disjoint_timer_query",
      "OES_element_index_uint",
      "OES_standard_derivatives",
      "OES_texture_float",
      "OES_texture_float_linear",
      "OES_texture_half_float",
      "OES_texture_half_float_linear",
      "OES_vertex_array_object",
      "WEBGL_color_buffer_float",
      "WEBGL_compressed_texture_s3tc",
      "WEBGL_compressed_texture_s3tc_srgb",
      "WEBGL_debug_renderer_info",
      "WEBGL_debug_shaders",
      "WEBGL_depth_texture",
      "WEBGL_draw_buffers",
      "WEBGL_lose_context"
    ];

    if (pattern) {
      let candidates = [];
      extensions.forEach(ext =>
        ext.includes(pattern) ? candidates.push(ext) : ""
      );
      if (candidates.length >= 0) {
        return random.item(candidates);
      }
    }

    return random.item(extensions);
  }
}