diff options
Diffstat (limited to '')
10 files changed, 1802 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/00_test_list.txt b/dom/canvas/test/webgl-conf/checkout/conformance2/context/00_test_list.txt new file mode 100644 index 0000000000..fc4f8b8c07 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/00_test_list.txt @@ -0,0 +1,10 @@ +constants-and-properties-2.html +context-attributes-depth-stencil-antialias-obeyed.html +--min-version 2.0.1 context-mode.html +--min-version 2.0.1 context-sharing-texture2darray-texture3d-data-bug.html +context-type-test-2.html +--min-version 2.0.1 context-resize-changes-buffer-binding-bug.html +--min-version 2.0.1 incorrect-context-object-behaviour.html +methods-2.html +--min-version 2.0.1 no-experimental-webgl2.html + diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/constants-and-properties-2.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/constants-and-properties-2.html new file mode 100644 index 0000000000..f4e2bfc30e --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/constants-and-properties-2.html @@ -0,0 +1,835 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Constants and Properties Test</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<canvas id="canvas" style="width: 50px; height: 50px;"> </canvas> +<script> +"use strict"; +description("This test ensures that the WebGL context has all the constants and (non-function) properties in the specification."); + +var constants = { + /* ClearBufferMask */ +DEPTH_BUFFER_BIT : 0x00000100, +STENCIL_BUFFER_BIT : 0x00000400, +COLOR_BUFFER_BIT : 0x00004000, + + /* BeginMode */ +POINTS : 0x0000, +LINES : 0x0001, +LINE_LOOP : 0x0002, +LINE_STRIP : 0x0003, +TRIANGLES : 0x0004, +TRIANGLE_STRIP : 0x0005, +TRIANGLE_FAN : 0x0006, + + /* AlphaFunction (not supported in ES20) */ + /* NEVER */ + /* LESS */ + /* EQUAL */ + /* LEQUAL */ + /* GREATER */ + /* NOTEQUAL */ + /* GEQUAL */ + /* ALWAYS */ + + /* BlendingFactorDest */ +ZERO : 0, +ONE : 1, +SRC_COLOR : 0x0300, +ONE_MINUS_SRC_COLOR : 0x0301, +SRC_ALPHA : 0x0302, +ONE_MINUS_SRC_ALPHA : 0x0303, +DST_ALPHA : 0x0304, +ONE_MINUS_DST_ALPHA : 0x0305, + + /* BlendingFactorSrc */ + /* ZERO */ + /* ONE */ +DST_COLOR : 0x0306, +ONE_MINUS_DST_COLOR : 0x0307, +SRC_ALPHA_SATURATE : 0x0308, + /* SRC_ALPHA */ + /* ONE_MINUS_SRC_ALPHA */ + /* DST_ALPHA */ + /* ONE_MINUS_DST_ALPHA */ + + /* BlendEquationSeparate */ +FUNC_ADD : 0x8006, +BLEND_EQUATION : 0x8009, +BLEND_EQUATION_RGB : 0x8009, /* same as BLEND_EQUATION */ +BLEND_EQUATION_ALPHA : 0x883D, + + /* BlendSubtract */ +FUNC_SUBTRACT : 0x800A, +FUNC_REVERSE_SUBTRACT : 0x800B, + + /* Separate Blend Functions */ +BLEND_DST_RGB : 0x80C8, +BLEND_SRC_RGB : 0x80C9, +BLEND_DST_ALPHA : 0x80CA, +BLEND_SRC_ALPHA : 0x80CB, +CONSTANT_COLOR : 0x8001, +ONE_MINUS_CONSTANT_COLOR : 0x8002, +CONSTANT_ALPHA : 0x8003, +ONE_MINUS_CONSTANT_ALPHA : 0x8004, +BLEND_COLOR : 0x8005, + + /* Buffer Objects */ +ARRAY_BUFFER : 0x8892, +ELEMENT_ARRAY_BUFFER : 0x8893, +ARRAY_BUFFER_BINDING : 0x8894, +ELEMENT_ARRAY_BUFFER_BINDING : 0x8895, + +STREAM_DRAW : 0x88E0, +STATIC_DRAW : 0x88E4, +DYNAMIC_DRAW : 0x88E8, + +BUFFER_SIZE : 0x8764, +BUFFER_USAGE : 0x8765, + +CURRENT_VERTEX_ATTRIB : 0x8626, + + /* CullFaceMode */ +FRONT : 0x0404, +BACK : 0x0405, +FRONT_AND_BACK : 0x0408, + + /* DepthFunction */ + /* NEVER */ + /* LESS */ + /* EQUAL */ + /* LEQUAL */ + /* GREATER */ + /* NOTEQUAL */ + /* GEQUAL */ + /* ALWAYS */ + + /* EnableCap */ + /* TEXTURE_2D */ +CULL_FACE : 0x0B44, +BLEND : 0x0BE2, +DITHER : 0x0BD0, +STENCIL_TEST : 0x0B90, +DEPTH_TEST : 0x0B71, +SCISSOR_TEST : 0x0C11, +POLYGON_OFFSET_FILL : 0x8037, +SAMPLE_ALPHA_TO_COVERAGE : 0x809E, +SAMPLE_COVERAGE : 0x80A0, + + /* ErrorCode */ +NO_ERROR : 0, +INVALID_ENUM : 0x0500, +INVALID_VALUE : 0x0501, +INVALID_OPERATION : 0x0502, +OUT_OF_MEMORY : 0x0505, + + /* FrontFaceDirection */ +CW : 0x0900, +CCW : 0x0901, + + /* GetPName */ +LINE_WIDTH : 0x0B21, +ALIASED_POINT_SIZE_RANGE : 0x846D, +ALIASED_LINE_WIDTH_RANGE : 0x846E, +CULL_FACE_MODE : 0x0B45, +FRONT_FACE : 0x0B46, +DEPTH_RANGE : 0x0B70, +DEPTH_WRITEMASK : 0x0B72, +DEPTH_CLEAR_VALUE : 0x0B73, +DEPTH_FUNC : 0x0B74, +STENCIL_CLEAR_VALUE : 0x0B91, +STENCIL_FUNC : 0x0B92, +STENCIL_FAIL : 0x0B94, +STENCIL_PASS_DEPTH_FAIL : 0x0B95, +STENCIL_PASS_DEPTH_PASS : 0x0B96, +STENCIL_REF : 0x0B97, +STENCIL_VALUE_MASK : 0x0B93, +STENCIL_WRITEMASK : 0x0B98, +STENCIL_BACK_FUNC : 0x8800, +STENCIL_BACK_FAIL : 0x8801, +STENCIL_BACK_PASS_DEPTH_FAIL : 0x8802, +STENCIL_BACK_PASS_DEPTH_PASS : 0x8803, +STENCIL_BACK_REF : 0x8CA3, +STENCIL_BACK_VALUE_MASK : 0x8CA4, +STENCIL_BACK_WRITEMASK : 0x8CA5, +VIEWPORT : 0x0BA2, +SCISSOR_BOX : 0x0C10, + /* SCISSOR_TEST */ +COLOR_CLEAR_VALUE : 0x0C22, +COLOR_WRITEMASK : 0x0C23, +UNPACK_ALIGNMENT : 0x0CF5, +PACK_ALIGNMENT : 0x0D05, +MAX_TEXTURE_SIZE : 0x0D33, +MAX_VIEWPORT_DIMS : 0x0D3A, +SUBPIXEL_BITS : 0x0D50, +RED_BITS : 0x0D52, +GREEN_BITS : 0x0D53, +BLUE_BITS : 0x0D54, +ALPHA_BITS : 0x0D55, +DEPTH_BITS : 0x0D56, +STENCIL_BITS : 0x0D57, +POLYGON_OFFSET_UNITS : 0x2A00, + /* POLYGON_OFFSET_FILL */ +POLYGON_OFFSET_FACTOR : 0x8038, +TEXTURE_BINDING_2D : 0x8069, +SAMPLE_BUFFERS : 0x80A8, +SAMPLES : 0x80A9, +SAMPLE_COVERAGE_VALUE : 0x80AA, +SAMPLE_COVERAGE_INVERT : 0x80AB, + + /* GetTextureParameter */ + /* TEXTURE_MAG_FILTER */ + /* TEXTURE_MIN_FILTER */ + /* TEXTURE_WRAP_S */ + /* TEXTURE_WRAP_T */ + +COMPRESSED_TEXTURE_FORMATS : 0x86A3, + + /* HintMode */ +DONT_CARE : 0x1100, +FASTEST : 0x1101, +NICEST : 0x1102, + + /* HintTarget */ +GENERATE_MIPMAP_HINT : 0x8192, + + /* DataType */ +BYTE : 0x1400, +UNSIGNED_BYTE : 0x1401, +SHORT : 0x1402, +UNSIGNED_SHORT : 0x1403, +INT : 0x1404, +UNSIGNED_INT : 0x1405, +FLOAT : 0x1406, + + /* PixelFormat */ +DEPTH_COMPONENT : 0x1902, +ALPHA : 0x1906, +RGB : 0x1907, +RGBA : 0x1908, +LUMINANCE : 0x1909, +LUMINANCE_ALPHA : 0x190A, + + /* PixelType */ + /* UNSIGNED_BYTE */ +UNSIGNED_SHORT_4_4_4_4 : 0x8033, +UNSIGNED_SHORT_5_5_5_1 : 0x8034, +UNSIGNED_SHORT_5_6_5 : 0x8363, + + /* Shaders */ +FRAGMENT_SHADER : 0x8B30, +VERTEX_SHADER : 0x8B31, +MAX_VERTEX_ATTRIBS : 0x8869, +MAX_VERTEX_UNIFORM_VECTORS : 0x8DFB, +MAX_VARYING_VECTORS : 0x8DFC, +MAX_COMBINED_TEXTURE_IMAGE_UNITS : 0x8B4D, +MAX_VERTEX_TEXTURE_IMAGE_UNITS : 0x8B4C, +MAX_TEXTURE_IMAGE_UNITS : 0x8872, +MAX_FRAGMENT_UNIFORM_VECTORS : 0x8DFD, +SHADER_TYPE : 0x8B4F, +DELETE_STATUS : 0x8B80, +LINK_STATUS : 0x8B82, +VALIDATE_STATUS : 0x8B83, +ATTACHED_SHADERS : 0x8B85, +ACTIVE_UNIFORMS : 0x8B86, +ACTIVE_ATTRIBUTES : 0x8B89, +SHADING_LANGUAGE_VERSION : 0x8B8C, +CURRENT_PROGRAM : 0x8B8D, + + /* StencilFunction */ +NEVER : 0x0200, +LESS : 0x0201, +EQUAL : 0x0202, +LEQUAL : 0x0203, +GREATER : 0x0204, +NOTEQUAL : 0x0205, +GEQUAL : 0x0206, +ALWAYS : 0x0207, + + /* StencilOp */ + /* ZERO */ +KEEP : 0x1E00, +REPLACE : 0x1E01, +INCR : 0x1E02, +DECR : 0x1E03, +INVERT : 0x150A, +INCR_WRAP : 0x8507, +DECR_WRAP : 0x8508, + + /* StringName */ +VENDOR : 0x1F00, +RENDERER : 0x1F01, +VERSION : 0x1F02, + + /* TextureMagFilter */ +NEAREST : 0x2600, +LINEAR : 0x2601, + + /* TextureMinFilter */ + /* NEAREST */ + /* LINEAR */ +NEAREST_MIPMAP_NEAREST : 0x2700, +LINEAR_MIPMAP_NEAREST : 0x2701, +NEAREST_MIPMAP_LINEAR : 0x2702, +LINEAR_MIPMAP_LINEAR : 0x2703, + + /* TextureParameterName */ +TEXTURE_MAG_FILTER : 0x2800, +TEXTURE_MIN_FILTER : 0x2801, +TEXTURE_WRAP_S : 0x2802, +TEXTURE_WRAP_T : 0x2803, + + /* TextureTarget */ +TEXTURE_2D : 0x0DE1, +TEXTURE : 0x1702, + +TEXTURE_CUBE_MAP : 0x8513, +TEXTURE_BINDING_CUBE_MAP : 0x8514, +TEXTURE_CUBE_MAP_POSITIVE_X : 0x8515, +TEXTURE_CUBE_MAP_NEGATIVE_X : 0x8516, +TEXTURE_CUBE_MAP_POSITIVE_Y : 0x8517, +TEXTURE_CUBE_MAP_NEGATIVE_Y : 0x8518, +TEXTURE_CUBE_MAP_POSITIVE_Z : 0x8519, +TEXTURE_CUBE_MAP_NEGATIVE_Z : 0x851A, +MAX_CUBE_MAP_TEXTURE_SIZE : 0x851C, + + /* TextureUnit */ +TEXTURE0 : 0x84C0, +TEXTURE1 : 0x84C1, +TEXTURE2 : 0x84C2, +TEXTURE3 : 0x84C3, +TEXTURE4 : 0x84C4, +TEXTURE5 : 0x84C5, +TEXTURE6 : 0x84C6, +TEXTURE7 : 0x84C7, +TEXTURE8 : 0x84C8, +TEXTURE9 : 0x84C9, +TEXTURE10 : 0x84CA, +TEXTURE11 : 0x84CB, +TEXTURE12 : 0x84CC, +TEXTURE13 : 0x84CD, +TEXTURE14 : 0x84CE, +TEXTURE15 : 0x84CF, +TEXTURE16 : 0x84D0, +TEXTURE17 : 0x84D1, +TEXTURE18 : 0x84D2, +TEXTURE19 : 0x84D3, +TEXTURE20 : 0x84D4, +TEXTURE21 : 0x84D5, +TEXTURE22 : 0x84D6, +TEXTURE23 : 0x84D7, +TEXTURE24 : 0x84D8, +TEXTURE25 : 0x84D9, +TEXTURE26 : 0x84DA, +TEXTURE27 : 0x84DB, +TEXTURE28 : 0x84DC, +TEXTURE29 : 0x84DD, +TEXTURE30 : 0x84DE, +TEXTURE31 : 0x84DF, +ACTIVE_TEXTURE : 0x84E0, + + /* TextureWrapMode */ +REPEAT : 0x2901, +CLAMP_TO_EDGE : 0x812F, +MIRRORED_REPEAT : 0x8370, + + /* Uniform Types */ +FLOAT_VEC2 : 0x8B50, +FLOAT_VEC3 : 0x8B51, +FLOAT_VEC4 : 0x8B52, +INT_VEC2 : 0x8B53, +INT_VEC3 : 0x8B54, +INT_VEC4 : 0x8B55, +BOOL : 0x8B56, +BOOL_VEC2 : 0x8B57, +BOOL_VEC3 : 0x8B58, +BOOL_VEC4 : 0x8B59, +FLOAT_MAT2 : 0x8B5A, +FLOAT_MAT3 : 0x8B5B, +FLOAT_MAT4 : 0x8B5C, +SAMPLER_2D : 0x8B5E, +SAMPLER_CUBE : 0x8B60, + + /* Vertex Arrays */ +VERTEX_ATTRIB_ARRAY_ENABLED : 0x8622, +VERTEX_ATTRIB_ARRAY_SIZE : 0x8623, +VERTEX_ATTRIB_ARRAY_STRIDE : 0x8624, +VERTEX_ATTRIB_ARRAY_TYPE : 0x8625, +VERTEX_ATTRIB_ARRAY_NORMALIZED : 0x886A, +VERTEX_ATTRIB_ARRAY_POINTER : 0x8645, +VERTEX_ATTRIB_ARRAY_BUFFER_BINDING : 0x889F, + + /* Shader Source */ +COMPILE_STATUS : 0x8B81, + + /* Shader Precision-Specified Types */ +LOW_FLOAT : 0x8DF0, +MEDIUM_FLOAT : 0x8DF1, +HIGH_FLOAT : 0x8DF2, +LOW_INT : 0x8DF3, +MEDIUM_INT : 0x8DF4, +HIGH_INT : 0x8DF5, + + /* Framebuffer Object. */ +FRAMEBUFFER : 0x8D40, +RENDERBUFFER : 0x8D41, + +RGBA4 : 0x8056, +RGB5_A1 : 0x8057, +RGB565 : 0x8D62, +DEPTH_COMPONENT16 : 0x81A5, +STENCIL_INDEX8 : 0x8D48, +DEPTH_STENCIL : 0x84F9, + +RENDERBUFFER_WIDTH : 0x8D42, +RENDERBUFFER_HEIGHT : 0x8D43, +RENDERBUFFER_INTERNAL_FORMAT : 0x8D44, +RENDERBUFFER_RED_SIZE : 0x8D50, +RENDERBUFFER_GREEN_SIZE : 0x8D51, +RENDERBUFFER_BLUE_SIZE : 0x8D52, +RENDERBUFFER_ALPHA_SIZE : 0x8D53, +RENDERBUFFER_DEPTH_SIZE : 0x8D54, +RENDERBUFFER_STENCIL_SIZE : 0x8D55, + +FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE : 0x8CD0, +FRAMEBUFFER_ATTACHMENT_OBJECT_NAME : 0x8CD1, +FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL : 0x8CD2, +FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE : 0x8CD3, + +COLOR_ATTACHMENT0 : 0x8CE0, +DEPTH_ATTACHMENT : 0x8D00, +STENCIL_ATTACHMENT : 0x8D20, +DEPTH_STENCIL_ATTACHMENT : 0x821A, + +NONE : 0, + +FRAMEBUFFER_COMPLETE : 0x8CD5, +FRAMEBUFFER_INCOMPLETE_ATTACHMENT : 0x8CD6, +FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : 0x8CD7, +FRAMEBUFFER_INCOMPLETE_DIMENSIONS : 0x8CD9, +FRAMEBUFFER_UNSUPPORTED : 0x8CDD, + +FRAMEBUFFER_BINDING : 0x8CA6, +RENDERBUFFER_BINDING : 0x8CA7, +MAX_RENDERBUFFER_SIZE : 0x84E8, + +INVALID_FRAMEBUFFER_OPERATION : 0x0506, + +IMPLEMENTATION_COLOR_READ_TYPE : 0x8B9A, +IMPLEMENTATION_COLOR_READ_FORMAT : 0x8B9B, + +/* WebGL-specific enums */ +UNPACK_FLIP_Y_WEBGL : 0x9240, +UNPACK_PREMULTIPLY_ALPHA_WEBGL : 0x9241, +CONTEXT_LOST_WEBGL : 0x9242, +UNPACK_COLORSPACE_CONVERSION_WEBGL : 0x9243, +BROWSER_DEFAULT_WEBGL : 0x9244, + +/* WebGL2 enums */ +READ_BUFFER : 0x0C02, +UNPACK_ROW_LENGTH : 0x0CF2, +UNPACK_SKIP_ROWS : 0x0CF3, +UNPACK_SKIP_PIXELS : 0x0CF4, +PACK_ROW_LENGTH : 0x0D02, +PACK_SKIP_ROWS : 0x0D03, +PACK_SKIP_PIXELS : 0x0D04, +COLOR : 0x1800, +DEPTH : 0x1801, +STENCIL : 0x1802, +RED : 0x1903, +RGB8 : 0x8051, +RGBA8 : 0x8058, +RGB10_A2 : 0x8059, +TEXTURE_BINDING_3D : 0x806A, +UNPACK_SKIP_IMAGES : 0x806D, +UNPACK_IMAGE_HEIGHT : 0x806E, +TEXTURE_3D : 0x806F, +TEXTURE_WRAP_R : 0x8072, +MAX_3D_TEXTURE_SIZE : 0x8073, +UNSIGNED_INT_2_10_10_10_REV : 0x8368, +MAX_ELEMENTS_VERTICES : 0x80E8, +MAX_ELEMENTS_INDICES : 0x80E9, +TEXTURE_MIN_LOD : 0x813A, +TEXTURE_MAX_LOD : 0x813B, +TEXTURE_BASE_LEVEL : 0x813C, +TEXTURE_MAX_LEVEL : 0x813D, +MIN : 0x8007, +MAX : 0x8008, +DEPTH_COMPONENT24 : 0x81A6, +MAX_TEXTURE_LOD_BIAS : 0x84FD, +TEXTURE_COMPARE_MODE : 0x884C, +TEXTURE_COMPARE_FUNC : 0x884D, +CURRENT_QUERY : 0x8865, +QUERY_RESULT : 0x8866, +QUERY_RESULT_AVAILABLE : 0x8867, +STREAM_READ : 0x88E1, +STREAM_COPY : 0x88E2, +STATIC_READ : 0x88E5, +STATIC_COPY : 0x88E6, +DYNAMIC_READ : 0x88E9, +DYNAMIC_COPY : 0x88EA, +MAX_DRAW_BUFFERS : 0x8824, +DRAW_BUFFER0 : 0x8825, +DRAW_BUFFER1 : 0x8826, +DRAW_BUFFER2 : 0x8827, +DRAW_BUFFER3 : 0x8828, +DRAW_BUFFER4 : 0x8829, +DRAW_BUFFER5 : 0x882A, +DRAW_BUFFER6 : 0x882B, +DRAW_BUFFER7 : 0x882C, +DRAW_BUFFER8 : 0x882D, +DRAW_BUFFER9 : 0x882E, +DRAW_BUFFER10 : 0x882F, +DRAW_BUFFER11 : 0x8830, +DRAW_BUFFER12 : 0x8831, +DRAW_BUFFER13 : 0x8832, +DRAW_BUFFER14 : 0x8833, +DRAW_BUFFER15 : 0x8834, +MAX_FRAGMENT_UNIFORM_COMPONENTS : 0x8B49, +MAX_VERTEX_UNIFORM_COMPONENTS : 0x8B4A, +SAMPLER_3D : 0x8B5F, +SAMPLER_2D_SHADOW : 0x8B62, +FRAGMENT_SHADER_DERIVATIVE_HINT : 0x8B8B, +PIXEL_PACK_BUFFER : 0x88EB, +PIXEL_UNPACK_BUFFER : 0x88EC, +PIXEL_PACK_BUFFER_BINDING : 0x88ED, +PIXEL_UNPACK_BUFFER_BINDING : 0x88EF, +FLOAT_MAT2x3 : 0x8B65, +FLOAT_MAT2x4 : 0x8B66, +FLOAT_MAT3x2 : 0x8B67, +FLOAT_MAT3x4 : 0x8B68, +FLOAT_MAT4x2 : 0x8B69, +FLOAT_MAT4x3 : 0x8B6A, +SRGB : 0x8C40, +SRGB8 : 0x8C41, +SRGB8_ALPHA8 : 0x8C43, +COMPARE_REF_TO_TEXTURE : 0x884E, +RGBA32F : 0x8814, +RGB32F : 0x8815, +RGBA16F : 0x881A, +RGB16F : 0x881B, +VERTEX_ATTRIB_ARRAY_INTEGER : 0x88FD, +MAX_ARRAY_TEXTURE_LAYERS : 0x88FF, +MIN_PROGRAM_TEXEL_OFFSET : 0x8904, +MAX_PROGRAM_TEXEL_OFFSET : 0x8905, +MAX_VARYING_COMPONENTS : 0x8B4B, +TEXTURE_2D_ARRAY : 0x8C1A, +TEXTURE_BINDING_2D_ARRAY : 0x8C1D, +R11F_G11F_B10F : 0x8C3A, +UNSIGNED_INT_10F_11F_11F_REV : 0x8C3B, +RGB9_E5 : 0x8C3D, +UNSIGNED_INT_5_9_9_9_REV : 0x8C3E, +TRANSFORM_FEEDBACK_BUFFER_MODE : 0x8C7F, +MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS : 0x8C80, +TRANSFORM_FEEDBACK_VARYINGS : 0x8C83, +TRANSFORM_FEEDBACK_BUFFER_START : 0x8C84, +TRANSFORM_FEEDBACK_BUFFER_SIZE : 0x8C85, +TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN : 0x8C88, +RASTERIZER_DISCARD : 0x8C89, +MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS : 0x8C8A, +MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS : 0x8C8B, +INTERLEAVED_ATTRIBS : 0x8C8C, +SEPARATE_ATTRIBS : 0x8C8D, +TRANSFORM_FEEDBACK_BUFFER : 0x8C8E, +TRANSFORM_FEEDBACK_BUFFER_BINDING : 0x8C8F, +RGBA32UI : 0x8D70, +RGB32UI : 0x8D71, +RGBA16UI : 0x8D76, +RGB16UI : 0x8D77, +RGBA8UI : 0x8D7C, +RGB8UI : 0x8D7D, +RGBA32I : 0x8D82, +RGB32I : 0x8D83, +RGBA16I : 0x8D88, +RGB16I : 0x8D89, +RGBA8I : 0x8D8E, +RGB8I : 0x8D8F, +RED_INTEGER : 0x8D94, +RGB_INTEGER : 0x8D98, +RGBA_INTEGER : 0x8D99, +SAMPLER_2D_ARRAY : 0x8DC1, +SAMPLER_2D_ARRAY_SHADOW : 0x8DC4, +SAMPLER_CUBE_SHADOW : 0x8DC5, +UNSIGNED_INT_VEC2 : 0x8DC6, +UNSIGNED_INT_VEC3 : 0x8DC7, +UNSIGNED_INT_VEC4 : 0x8DC8, +INT_SAMPLER_2D : 0x8DCA, +INT_SAMPLER_3D : 0x8DCB, +INT_SAMPLER_CUBE : 0x8DCC, +INT_SAMPLER_2D_ARRAY : 0x8DCF, +UNSIGNED_INT_SAMPLER_2D : 0x8DD2, +UNSIGNED_INT_SAMPLER_3D : 0x8DD3, +UNSIGNED_INT_SAMPLER_CUBE : 0x8DD4, +UNSIGNED_INT_SAMPLER_2D_ARRAY : 0x8DD7, +DEPTH_COMPONENT32F : 0x8CAC, +DEPTH32F_STENCIL8 : 0x8CAD, +FLOAT_32_UNSIGNED_INT_24_8_REV : 0x8DAD, +FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING : 0x8210, +FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE : 0x8211, +FRAMEBUFFER_ATTACHMENT_RED_SIZE : 0x8212, +FRAMEBUFFER_ATTACHMENT_GREEN_SIZE : 0x8213, +FRAMEBUFFER_ATTACHMENT_BLUE_SIZE : 0x8214, +FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE : 0x8215, +FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE : 0x8216, +FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE : 0x8217, +FRAMEBUFFER_DEFAULT : 0x8218, +UNSIGNED_INT_24_8 : 0x84FA, +DEPTH24_STENCIL8 : 0x88F0, +UNSIGNED_NORMALIZED : 0x8C17, +DRAW_FRAMEBUFFER_BINDING : 0x8CA6, +READ_FRAMEBUFFER : 0x8CA8, +DRAW_FRAMEBUFFER : 0x8CA9, +READ_FRAMEBUFFER_BINDING : 0x8CAA, +RENDERBUFFER_SAMPLES : 0x8CAB, +FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER : 0x8CD4, +MAX_COLOR_ATTACHMENTS : 0x8CDF, +COLOR_ATTACHMENT1 : 0x8CE1, +COLOR_ATTACHMENT2 : 0x8CE2, +COLOR_ATTACHMENT3 : 0x8CE3, +COLOR_ATTACHMENT4 : 0x8CE4, +COLOR_ATTACHMENT5 : 0x8CE5, +COLOR_ATTACHMENT6 : 0x8CE6, +COLOR_ATTACHMENT7 : 0x8CE7, +COLOR_ATTACHMENT8 : 0x8CE8, +COLOR_ATTACHMENT9 : 0x8CE9, +COLOR_ATTACHMENT10 : 0x8CEA, +COLOR_ATTACHMENT11 : 0x8CEB, +COLOR_ATTACHMENT12 : 0x8CEC, +COLOR_ATTACHMENT13 : 0x8CED, +COLOR_ATTACHMENT14 : 0x8CEE, +COLOR_ATTACHMENT15 : 0x8CEF, +FRAMEBUFFER_INCOMPLETE_MULTISAMPLE : 0x8D56, +MAX_SAMPLES : 0x8D57, +HALF_FLOAT : 0x140B, +RG : 0x8227, +RG_INTEGER : 0x8228, +R8 : 0x8229, +RG8 : 0x822B, +R16F : 0x822D, +R32F : 0x822E, +RG16F : 0x822F, +RG32F : 0x8230, +R8I : 0x8231, +R8UI : 0x8232, +R16I : 0x8233, +R16UI : 0x8234, +R32I : 0x8235, +R32UI : 0x8236, +RG8I : 0x8237, +RG8UI : 0x8238, +RG16I : 0x8239, +RG16UI : 0x823A, +RG32I : 0x823B, +RG32UI : 0x823C, +VERTEX_ARRAY_BINDING : 0x85B5, +R8_SNORM : 0x8F94, +RG8_SNORM : 0x8F95, +RGB8_SNORM : 0x8F96, +RGBA8_SNORM : 0x8F97, +SIGNED_NORMALIZED : 0x8F9C, +COPY_READ_BUFFER : 0x8F36, +COPY_WRITE_BUFFER : 0x8F37, +COPY_READ_BUFFER_BINDING : 0x8F36, +COPY_WRITE_BUFFER_BINDING : 0x8F37, +UNIFORM_BUFFER : 0x8A11, +UNIFORM_BUFFER_BINDING : 0x8A28, +UNIFORM_BUFFER_START : 0x8A29, +UNIFORM_BUFFER_SIZE : 0x8A2A, +MAX_VERTEX_UNIFORM_BLOCKS : 0x8A2B, +MAX_FRAGMENT_UNIFORM_BLOCKS : 0x8A2D, +MAX_COMBINED_UNIFORM_BLOCKS : 0x8A2E, +MAX_UNIFORM_BUFFER_BINDINGS : 0x8A2F, +MAX_UNIFORM_BLOCK_SIZE : 0x8A30, +MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS : 0x8A31, +MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS : 0x8A33, +UNIFORM_BUFFER_OFFSET_ALIGNMENT : 0x8A34, +ACTIVE_UNIFORM_BLOCKS : 0x8A36, +UNIFORM_TYPE : 0x8A37, +UNIFORM_SIZE : 0x8A38, +UNIFORM_BLOCK_INDEX : 0x8A3A, +UNIFORM_OFFSET : 0x8A3B, +UNIFORM_ARRAY_STRIDE : 0x8A3C, +UNIFORM_MATRIX_STRIDE : 0x8A3D, +UNIFORM_IS_ROW_MAJOR : 0x8A3E, +UNIFORM_BLOCK_BINDING : 0x8A3F, +UNIFORM_BLOCK_DATA_SIZE : 0x8A40, +UNIFORM_BLOCK_ACTIVE_UNIFORMS : 0x8A42, +UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES : 0x8A43, +UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER : 0x8A44, +UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER : 0x8A46, +INVALID_INDEX : 0xFFFFFFFF, +MAX_VERTEX_OUTPUT_COMPONENTS : 0x9122, +MAX_FRAGMENT_INPUT_COMPONENTS : 0x9125, +MAX_SERVER_WAIT_TIMEOUT : 0x9111, +OBJECT_TYPE : 0x9112, +SYNC_CONDITION : 0x9113, +SYNC_STATUS : 0x9114, +SYNC_FLAGS : 0x9115, +SYNC_FENCE : 0x9116, +SYNC_GPU_COMMANDS_COMPLETE : 0x9117, +UNSIGNALED : 0x9118, +SIGNALED : 0x9119, +ALREADY_SIGNALED : 0x911A, +TIMEOUT_EXPIRED : 0x911B, +CONDITION_SATISFIED : 0x911C, +WAIT_FAILED : 0x911D, +SYNC_FLUSH_COMMANDS_BIT : 0x00000001, +TIMEOUT_IGNORED : -1, +VERTEX_ATTRIB_ARRAY_DIVISOR : 0x88FE, +ANY_SAMPLES_PASSED : 0x8C2F, +ANY_SAMPLES_PASSED_CONSERVATIVE : 0x8D6A, +SAMPLER_BINDING : 0x8919, +RGB10_A2UI : 0x906F, +INT_2_10_10_10_REV : 0x8D9F, +TRANSFORM_FEEDBACK : 0x8E22, +TRANSFORM_FEEDBACK_PAUSED : 0x8E23, +TRANSFORM_FEEDBACK_ACTIVE : 0x8E24, +TRANSFORM_FEEDBACK_BINDING : 0x8E25, +TEXTURE_IMMUTABLE_FORMAT : 0x912F, +MAX_ELEMENT_INDEX : 0x8D6B, +TEXTURE_IMMUTABLE_LEVELS : 0x82DF, + +/* WebGL-specific enums */ +MAX_CLIENT_WAIT_TIMEOUT_WEBGL: 0x9247 +}; + +// Other non-function properties on the WebGL object +var otherProperties = { +drawingBufferWidth : "number", +drawingBufferHeight : "number", +drawingBufferColorSpace : "string", +unpackColorSpace : "string", +canvas : "implementation-dependent" +}; + +// Properties to be ignored (as a list of strings) because they were +// added in versions of the spec that are backward-compatible with +// this version +var ignoredProperties = [ +]; + +// Constants removed from the WebGL spec compared to ES 3.0 +var removedConstants = { +BUFFER_ACCESS_FLAGS : 0x911F, +BUFFER_MAP_LENGTH : 0x9120, +BUFFER_MAP_OFFSET : 0x9121, +NUM_COMPRESSED_TEXTURE_FORMATS : 0x86A2, +FIXED : 0x140C, +ACTIVE_UNIFORM_MAX_LENGTH : 0x8B87, +ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH : 0x8A35, +ACTIVE_ATTRIBUTE_MAX_LENGTH : 0x8B8A, +EXTENSIONS : 0x1F03, +UNIFORM_NAME_LENGTH : 0x8A39, +UNIFORM_BLOCK_NAME_LENGTH : 0x8A41, +INFO_LOG_LENGTH : 0x8B84, +MAP_READ_BIT : 0x0001, +MAP_WRITE_BIT : 0x0002, +MAP_INVALIDATE_RANGE_BIT : 0x0004, +MAP_INVALIDATE_BUFFER_BIT : 0x0008, +MAP_FLUSH_EXPLICIT_BIT : 0x0010, +MAP_UNSYNCHRONIZED_BIT : 0x0020, +SHADER_SOURCE_LENGTH : 0x8B88, +SHADER_COMPILER : 0x8DFA, +SHADER_BINARY_FORMATS : 0x8DF8, +NUM_SHADER_BINARY_FORMATS : 0x8DF9, +TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH : 0x8C76, +FRAMEBUFFER_UNDEFINED : 0x8219, +PROGRAM_BINARY_RETRIEVABLE_HINT : 0x8257, +PROGRAM_BINARY_LENGTH : 0x8741, +PROGRAM_BINARY_FORMATS : 0x87FE, +NUM_PROGRAM_BINARY_FORMATS : 0x87FF, +TEXTURE_SWIZZLE_A : 0x8E45, +TEXTURE_SWIZZLE_B : 0x8E44, +TEXTURE_SWIZZLE_G : 0x8E43, +TEXTURE_SWIZZLE_R : 0x8E42, +PRIMITIVE_RESTART_FIXED_INDEX : 0x8D69, +}; + +function assertProperty(v, p) { + if (p in v) { + return true; + } else { + testFailed("Property does not exist: " + p) + return false; + } +} + +function assertNoProperty(v, p) { + if (p in v) { + testFailed("Property is defined and should not be: " + p) + return false; + } else { + return true; + } +} + +function assertMsg_(bool, msg) { + if (!bool) // show only failures to avoid spamming result list + assertMsg(bool, msg); + return bool; +} + +debug(""); +debug("Canvas.getContext"); + +var canvas = document.getElementById("canvas"); +var wtu = WebGLTestUtils; +var gl = wtu.create3DContext(canvas, null, 2); +var passed = true; +for (var i in constants) { + var r = assertProperty(gl, i) && assertMsg_(gl[i] == constants[i], "Property "+i+" value test "+gl[i]+" == "+constants[i]); + passed = passed && r; +} +if (passed) { + testPassed("All WebGL constants found to have correct values."); +} +passed = true; +for (var i in removedConstants) { + var r = assertNoProperty(gl, i); + passed = passed && r; +} +if (passed) { + testPassed("All constants removed from WebGL spec were absent from WebGL context."); +} +var extended = false; +for (var i in gl) { + if (constants[i] !== undefined) { + // OK; known constant + } else if (ignoredProperties.indexOf(i) != -1) { + // OK; constant that should be ignored because it was added in a later version of the spec + } else if (otherProperties[i] !== undefined && + (otherProperties[i] == "implementation-dependent" || typeof gl[i] == otherProperties[i])) { + // OK; known property of known type + } else if (typeof gl[i] != "function" && removedConstants[i] === undefined) { + if (!extended) { + extended = true; + testFailed("Also found the following extra properties:"); + } + testFailed(i); + } +} + +if (!extended) { + testPassed("No extra properties found on WebGL context."); +} + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-attributes-depth-stencil-antialias-obeyed.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-attributes-depth-stencil-antialias-obeyed.html new file mode 100644 index 0000000000..7cd91959f0 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-attributes-depth-stencil-antialias-obeyed.html @@ -0,0 +1,89 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<script> +"use strict"; + +function getWebGL(attribs) { + var canvas = document.createElement("canvas"); + if (!canvas) + return null; + + // We can't use wtu.create3DContext because it defaults to antialias=false. + var names = ["webgl2"]; + var gl = null; + for (var i = 0; i < names.length; ++i) { + try { + gl = canvas.getContext(names[i], attribs); + } catch (e) { + } + if (gl) { + break; + } + } + if (!gl) + return null; + return gl; +} + +function testAttribs(attribs) { + var antialias, depth, stencil; + if (!attribs) { + antialias = true; + depth = true; + stencil = false; + debug("Testing default attributes: { antialias: true, depth: true, stencil:false }"); + } else { + antialias = attribs.antialias; + depth = attribs.depth; + stencil = attribs.stencil; + debug("Testing specified attributes: { antialias: " + antialias + ", depth: " + depth + ", stencil: " + stencil + " }"); + } + var gl = getWebGL(attribs); + if (!gl) { + testFailed("Fail to create a context"); + return; + } + var actual_attribs = gl.getContextAttributes(); + if (antialias != actual_attribs.antialias) + testFailed("antialias = " + antialias + " is not obeyed") + if (depth != actual_attribs.depth) + testFailed("depth = " + depth + " is not obeyed") + if (stencil != actual_attribs.stencil) + testFailed("stencil = " + stencil + " is not obeyed") + if (antialias == actual_attribs.antialias && + depth == actual_attribs.depth && + stencil == actual_attribs.stencil) { + testPassed("Context created with the correct antialias, depth, and stencil."); + } +} + +description('Verify WebGLContextAttributes are working as specified, including depth, stencil, antialias'); +testAttribs(null); // Default attribs +testAttribs({antialias: true, depth: true, stencil: true}); +testAttribs({antialias: false, depth: true, stencil: true}); +testAttribs({antialias: true, depth: false, stencil: true}); +testAttribs({antialias: false, depth: false, stencil: true}); +testAttribs({antialias: true, depth: true, stencil: false}); +testAttribs({antialias: false, depth: true, stencil: false}); +testAttribs({antialias: true, depth: false, stencil: false}); +testAttribs({antialias: false, depth: false, stencil: false}); + +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-mode.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-mode.html new file mode 100644 index 0000000000..d896604c50 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-mode.html @@ -0,0 +1,56 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Canvas Context Mode Conformance Tests</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<script> +"use strict"; +description("This test ensures WebGL 2.0 implementations respect the canvas's context mode."); + +debug(""); + +assertMsg(window.WebGLRenderingContext, + "WebGL2RenderingContext should be a member of window"); +assertMsg('WebGL2RenderingContext' in window, + "WebGL2RenderingContext should be 'in' window"); + +function testContextMode(mode, altMode) { + debug("Testing " + mode + " context type"); + + let c = document.createElement('canvas'); + c.width = 2; + c.height = 2; + let gl = c.getContext(mode); + assertMsg(c.getContext(mode) == gl, + "Canvas.getContext('" + mode + "') should return the same value every time"); + try { + assertMsg(c.getContext(altMode) == null, + "Canvas.getContext('" + altMode + "') after getContext('" + mode + "') should return null"); + } catch (e) { + testFailed("Canvas.getContext('" + altMode + "') after getContext('" + mode + "') should not throw an exception"); + } +} + +testContextMode('webgl2', 'webgl'); +testContextMode('webgl', 'webgl2'); + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-resize-changes-buffer-binding-bug.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-resize-changes-buffer-binding-bug.html new file mode 100644 index 0000000000..e6682295a4 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-resize-changes-buffer-binding-bug.html @@ -0,0 +1,49 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Context Resize Bug Test</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<canvas id="test"></canvas> +<script> +"use strict"; +description("This test verifies canvas resize does not affect PIXEL_UNPACK_BUFFER binding."); + +var wtu = WebGLTestUtils; +var canvas = document.getElementById("test"); +var gl = wtu.create3DContext(canvas, null, 2); +if (!gl) { + testFailed("context does not exist"); +} else { + testPassed("context exists"); + var texture1= gl.createTexture(); + gl.bindTexture(gl.TEXTURE_3D, texture1); + var buffer0= gl.createBuffer(); + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buffer0); + + canvas.width = 682; + // Resizing canvas incorrectly cleared the PIXEL_UNPACK_BUFFER binding to 0 + // and caused a crash from the following line in Chrome. crbug.com/673929. + gl.texImage3D(gl.TEXTURE_3D, 1, gl.R8, 225,664 , 143, 0, + gl.LUMINANCE_ALPHA, gl.UNSIGNED_SHORT_4_4_4_4, 0x41414141); + testPassed("no crash from texImage3D"); +} +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-sharing-texture2darray-texture3d-data-bug.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-sharing-texture2darray-texture3d-data-bug.html new file mode 100644 index 0000000000..8ef6dd74b3 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-sharing-texture2darray-texture3d-data-bug.html @@ -0,0 +1,150 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>Multiple WebGL2 Context sharing texture2darray/texture3d data bug test</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<canvas id="canvas1" width="64" height="64"> </canvas> +<canvas id="canvas2" width="64" height="64"> </canvas> +<div id="console"></div> + +<!-- WebGL 2 Shaders --> +<script id="vs" type="x-shader/x-vertex">#version 300 es +precision mediump float; +in vec4 a_position; +in vec2 a_coord; +out vec2 v_coord; +void main() { + gl_Position = a_position; + v_coord = a_coord; +} +</script> + +<script id="fs_texture_3d" type="x-shader/x-fragment">#version 300 es +precision mediump float; +in vec2 v_coord; +uniform mediump sampler3D u_sampler; +out vec4 o_color; +void main () { + o_color = texture(u_sampler, vec3(v_coord, 0.0)); +} +</script> + +<script id="fs_texture_2d_array" type="x-shader/x-fragment">#version 300 es +precision mediump float; +in vec2 v_coord; +uniform mediump sampler2DArray u_sampler; +out vec4 o_color; +void main () { + o_color = texture(u_sampler, vec3(v_coord, 0.0)); +} +</script> + +<script> +"use strict"; +description("This test verifies that 2 different contexts both using 2d array texture or 3d texture does not share the texture data among them due to context save/restore bug. https://bugs.chromium.org/p/chromium/issues/detail?id=788448"); +debug(""); + +function render(gl, width, height, expectedColor, msg) { + wtu.setupUnitQuad(gl, 0, 1); + wtu.clearAndDrawUnitQuad(gl); + wtu.checkCanvasRect(gl, 0, 0, width, height, expectedColor, msg); +} + +function StateSetup(gl, texture_type, texture_color, width, height) { + + // create a buffer to hold texture data + const depth = 4; + var size = width * height * depth * 4; + var buf = new Uint8Array(size); + for (var i = 0; i < size; i += 4) { + buf[i + 0] = texture_color[0]; + buf[i + 1] = texture_color[1]; + buf[i + 2] = texture_color[2]; + buf[i + 3] = texture_color[3]; + } + gl.viewport(0, 0, width, height); + + // choose texture type and fragment shader type + var tex_type = gl.TEXTURE_2D; + var fragment_shader = "", vertex_shader = "vs"; + if(texture_type === "3d") { + tex_type = gl.TEXTURE_3D, fragment_shader = "fs_texture_3d"; + } else if(texture_type === "2d_array") { + tex_type = gl.TEXTURE_2D_ARRAY, fragment_shader = "fs_texture_2d_array"; + } else { + testFailed("Texture type must be 3d or 2darray"); + } + + var program = wtu.setupProgram(gl, [vertex_shader, fragment_shader], ['a_position', 'a_coord'], [0, 1]); + + // create a texture + var texture = gl.createTexture(); + gl.activeTexture(gl.TEXTURE0); + + // program texture parameters + gl.activeTexture(gl.TEXTURE0); + gl.bindTexture(tex_type, texture); + gl.texImage3D(tex_type, 0, gl.RGBA, width, height, depth, 0, gl.RGBA, gl.UNSIGNED_BYTE, buf); + gl.texParameteri(tex_type, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + gl.texParameteri(tex_type, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + + // bind sampler to the texture + var samplerLoc = gl.getUniformLocation(program, "u_sampler"); + gl.uniform1i(samplerLoc, 0); + + // flush all gl commands + gl.flush(); +} + +var wtu = WebGLTestUtils; +var canvas1 = document.getElementById("canvas1"); +var gl1 = wtu.create3DContext(canvas1, null, 2); //context1 + +var canvas2 = document.getElementById("canvas2"); +var gl2 = wtu.create3DContext(canvas2, null, 2); // context2 + +if (gl1 && gl2) +{ + testPassed("Created 2 WebGL2 context successfully"); + var red = [255, 0, 0, 255], green = [0,255,0,255], blue = [0,0,255,255]; + var width = 64, height = 64; + var texture_type = "3d", texture_color = green; + StateSetup(gl1,texture_type, texture_color, width, height);// context1 state setup + texture_color = red; + StateSetup(gl2, texture_type, texture_color, width, height);// context2 state setup + render(gl1, width, height, green, "Result pixels rendering from context1 with 3d texture should be green");// render context1 + + texture_type = "2d_array", texture_color = blue; + StateSetup(gl1, texture_type, texture_color, width, height);// context1 state setup + texture_color = green; + StateSetup(gl2, texture_type, texture_color, width, height);// context2 state setup + render(gl1, width, height, blue, "Result pixels rendering from context1 with 2darray texture should be blue");//render context1 +} +else if(!gl1) +{ + testFailed("Fail to get 1st WebGL2 context"); +} +else +{ + testFailed("Fail to get 2nd WebGL2 context"); +} + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-type-test-2.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-type-test-2.html new file mode 100644 index 0000000000..42ca0f3742 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/context-type-test-2.html @@ -0,0 +1,80 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Canvas Conformance Tests</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<canvas id="canvas1" style="width: 50px; height: 50px;"> </canvas> +<canvas id="canvas2" style="width: 50px; height: 50px;"> </canvas> +<script> +"use strict"; +description("This test ensures WebGL2 implementations interact correctly with the canvas tag."); + +debug(""); +debug("Canvas.getContext"); + +function runTest() { + assertMsg(window.WebGL2RenderingContext, + "WebGL2RenderingContext should be a member of window"); + assertMsg('WebGL2RenderingContext' in window, + "WebGL2RenderingContext should be 'in' window"); + + const wtu = WebGLTestUtils; + let canvas2 = document.getElementById("canvas2"); + let gl2 = wtu.create3DContext(canvas2, null, 2); + if (!gl2) { + testFailed("Could not fetch WebGL 2.0 context"); + return; + } + testPassed("Fetched WebGL2 context successfully"); + + debug("Checking WebGL2 context type"); + assertMsg(gl2 instanceof WebGL2RenderingContext, + "context type should be WebGL2RenderingContext"); + + // WebGL1 contexts do not respond to the WebGL2 context type, and vice versa. + let canvas1 = document.getElementById("canvas1"); + let gl1 = wtu.create3DContext(canvas1, null, 1); + if (!gl1) { + testFailed("Could not fetch WebGL 1.0 context"); + return; + } + + debug("Checking WebGL1 context type"); + assertMsg(gl1 instanceof WebGLRenderingContext, + "context type should be WebGLRenderingContext"); + + let msg1 = "A canvas which has created a WebGL 1.0 context should not return it for a 'webgl2' context request"; + if (canvas1.getContext("webgl2")) + testFailed(msg1); + else + testPassed(msg1); + + let msg2 = "A canvas which has created a WebGL 2.0 context should not return it for a 'webgl' context request"; + if (canvas2.getContext("webgl")) + testFailed(msg2); + else + testPassed(msg2); +} + +runTest(); +debug(""); + +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/incorrect-context-object-behaviour.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/incorrect-context-object-behaviour.html new file mode 100644 index 0000000000..3f0b54fc6e --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/incorrect-context-object-behaviour.html @@ -0,0 +1,230 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> + +<script id="tf-vshader" type="x-shader/x-vertex">#version 300 es +in uint in_data; +flat out uint out_data; +void main() { + out_data = in_data; +} +</script> +<script id="tf-fshader" type="x-shader/x-fragment">#version 300 es +void main() {} +</script> + +<script> +"use strict"; +description("Tests calling WebGL 2.0 APIs with objects from other contexts"); + +function loadTFProgram(context) { + const tfProgram = wtu.setupTransformFeedbackProgram(context, ["tf-vshader", "tf-fshader"], + ["out_data"], context.SEPARATE_ATTRIBS, + ["in_data"]); + wtu.glErrorShouldBe(context, context.NO_ERROR, "linking transform feedback shader should not set an error"); + return tfProgram; +} + +function create2DTextureArray4x4x4(context) { + const texture = context.createTexture(); + context.bindTexture(context.TEXTURE_2D_ARRAY, texture); + context.texImage3D(context.TEXTURE_2D_ARRAY, 0, context.RGBA8, 4, 4, 4, 0, context.RGBA, context.UNSIGNED_BYTE, null); + wtu.glErrorShouldBe(context, context.NO_ERROR, "allocating 2D texture array should not set an error"); + return texture; +} + +var wtu = WebGLTestUtils; +var contextA = wtu.create3DContext(undefined, undefined, 2); +var contextB = wtu.create3DContext(undefined, undefined, 2); +var bufferA = contextA.createBuffer(); +var bufferB = contextB.createBuffer(); +var frameBufferA = contextA.createFramebuffer(); +var frameBufferB = contextB.createFramebuffer(); +var programB = wtu.loadStandardProgram(contextB); +var queryB = contextB.createQuery(); +var samplerA = contextA.createSampler(); +var samplerB = contextB.createSampler(); +var syncB = contextB.fenceSync(contextB.SYNC_GPU_COMMANDS_COMPLETE, 0); +var transformFeedbackA = contextA.createTransformFeedback(); +var transformFeedbackB = contextB.createTransformFeedback(); +var vertexArrayA = contextA.createVertexArray(); +var vertexArrayB = contextB.createVertexArray(); +var tfProgramB = loadTFProgram(contextB); +var texture2DArrayA = create2DTextureArray4x4x4(contextA); +var texture2DArrayB = create2DTextureArray4x4x4(contextB); +var locationB = contextB.getUniformLocation(programB, 'u_modelViewProjMatrix'); +var uniformData = []; + +function generateFloat32Array(length) { + uniformData = new Float32Array(length); +} + +function generateFloatArray(length) { + uniformData = new Array(length); + for (var i = 0; i < length; i++) { + uniformData[i] = 0.0; + } +} + +function generateInt32Array(length) { + uniformData = new Int32Array(length); +} + +function generateIntArray(length) { + uniformData = new Array(length); + for (var i = 0; i < length; i++) { + uniformData[i] = 0; + } +} + +function generateUint32Array(length) { + uniformData = new Uint32Array(length); +} + +// Make the bindable objects valid in both contexts first. +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindBuffer(contextA.ARRAY_BUFFER, bufferA)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindBuffer(contextA.ARRAY_BUFFER, null)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindBuffer(contextB.ARRAY_BUFFER, bufferB)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindBuffer(contextB.ARRAY_BUFFER, null)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindTransformFeedback(contextA.TRANSFORM_FEEDBACK, transformFeedbackA)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindTransformFeedback(contextA.TRANSFORM_FEEDBACK, null)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindTransformFeedback(contextB.TRANSFORM_FEEDBACK, transformFeedbackB)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindTransformFeedback(contextB.TRANSFORM_FEEDBACK, null)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindVertexArray(vertexArrayA)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindVertexArray(null)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindVertexArray(vertexArrayB)"); +wtu.shouldGenerateGLError(contextB, contextB.NO_ERROR, "contextB.bindVertexArray(null)"); + +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.bindFramebuffer(contextA.FRAMEBUFFER, frameBufferA)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.framebufferTextureLayer(contextA.FRAMEBUFFER, contextA.COLOR_ATTACHMENT0, texture2DArrayB, 0, 0)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getFragDataLocation(tfProgramB, 'nonexistent_variable')"); +// Unsigned int uniforms + wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1ui(locationB, 0)"); +generateUint32Array(1); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1uiv(locationB, uniformData)"); +generateIntArray(1); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1uiv(locationB, uniformData)"); + wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2ui(locationB, 0, 0)"); +generateUint32Array(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2uiv(locationB, uniformData)"); +generateIntArray(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2uiv(locationB, uniformData)"); + wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3ui(locationB, 0, 0, 0)"); +generateUint32Array(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3uiv(locationB, uniformData)"); +generateIntArray(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3uiv(locationB, uniformData)"); + wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4ui(locationB, 0, 0, 0, 0)"); +generateUint32Array(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4uiv(locationB, uniformData)"); +generateIntArray(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4uiv(locationB, uniformData)"); +// New uniform entry points with offsets +generateFloat32Array(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1fv(locationB, uniformData, 1)"); +generateFloatArray(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1fv(locationB, uniformData, 1)"); +generateInt32Array(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1iv(locationB, uniformData, 1)"); +generateIntArray(2); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform1iv(locationB, uniformData, 1)"); +generateFloat32Array(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2fv(locationB, uniformData, 1)"); +generateFloatArray(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2fv(locationB, uniformData, 1)"); +generateInt32Array(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2iv(locationB, uniformData, 1)"); +generateIntArray(3); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform2iv(locationB, uniformData, 1)"); +generateFloat32Array(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3fv(locationB, uniformData, 1)"); +generateFloatArray(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3fv(locationB, uniformData, 1)"); +generateInt32Array(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3iv(locationB, uniformData, 1)"); +generateIntArray(4); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform3iv(locationB, uniformData, 1)"); +generateFloat32Array(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4fv(locationB, uniformData, 1)"); +generateFloatArray(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4fv(locationB, uniformData, 1)"); +generateInt32Array(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4iv(locationB, uniformData, 1)"); +generateIntArray(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniform4iv(locationB, uniformData, 1)"); +generateFloat32Array(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2fv(locationB, false, uniformData, 1)"); +generateFloatArray(5); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2fv(locationB, false, uniformData, 1)"); +generateFloat32Array(10); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3fv(locationB, false, uniformData, 1)"); +generateFloatArray(10); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3fv(locationB, false, uniformData, 1)"); +generateFloat32Array(17); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4fv(locationB, false, uniformData, 1)"); +generateFloatArray(17); wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4fv(locationB, false, uniformData, 1)"); +// Non-rectangular matrix uniform entry points +generateFloat32Array(6); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3x2fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2x3fv(locationB, false, uniformData)"); +generateFloatArray(6); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3x2fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2x3fv(locationB, false, uniformData)"); +generateFloat32Array(8); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4x2fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2x4fv(locationB, false, uniformData)"); +generateFloatArray(8); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4x2fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix2x4fv(locationB, false, uniformData)"); +generateFloat32Array(12); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4x3fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3x4fv(locationB, false, uniformData)"); +generateFloatArray(12); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix4x3fv(locationB, false, uniformData)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformMatrix3x4fv(locationB, false, uniformData)"); + +// Query objects +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.deleteQuery(queryB)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.isQuery(queryB)"); +shouldBeFalse("contextA.isQuery(queryB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.beginQuery(contextA.ANY_SAMPLES_PASSED, queryB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getQueryParameter(queryB, contextA.QUERY_RESULT_AVAILABLE)"); + +// Sampler objects +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.deleteSampler(samplerB)"); +wtu.shouldGenerateGLError(contextB, contextB.INVALID_OPERATION, "contextB.deleteSampler(samplerA)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.bindSampler(0, samplerB)"); +wtu.shouldGenerateGLError(contextB, contextB.INVALID_OPERATION, "contextB.bindSampler(0, samplerA)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.isSampler(samplerB)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextB.isSampler(samplerA)"); +shouldBeFalse("contextA.isSampler(samplerB)"); +shouldBeFalse("contextB.isSampler(samplerA)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.samplerParameteri(samplerB, contextA.TEXTURE_WRAP_S, contextA.CLAMP_TO_EDGE)"); +wtu.shouldGenerateGLError(contextB, contextB.INVALID_OPERATION, "contextB.samplerParameteri(samplerA, contextB.TEXTURE_WRAP_S, contextB.CLAMP_TO_EDGE)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.samplerParameterf(samplerB, contextA.TEXTURE_MIN_LOD, -500.5)"); +wtu.shouldGenerateGLError(contextB, contextB.INVALID_OPERATION, "contextB.samplerParameterf(samplerA, contextB.TEXTURE_MIN_LOD, -500.5)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getSamplerParameter(samplerB, contextA.TEXTURE_WRAP_S)"); +wtu.shouldGenerateGLError(contextB, contextB.INVALID_OPERATION, "contextB.getSamplerParameter(samplerA, contextB.TEXTURE_WRAP_S)"); + +// Sync objects +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.deleteSync(syncB)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.isSync(syncB)"); +shouldBeFalse("contextA.isSync(syncB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.clientWaitSync(syncB, 0, 0)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.waitSync(syncB, 0, contextA.TIMEOUT_IGNORED)"); + +// Transform feedback +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.deleteTransformFeedback(transformFeedbackB)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.isTransformFeedback(transformFeedbackB)"); +shouldBeFalse("contextA.isTransformFeedback(transformFeedbackB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.bindTransformFeedback(contextA.TRANSFORM_FEEDBACK, transformFeedbackB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.transformFeedbackVaryings(tfProgramB, ['out_data'], contextA.SEPARATE_ATTRIBS)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getTransformFeedbackVarying(tfProgramB, 0)"); + +// Uniform buffer objects and transform feedback buffers +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.bindBufferBase(contextA.UNIFORM_BUFFER, 0, bufferB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.bindBufferRange(contextA.UNIFORM_BUFFER, 0, bufferB, 0, 4)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getUniformIndices(programB, ['u_modelViewProjMatrix'])"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getActiveUniforms(programB, [0], contextA.UNIFORM_TYPE)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getUniformBlockIndex(programB, 'nonexistent_uniform_block_name')"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getActiveUniformBlockParameter(programB, 0, contextA.UNIFORM_BLOCK_BINDING)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.getActiveUniformBlockName(programB, 0)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.uniformBlockBinding(programB, 0, 0)"); + +// Vertex Array objects +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.deleteVertexArray(vertexArrayB)"); +wtu.shouldGenerateGLError(contextA, contextA.NO_ERROR, "contextA.isVertexArray(vertexArrayB)"); +shouldBeFalse("contextA.isVertexArray(vertexArrayB)"); +wtu.shouldGenerateGLError(contextA, contextA.INVALID_OPERATION, "contextA.bindVertexArray(vertexArrayB)"); + +var successfullyParsed = true; +</script> + +<script src="../../js/js-test-post.js"></script> +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/methods-2.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/methods-2.html new file mode 100644 index 0000000000..a389329aa3 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/methods-2.html @@ -0,0 +1,268 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Methods Test</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +<script src="../../js/tests/context-methods.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<canvas id="canvas" style="width: 50px; height: 50px;"> </canvas> +<script> +"use strict"; +description("This test ensures that the WebGL context has all the methods in the specification."); + +const methods = [ + "getContextAttributes", + "activeTexture", + "attachShader", + "bindAttribLocation", + "bindBuffer", + "bindFramebuffer", + "bindRenderbuffer", + "bindTexture", + "blendColor", + "blendEquation", + "blendEquationSeparate", + "blendFunc", + "blendFuncSeparate", + "bufferData", + "bufferSubData", + "checkFramebufferStatus", + "clear", + "clearColor", + "clearDepth", + "clearStencil", + "colorMask", + "compileShader", + "compressedTexImage2D", + "compressedTexSubImage2D", + "copyTexImage2D", + "copyTexSubImage2D", + "createBuffer", + "createFramebuffer", + "createProgram", + "createRenderbuffer", + "createShader", + "createTexture", + "cullFace", + "deleteBuffer", + "deleteFramebuffer", + "deleteProgram", + "deleteRenderbuffer", + "deleteShader", + "deleteTexture", + "depthFunc", + "depthMask", + "depthRange", + "detachShader", + "disable", + "disableVertexAttribArray", + "drawArrays", + "drawElements", + "enable", + "enableVertexAttribArray", + "finish", + "flush", + "framebufferRenderbuffer", + "framebufferTexture2D", + "frontFace", + "generateMipmap", + "getActiveAttrib", + "getActiveUniform", + "getAttachedShaders", + "getAttribLocation", + "getParameter", + "getBufferParameter", + "getError", + "getExtension", + "getFramebufferAttachmentParameter", + "getProgramParameter", + "getProgramInfoLog", + "getRenderbufferParameter", + "getShaderParameter", + "getShaderInfoLog", + "getShaderPrecisionFormat", + "getShaderSource", + "getSupportedExtensions", + "getTexParameter", + "getUniform", + "getUniformLocation", + "getVertexAttrib", + "getVertexAttribOffset", + "hint", + "isBuffer", + "isContextLost", + "isEnabled", + "isFramebuffer", + "isProgram", + "isRenderbuffer", + "isShader", + "isTexture", + "lineWidth", + "linkProgram", + "pixelStorei", + "polygonOffset", + "readPixels", + "renderbufferStorage", + "sampleCoverage", + "scissor", + "shaderSource", + "stencilFunc", + "stencilFuncSeparate", + "stencilMask", + "stencilMaskSeparate", + "stencilOp", + "stencilOpSeparate", + "texImage2D", + "texParameterf", + "texParameteri", + "texSubImage2D", + "uniform1f", + "uniform1fv", + "uniform1i", + "uniform1iv", + "uniform2f", + "uniform2fv", + "uniform2i", + "uniform2iv", + "uniform3f", + "uniform3fv", + "uniform3i", + "uniform3iv", + "uniform4f", + "uniform4fv", + "uniform4i", + "uniform4iv", + "uniformMatrix2fv", + "uniformMatrix3fv", + "uniformMatrix4fv", + "useProgram", + "validateProgram", + "vertexAttrib1f", + "vertexAttrib1fv", + "vertexAttrib2f", + "vertexAttrib2fv", + "vertexAttrib3f", + "vertexAttrib3fv", + "vertexAttrib4f", + "vertexAttrib4fv", + "vertexAttribPointer", + "viewport", + + // WebGL2 methods + "getBufferSubData", + "copyBufferSubData", + "blitFramebuffer", + "framebufferTextureLayer", + "getInternalformatParameter", + "invalidateFramebuffer", + "invalidateSubFramebuffer", + "readBuffer", + "renderbufferStorageMultisample", + "texImage3D", + "texStorage2D", + "texStorage3D", + "texSubImage3D", + "copyTexSubImage3D", + "compressedTexImage3D", + "compressedTexSubImage3D", + "getFragDataLocation", + "uniform1ui", + "uniform2ui", + "uniform3ui", + "uniform4ui", + "uniform1uiv", + "uniform2uiv", + "uniform3uiv", + "uniform4uiv", + "uniformMatrix2x3fv", + "uniformMatrix3x2fv", + "uniformMatrix2x4fv", + "uniformMatrix4x2fv", + "uniformMatrix3x4fv", + "uniformMatrix4x3fv", + "vertexAttribI4i", + "vertexAttribI4iv", + "vertexAttribI4ui", + "vertexAttribI4uiv", + "vertexAttribIPointer", + "vertexAttribDivisor", + "drawArraysInstanced", + "drawElementsInstanced", + "drawRangeElements", + "drawBuffers", + "clearBufferiv", + "clearBufferuiv", + "clearBufferfv", + "clearBufferfi", + "createQuery", + "deleteQuery", + "isQuery", + "beginQuery", + "endQuery", + "getQuery", + "getQueryParameter", + "createSampler", + "deleteSampler", + "isSampler", + "bindSampler", + "samplerParameteri", + "samplerParameterf", + "getSamplerParameter", + "fenceSync", + "isSync", + "deleteSync", + "clientWaitSync", + "waitSync", + "getSyncParameter", + "createTransformFeedback", + "deleteTransformFeedback", + "isTransformFeedback", + "bindTransformFeedback", + "beginTransformFeedback", + "endTransformFeedback", + "transformFeedbackVaryings", + "getTransformFeedbackVarying", + "pauseTransformFeedback", + "resumeTransformFeedback", + "bindBufferBase", + "bindBufferRange", + "getIndexedParameter", + "getUniformIndices", + "getActiveUniforms", + "getUniformBlockIndex", + "getActiveUniformBlockParameter", + "getActiveUniformBlockName", + "uniformBlockBinding", + "createVertexArray", + "deleteVertexArray", + "isVertexArray", + "bindVertexArray", +]; + +debug(""); +debug("Canvas.getContext"); + +const wtu = WebGLTestUtils; +const canvas = document.getElementById("canvas"); +const gl = wtu.create3DContext(canvas, null, 2); + +testContextMethods(gl, methods); + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/context/no-experimental-webgl2.html b/dom/canvas/test/webgl-conf/checkout/conformance2/context/no-experimental-webgl2.html new file mode 100644 index 0000000000..65aa9cb16d --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/context/no-experimental-webgl2.html @@ -0,0 +1,35 @@ +<!-- +Copyright (c) 2019 The Khronos Group Inc. +Use of this source code is governed by an MIT-style license that can be +found in the LICENSE.txt file. +--> + +<!DOCTYPE html> +<html> +<head> +<meta charset="utf-8"> +<title>WebGL2 Canvas Conformance Tests</title> +<link rel="stylesheet" href="../../resources/js-test-style.css"/> +<script src="../../js/js-test-pre.js"></script> +<script src="../../js/webgl-test-utils.js"></script> +</head> +<body> +<div id="description"></div> +<div id="console"></div> +<canvas id="canvas" style="width: 50px; height: 50px;"> </canvas> +<canvas id="canvas2d" width="40" height="40"> </canvas> +<script> +"use strict"; +description("This test ensures WebGL2 implementations do not respond to experimental-webgl2."); + +debug(""); + +var canvas = document.getElementById("canvas"); +shouldBeNull('canvas.getContext("experimental-webgl2")'); +debug(""); +var successfullyParsed = true; +</script> +<script src="../../js/js-test-post.js"></script> + +</body> +</html> |