dom/canvas/test/webgl-conf/checkout/conformance/attribs/gl-vertexattribpointer.html

   1 <!--
   2 Copyright (c) 2019 The Khronos Group Inc.
   3 Use of this source code is governed by an MIT-style license that can be
   4 found in the LICENSE.txt file.
   5 -->
   6
   7 <!DOCTYPE html>
   8 <html>
   9 <head>
  10 <meta charset="utf-8">
  11 <title>WebGL vertexAttribPointer Conformance Tests</title>
  12 <link rel="stylesheet" href="../../resources/js-test-style.css"/>
  13 <script src="../../js/js-test-pre.js"></script>
  14 <script src="../../js/webgl-test-utils.js"></script>
  15 </head>
  16 <body>
  17 <div id="description"></div>
  18 <div id="console"></div>
  19 <canvas id="canvas" width="2" height="2"> </canvas>
  20 <script>
  21 "use strict";
  22 description("This test checks vertexAttribPointer behaviors in WebGL.");
  23
  24 debug("");
  25 debug("Canvas.getContext");
  26
  27 var wtu = WebGLTestUtils;
  28 var gl = wtu.create3DContext("canvas");
  29 if (!gl) {
  30   testFailed("context does not exist");
  31 } else {
  32   testPassed("context exists");
  33
  34   debug("");
  35   debug("Checking gl.vertexAttribPointer.");
  36
  37   if (!gl.FIXED) {
  38     gl.FIXED = 0x140C;
  39   }
  40
  41   var vertexObject = gl.createBuffer();
  42   gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject);
  43   gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(0), gl.STATIC_DRAW);
  44
  45
  46   gl.bindBuffer(gl.ARRAY_BUFFER, null);
  47   gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 4);
  48   wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION,
  49       "vertexAttribPointer should fail if no buffer is bound and `offset` is non-zero.");
  50
  51   gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject);
  52   gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0);
  53   wtu.glErrorShouldBe(gl, gl.NO_ERROR);
  54
  55   gl.bindBuffer(gl.ARRAY_BUFFER, null);
  56   gl.vertexAttribPointer(0, 1, gl.FLOAT, false, 0, 0);
  57   wtu.glErrorShouldBe(gl, gl.NO_ERROR,
  58       "vertexAttribPointer should succeed if no buffer is bound and `offset` is zero.");
  59
  60   gl.bindBuffer(gl.ARRAY_BUFFER, vertexObject);
  61
  62
  63   if (wtu.getDefault3DContextVersion() < 2) {
  64     gl.vertexAttribPointer(0, 1, gl.INT, 0, 0, 0);
  65     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM,
  66             "vertexAttribPointer should not support INT");
  67     gl.vertexAttribPointer(0, 1, gl.UNSIGNED_INT, 0, 0, 0);
  68     wtu.glErrorShouldBe(gl, gl.INVALID_ENUM,
  69             "vertexAttribPointer should not support UNSIGNED_INT");
  70   }
  71   gl.vertexAttribPointer(0, 1, gl.FIXED, 0, 0, 0);
  72   wtu.glErrorShouldBe(gl, gl.INVALID_ENUM,
  73           "vertexAttribPointer should not support FIXED");
  74
  75   var checkVertexAttribPointer = function(
  76       gl, err, reason, size, type, normalize, stride, offset) {
  77     gl.vertexAttribPointer(0, size, type, normalize, stride, offset);
  78     var succeeded = (err == gl.NO_ERROR);
  79     wtu.glErrorShouldBe(gl, err,
  80         "gl.vertexAttribPointer(0, " + size +
  81         ", gl." + wtu.glEnumToString(gl, type) +
  82         ", " + normalize +
  83         ", " + stride +
  84         ", " + offset +
  85         ") should " + (succeeded ? "succeed " : "fail ") + reason);
  86     if (succeeded) {
  87       shouldBe('gl.getVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_SIZE)', size.toString());
  88       shouldBe('gl.getVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_TYPE)', 'gl.' + wtu.glEnumToString(gl, type));
  89       shouldBe('gl.getVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_NORMALIZED)', normalize.toString());
  90       shouldBe('gl.getVertexAttrib(0, gl.VERTEX_ATTRIB_ARRAY_STRIDE)', stride.toString());
  91       shouldBe('gl.getVertexAttribOffset(0, gl.VERTEX_ATTRIB_ARRAY_POINTER)', offset.toString());
  92     }
  93   }
  94
  95   var types = [
  96     { type:gl.BYTE,           bytesPerComponent: 1 },
  97     { type:gl.UNSIGNED_BYTE,  bytesPerComponent: 1 },
  98     { type:gl.SHORT,          bytesPerComponent: 2 },
  99     { type:gl.UNSIGNED_SHORT, bytesPerComponent: 2 },
 100     { type:gl.FLOAT,          bytesPerComponent: 4 },
 101   ];
 102
 103   if (wtu.getDefault3DContextVersion() >= 2) {
 104     types.push(...[
 105         { type:gl.INT,                         bytesPerComponent: 4 },
 106         { type:gl.UNSIGNED_INT,                bytesPerComponent: 4 },
 107         { type:gl.HALF_FLOAT,                  bytesPerComponent: 2 },
 108         { type:gl.INT_2_10_10_10_REV,          bytesPerComponent: 4, minSize: 4 },
 109         { type:gl.UNSIGNED_INT_2_10_10_10_REV, bytesPerComponent: 4, minSize: 4 },
 110       ]);
 111   }
 112
 113   for (var ii = 0; ii < types.length; ++ii) {
 114     var info = types[ii];
 115     debug("");
 116     for (var size = 1; size <= 4; ++size) {
 117       debug("");
 118       debug("checking: " + wtu.glEnumToString(gl, info.type) + " with size " + size);
 119       var bytesPerElement = size * info.bytesPerComponent;
 120       var offsetSet = [
 121           0,
 122           1,
 123           info.bytesPerComponent - 1,
 124           info.bytesPerComponent,
 125           info.bytesPerComponent + 1,
 126           info.bytesPerComponent * 2];
 127       for (var jj = 0; jj < offsetSet.length; ++jj) {
 128         var offset = offsetSet[jj];
 129         for (var kk = 0; kk < offsetSet.length; ++kk) {
 130           var stride = offsetSet[kk];
 131           var err = gl.NO_ERROR;
 132           var reason = ""
 133           if (offset % info.bytesPerComponent != 0) {
 134             reason = "because offset is bad";
 135             err = gl.INVALID_OPERATION;
 136           }
 137           if (stride % info.bytesPerComponent != 0) {
 138             reason = "because stride is bad";
 139             err = gl.INVALID_OPERATION;
 140           }
 141           if (size < info.minSize) {
 142             reason = "because size < minSize";
 143             err = gl.INVALID_OPERATION;
 144           }
 145           checkVertexAttribPointer(
 146               gl, err, reason, size, info.type, false, stride, offset);
 147         }
 148         var stride = Math.floor(255 / info.bytesPerComponent) * info.bytesPerComponent;
 149
 150         if (offset == 0) {
 151           checkVertexAttribPointer(
 152               gl, size < info.minSize ? gl.INVALID_OPERATION : gl.NO_ERROR, "at stride limit",
 153               size, info.type, false, stride, offset);
 154           checkVertexAttribPointer(
 155               gl, size < info.minSize ? [gl.INVALID_OPERATION, gl.INVALID_VALUE] : gl.INVALID_VALUE, "over stride limit",
 156               size, info.type, false,
 157               stride + info.bytesPerComponent, offset);
 158         }
 159       }
 160     }
 161   }
 162 }
 163
 164 debug("");
 165 var successfullyParsed = true;
 166
 167 </script>
 168 <script src="../../js/js-test-post.js"></script>
 169
 170 </body>
 171 </html>