| OLD | NEW |
|---|
| (Empty) | |
| 1 <!-- |
| 2 Copyright (c) 2011 The Chromium Authors. All rights reserved. |
| 3 Use of this source code is governed by a BSD-style license that can be |
| 4 found in the LICENSE file. |
| 5 --> |
| 6 <!DOCTYPE html> |
| 7 <html> |
| 8 <head> |
| 9 <meta charset="utf-8"> |
| 10 <title>WebGL texture size cube map conformance test.</title> |
| 11 <link rel="stylesheet" href="../../resources/js-test-style.css"/> |
| 12 <script src="../../resources/js-test-pre.js"></script> |
| 13 <script src="../resources/webgl-test.js"> </script> |
| 14 <script src="../resources/webgl-test-utils.js"></script> |
| 15 </head> |
| 16 <body> |
| 17 <canvas id="example" width="256" height="256" style="width: 40px; height: 40px;"
></canvas> |
| 18 <div id="description"></div> |
| 19 <div id="console"></div> |
| 20 <script id="vshader" type="x-shader/x-vertex"> |
| 21 attribute vec4 vPosition; |
| 22 uniform mat4 rotation; |
| 23 varying vec3 texCoord; |
| 24 void main() |
| 25 { |
| 26 gl_Position = vPosition; |
| 27 vec4 direction = vec4(vPosition.x * 0.5, vPosition.y * 0.5, 1, 1); |
| 28 texCoord = normalize((rotation * direction).xyz); |
| 29 } |
| 30 </script> |
| 31 |
| 32 <script id="fshader" type="x-shader/x-fragment"> |
| 33 precision mediump float; |
| 34 uniform samplerCube tex; |
| 35 varying vec3 texCoord; |
| 36 void main() |
| 37 { |
| 38 gl_FragColor = textureCube(tex, normalize(texCoord)); |
| 39 } |
| 40 </script> |
| 41 <script> |
| 42 var canvas; |
| 43 description("Checks issues with size of cube map textures"); |
| 44 debug(""); |
| 45 |
| 46 var wtu = WebGLTestUtils; |
| 47 canvas = document.getElementById("example"); |
| 48 |
| 49 gl = wtu.create3DContext(canvas); |
| 50 wtu.setupUnitQuad(gl, 0, 1); |
| 51 var program = wtu.setupProgram( |
| 52 gl, |
| 53 [wtu.loadShaderFromScript(gl, 'vshader', gl.VERTEX_SHADER), |
| 54 wtu.loadShaderFromScript(gl, 'fshader', gl.FRAGMENT_SHADER)], |
| 55 ['vPosition', 'texCoord0'], [0, 1]); |
| 56 var rotLoc = gl.getUniformLocation(program, "rotation"); |
| 57 |
| 58 gl.disable(gl.DEPTH_TEST); |
| 59 gl.disable(gl.BLEND); |
| 60 |
| 61 var maxSize = gl.getParameter(gl.MAX_CUBE_MAP_TEXTURE_SIZE); |
| 62 debug("max cube map size: " + maxSize); |
| 63 maxSize = Math.min(512, maxSize); |
| 64 |
| 65 // a cube map of 512x512 takes 6meg. I'm assuming it's not |
| 66 // unreasonable to expect to be able to allocate a 6meg texture |
| 67 |
| 68 var colors = [ |
| 69 {name: 'red', color: [255, 0, 0, 255]}, |
| 70 {name: 'green', color: [ 0, 255, 0, 255]}, |
| 71 {name: 'blue', color: [ 0, 0, 255, 255]}, |
| 72 {name: 'yellow', color: [255, 255, 0, 255]}, |
| 73 {name: 'cyan', color: [ 0, 255, 255, 255]}, |
| 74 {name: 'magenta', color: [255, 0, 255, 255]} |
| 75 ]; |
| 76 |
| 77 var targets = [ |
| 78 gl.TEXTURE_CUBE_MAP_POSITIVE_X, |
| 79 gl.TEXTURE_CUBE_MAP_NEGATIVE_X, |
| 80 gl.TEXTURE_CUBE_MAP_POSITIVE_Y, |
| 81 gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, |
| 82 gl.TEXTURE_CUBE_MAP_POSITIVE_Z, |
| 83 gl.TEXTURE_CUBE_MAP_NEGATIVE_Z]; |
| 84 |
| 85 var rotations = [ |
| 86 {axis: [0, 1, 0], angle: Math.PI / 2}, |
| 87 {axis: [0, 1, 0], angle: -Math.PI / 2}, |
| 88 {axis: [1, 0, 0], angle: -Math.PI / 2}, |
| 89 {axis: [1, 0, 0], angle: Math.PI / 2}, |
| 90 {axis: [0, 1, 0], angle: 0}, |
| 91 {axis: [0, 1, 0], angle: Math.PI}, |
| 92 ]; |
| 93 |
| 94 var halfRotations = [ |
| 95 {colors: [3, 4], rotations: [{axis: [1, 0, 0], angle: Math.PI / 4}]}, |
| 96 {colors: [4, 2], rotations: [{axis: [1, 0, 0], angle: -Math.PI / 4}]}, |
| 97 {colors: [5, 3], rotations: [{axis: [1, 0, 0], angle: Math.PI / 4 * 3}]}, |
| 98 {colors: [2, 5], rotations: [{axis: [1, 0, 0], angle: -Math.PI / 4 * 3}]}, |
| 99 {colors: [3, 0], rotations: [{axis: [0, 1, 0], angle: Math.PI / 2}, |
| 100 {axis: [1, 0, 0], angle: Math.PI / 4}]}, |
| 101 {colors: [0, 2], rotations: [{axis: [0, 1, 0], angle: Math.PI / 2}, |
| 102 {axis: [1, 0, 0], angle: -Math.PI / 4}]}, |
| 103 ]; |
| 104 |
| 105 var count = 0; |
| 106 var sizeCount = 0; |
| 107 |
| 108 test(); |
| 109 |
| 110 function test() { |
| 111 var size = Math.pow(2, sizeCount); |
| 112 if (size > maxSize || !testSize(size)) { |
| 113 finishTest(); |
| 114 } else { |
| 115 ++sizeCount; |
| 116 setTimeout(test, 100); |
| 117 } |
| 118 } |
| 119 |
| 120 function testSize(size) { |
| 121 debug(""); |
| 122 debug("testing size: " + size); |
| 123 var canvasSize = Math.max(size / 4, 2); |
| 124 canvas.width = canvasSize; |
| 125 canvas.height = canvasSize; |
| 126 gl.viewport(0, 0, canvasSize, canvasSize); |
| 127 var tex = gl.createTexture(); |
| 128 gl.bindTexture(gl.TEXTURE_CUBE_MAP, tex); |
| 129 |
| 130 // Seems like I should be using LINEAR here with some other math |
| 131 // to make sure I get more mip coverage but that's easier said |
| 132 // than done. |
| 133 |
| 134 gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, gl.NEAREST); |
| 135 gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.NEAREST); |
| 136 |
| 137 for (var jj = 0; jj < 2; ++jj) { |
| 138 for (var tt = 0; tt < targets.length; ++tt) { |
| 139 var color = colors[(tt + count) % colors.length]; |
| 140 fillLevel(targets[tt], 0, size, color.color); |
| 141 } |
| 142 if (jj == 1) { |
| 143 debug("use mipmap"); |
| 144 gl.texParameteri( |
| 145 gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, |
| 146 gl.NEAREST_MIPMAP_NEAREST); |
| 147 gl.generateMipmap(gl.TEXTURE_CUBE_MAP); |
| 148 } |
| 149 |
| 150 var err = gl.getError(); |
| 151 if (err == gl.OUT_OF_MEMORY) { |
| 152 debug("out of memory"); |
| 153 return false; |
| 154 } |
| 155 if (err != gl.NO_ERROR) { |
| 156 testFailed("unexpected gl error: " + wtu.glEnumToString(gl, err)); |
| 157 } |
| 158 |
| 159 |
| 160 for (var rr = 0; rr < rotations.length; ++rr) { |
| 161 var rot = rotations[rr]; |
| 162 var color = colors[(rr + count) % colors.length]; |
| 163 var rotMat = axisRotation(rot.axis, rot.angle); |
| 164 gl.uniformMatrix4fv(rotLoc, false, rotMat); |
| 165 wtu.drawQuad(gl); |
| 166 wtu.checkCanvas( |
| 167 gl, color.color, |
| 168 wtu.glEnumToString(gl, targets[rr]) + " should be " + color.name); |
| 169 } |
| 170 |
| 171 for (var rr = 0; rr < halfRotations.length; ++rr) { |
| 172 var h = halfRotations[rr]; |
| 173 var rots = h.rotations; |
| 174 var rotMat = axisRotation(rots[0].axis, rots[0].angle); |
| 175 for (var ii = 1; ii < rots.length; ++ii) { |
| 176 var tmpMat = axisRotation(rots[ii].axis, rots[ii].angle); |
| 177 var rotMat = mulMatrix(tmpMat, rotMat); |
| 178 } |
| 179 gl.uniformMatrix4fv(rotLoc, false, rotMat); |
| 180 wtu.drawQuad(gl); |
| 181 |
| 182 for (var ii = 0; ii < 2; ++ii) { |
| 183 checkRect( |
| 184 0, |
| 185 canvasSize / 2 * ii, |
| 186 canvasSize, |
| 187 canvasSize / 2, |
| 188 colors[(h.colors[ii] + count) % colors.length]); |
| 189 } |
| 190 } |
| 191 ++count; |
| 192 } |
| 193 |
| 194 gl.deleteTexture(tex); |
| 195 return true; |
| 196 } |
| 197 |
| 198 glErrorShouldBe(gl, gl.NO_ERROR, "Should be no errors."); |
| 199 |
| 200 function checkRect(x, y, width, height, color) { |
| 201 wtu.checkCanvasRect( |
| 202 gl, |
| 203 x, |
| 204 y, |
| 205 width, |
| 206 height, |
| 207 color.color, |
| 208 "" + x + ", " + y + ", " + width + ", " + height + |
| 209 " should be " + color.name); |
| 210 } |
| 211 |
| 212 function fillLevel(target, level, size, color) { |
| 213 var numPixels = size * size; |
| 214 var pixels = new Uint8Array(numPixels * 4); |
| 215 var pixelRow = new Uint8Array(size * 4); |
| 216 for (var jj = 0; jj < size; ++jj) { |
| 217 var off = jj * 4; |
| 218 pixelRow[off + 0] = color[0]; |
| 219 pixelRow[off + 1] = color[1]; |
| 220 pixelRow[off + 2] = color[2]; |
| 221 pixelRow[off + 3] = color[3]; |
| 222 } |
| 223 for (var jj = 0; jj < size; ++jj) { |
| 224 var off = jj * size * 4; |
| 225 pixels.set(pixelRow, off); |
| 226 } |
| 227 gl.texImage2D( |
| 228 target, level, gl.RGBA, size, size, 0, gl.RGBA, gl.UNSIGNED_BYTE, |
| 229 pixels); |
| 230 } |
| 231 |
| 232 function printMat(mat) { |
| 233 debug("" + mat[0] + ", " + mat[1] + ", " + mat[2] + ", " + mat[3] + ", "); |
| 234 debug("" + mat[4] + ", " + mat[5] + ", " + mat[6] + ", " + mat[7] + ", "); |
| 235 debug("" + mat[8] + ", " + mat[9] + ", " + mat[10] + ", " + mat[11] + ", "); |
| 236 debug("" + mat[12] + ", " + mat[13] + ", " + mat[14] + ", " + mat[15] + ", "); |
| 237 } |
| 238 |
| 239 function axisRotation(axis, angle) { |
| 240 var dst = new Float32Array(16); |
| 241 var x = axis[0]; |
| 242 var y = axis[1]; |
| 243 var z = axis[2]; |
| 244 var n = Math.sqrt(x * x + y * y + z * z); |
| 245 x /= n; |
| 246 y /= n; |
| 247 z /= n; |
| 248 var xx = x * x; |
| 249 var yy = y * y; |
| 250 var zz = z * z; |
| 251 var c = Math.cos(angle); |
| 252 var s = Math.sin(angle); |
| 253 var oneMinusCosine = 1 - c; |
| 254 |
| 255 dst[ 0] = xx + (1 - xx) * c; |
| 256 dst[ 1] = x * y * oneMinusCosine + z * s; |
| 257 dst[ 2] = x * z * oneMinusCosine - y * s; |
| 258 dst[ 3] = 0; |
| 259 dst[ 4] = x * y * oneMinusCosine - z * s; |
| 260 dst[ 5] = yy + (1 - yy) * c; |
| 261 dst[ 6] = y * z * oneMinusCosine + x * s; |
| 262 dst[ 7] = 0; |
| 263 dst[ 8] = x * z * oneMinusCosine + y * s; |
| 264 dst[ 9] = y * z * oneMinusCosine - x * s; |
| 265 dst[10] = zz + (1 - zz) * c; |
| 266 dst[11] = 0; |
| 267 dst[12] = 0; |
| 268 dst[13] = 0; |
| 269 dst[14] = 0; |
| 270 dst[15] = 1; |
| 271 |
| 272 return dst; |
| 273 }; |
| 274 |
| 275 function mulMatrix(a, b) { |
| 276 var dst = new Float32Array(16); |
| 277 var a00 = a[0]; |
| 278 var a01 = a[1]; |
| 279 var a02 = a[2]; |
| 280 var a03 = a[3]; |
| 281 var a10 = a[ 4 + 0]; |
| 282 var a11 = a[ 4 + 1]; |
| 283 var a12 = a[ 4 + 2]; |
| 284 var a13 = a[ 4 + 3]; |
| 285 var a20 = a[ 8 + 0]; |
| 286 var a21 = a[ 8 + 1]; |
| 287 var a22 = a[ 8 + 2]; |
| 288 var a23 = a[ 8 + 3]; |
| 289 var a30 = a[12 + 0]; |
| 290 var a31 = a[12 + 1]; |
| 291 var a32 = a[12 + 2]; |
| 292 var a33 = a[12 + 3]; |
| 293 var b00 = b[0]; |
| 294 var b01 = b[1]; |
| 295 var b02 = b[2]; |
| 296 var b03 = b[3]; |
| 297 var b10 = b[ 4 + 0]; |
| 298 var b11 = b[ 4 + 1]; |
| 299 var b12 = b[ 4 + 2]; |
| 300 var b13 = b[ 4 + 3]; |
| 301 var b20 = b[ 8 + 0]; |
| 302 var b21 = b[ 8 + 1]; |
| 303 var b22 = b[ 8 + 2]; |
| 304 var b23 = b[ 8 + 3]; |
| 305 var b30 = b[12 + 0]; |
| 306 var b31 = b[12 + 1]; |
| 307 var b32 = b[12 + 2]; |
| 308 var b33 = b[12 + 3]; |
| 309 dst[ 0] = a00 * b00 + a01 * b10 + a02 * b20 + a03 * b30; |
| 310 dst[ 1] = a00 * b01 + a01 * b11 + a02 * b21 + a03 * b31; |
| 311 dst[ 2] = a00 * b02 + a01 * b12 + a02 * b22 + a03 * b32; |
| 312 dst[ 3] = a00 * b03 + a01 * b13 + a02 * b23 + a03 * b33; |
| 313 dst[ 4] = a10 * b00 + a11 * b10 + a12 * b20 + a13 * b30; |
| 314 dst[ 5] = a10 * b01 + a11 * b11 + a12 * b21 + a13 * b31; |
| 315 dst[ 6] = a10 * b02 + a11 * b12 + a12 * b22 + a13 * b32; |
| 316 dst[ 7] = a10 * b03 + a11 * b13 + a12 * b23 + a13 * b33; |
| 317 dst[ 8] = a20 * b00 + a21 * b10 + a22 * b20 + a23 * b30; |
| 318 dst[ 9] = a20 * b01 + a21 * b11 + a22 * b21 + a23 * b31; |
| 319 dst[10] = a20 * b02 + a21 * b12 + a22 * b22 + a23 * b32; |
| 320 dst[11] = a20 * b03 + a21 * b13 + a22 * b23 + a23 * b33; |
| 321 dst[12] = a30 * b00 + a31 * b10 + a32 * b20 + a33 * b30; |
| 322 dst[13] = a30 * b01 + a31 * b11 + a32 * b21 + a33 * b31; |
| 323 dst[14] = a30 * b02 + a31 * b12 + a32 * b22 + a33 * b32; |
| 324 dst[15] = a30 * b03 + a31 * b13 + a32 * b23 + a33 * b33; |
| 325 return dst; |
| 326 }; |
| 327 |
| 328 successfullyParsed = true; |
| 329 </script> |
| 330 </body> |
| 331 </html> |
| 332 |
| 333 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9373009:
Check in webgl conformance tests r16844 from khronos. (Closed)
Base URL: svn://chrome-svn/chrome/trunk/deps/