glsStateQuery.js (11732B)
1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES Utilities 3 * ------------------------------------------------ 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ 20 21 'use strict'; 22 goog.provide('modules.shared.glsStateQuery'); 23 24 goog.scope(function() { 25 var glsStateQuery = modules.shared.glsStateQuery; 26 27 /** 28 * Compare two objects. Objects must have the same type and contents. 29 * If comparing numbers, allow some epsilon differences 30 * @param {*} a 31 * @param {*} b 32 * return {boolean} 33 */ 34 glsStateQuery.compare = function(a, b) { 35 /** @const */ var eps = 0.01; 36 if (a === b) 37 return true; 38 39 if (typeof a === 'number' && typeof b === 'number') 40 return Math.abs(a - b) < eps; 41 42 //compare array-like parameters 43 if (typeof a == 'object' && typeof b == 'object') { 44 if (a.constructor !== b.constructor) 45 return false; 46 47 if ('length' in a && 'length' in b) { 48 if (a.length !== b.length) 49 return false; 50 for (var i = 0; i < a.length; i++) { 51 if (typeof a[i] === 'number' && typeof b[i] === 'number') { 52 if (Math.abs(a[i] - b[i]) >= eps) 53 return false; 54 } else if (a[i] !== b[i]) 55 return false; 56 } 57 return true; 58 } 59 60 } 61 return false; 62 }; 63 64 /** 65 * Verify that WebGL state 'param' has the expected value 66 * @param {number} param 67 * @param {*} reference 68 * @return {boolean} 69 */ 70 glsStateQuery.verify = function(param, reference) { 71 var value = gl.getParameter(param); 72 var result = glsStateQuery.compare(value, reference); 73 if (!result) { 74 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 75 } 76 return result; 77 }; 78 79 /** 80 * Verify that WebGL current vertex attrib has the expected value 81 * @param {number} index 82 * @param {*} reference 83 * @return {boolean} 84 */ 85 glsStateQuery.verifyCurrentVertexAttrib = function(index, reference) { 86 var value = gl.getVertexAttrib(index, gl.CURRENT_VERTEX_ATTRIB); 87 var result = glsStateQuery.compare(value, reference); 88 if (!result) { 89 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 90 } 91 return result; 92 }; 93 94 /** 95 * Verify that WebGL vertex attrib attribute 'param' has the expected value 96 * @param {number} index 97 * @param {number} param 98 * @param {*} reference 99 * @return {boolean} 100 */ 101 glsStateQuery.verifyVertexAttrib = function(index, param, reference) { 102 var value = (param == gl.VERTEX_ATTRIB_ARRAY_POINTER) ? 103 gl.getVertexAttribOffset(index, param) : 104 gl.getVertexAttrib(index, param); 105 var result = glsStateQuery.compare(value, reference); 106 if (!result) { 107 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 108 } 109 return result; 110 }; 111 112 /** 113 * Verify that WebGL uniform has the expected value 114 * @param {WebGLProgram} program 115 * @param {WebGLUniformLocation} location 116 * @param {*} reference 117 * @return {boolean} 118 */ 119 glsStateQuery.verifyUniform = function(program, location, reference) { 120 var value = gl.getUniform(program, location); 121 var result = glsStateQuery.compare(value, reference); 122 if (!result) { 123 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 124 } 125 return result; 126 }; 127 128 /** 129 * Verify that WebGL shader state 'param' has the expected value 130 * @param {WebGLShader} shader 131 * @param {number} param 132 * @param {*} reference 133 * @return {boolean} 134 */ 135 glsStateQuery.verifyShader = function(shader, param, reference) { 136 var value = gl.getShaderParameter(shader, param); 137 var result = glsStateQuery.compare(value, reference); 138 if (!result) { 139 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 140 } 141 return result; 142 }; 143 144 /** 145 * Verify that WebGL program state 'param' has the expected value 146 * @param {WebGLProgram} program 147 * @param {number} param 148 * @param {*} reference 149 * @return {boolean} 150 */ 151 glsStateQuery.verifyProgram = function(program, param, reference) { 152 var value = gl.getProgramParameter(program, param); 153 var result = glsStateQuery.compare(value, reference); 154 if (!result) { 155 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 156 } 157 return result; 158 }; 159 160 /** 161 * Verify that WebGL sampler state 'param' has the expected value 162 * @param {WebGLSampler} sampler 163 * @param {number} param 164 * @param {*} reference 165 * @return {boolean} 166 */ 167 glsStateQuery.verifySampler = function(sampler, param, reference) { 168 var value = gl.getSamplerParameter(sampler, param); 169 var result = glsStateQuery.compare(value, reference); 170 if (!result) { 171 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 172 } 173 return result; 174 }; 175 176 /** 177 * Verify that WebGL texture state 'param' has the expected value 178 * @param {number} target 179 * @param {number} param 180 * @param {*} reference 181 * @return {boolean} 182 */ 183 glsStateQuery.verifyTexture = function(target, param, reference) { 184 var value = gl.getTexParameter(target, param); 185 var result = glsStateQuery.compare(value, reference); 186 if (!result) { 187 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 188 } 189 return result; 190 }; 191 192 /** 193 * Verify that WebGL state 'param' has one of the expected values 194 * @param {number} param 195 * @param {Array<*>} reference 196 * return {boolean} 197 */ 198 glsStateQuery.verifyAnyOf = function(param, reference) { 199 var value = gl.getParameter(param); 200 for (var i = 0; i < reference.length; i++) 201 if (glsStateQuery.compare(value, reference[i])) 202 return true; 203 bufferedLogToConsole('Result: ' + value + ' Expected one of: ' + reference); 204 return false; 205 }; 206 207 /** 208 * Verify that WebGL state 'param' has the expected value 209 * @param {number} param 210 * @param {number|Array<number>} reference 211 * @return {boolean} 212 */ 213 glsStateQuery.verifyGreaterOrEqual = function(param, reference) { 214 var value = gl.getParameter(param); 215 if (reference instanceof Array) { 216 var v = /** @type {Array<number>} */ (value); 217 if (v.length != reference.length) { 218 bufferedLogToConsole('Result: ' + value + ' Expected >= : ' + reference); 219 return false; 220 } 221 for (var i = 0; i < reference.length; i++) 222 if (v[i] < reference[i]) { 223 bufferedLogToConsole('Result: ' + value + ' Expected >= : ' + reference); 224 return false; 225 } 226 return true; 227 } 228 var n = /** @type {number} */ (value); 229 if (n < reference) { 230 bufferedLogToConsole('Result: ' + value + ' Expected >= : ' + reference); 231 return false; 232 } 233 return true; 234 }; 235 236 /** 237 * Verify that WebGL state 'param' has the expected value 238 * @param {number} param 239 * @param {number|Array<number>} reference 240 * @return {boolean} 241 */ 242 glsStateQuery.verifyLessOrEqual = function(param, reference) { 243 var value = gl.getParameter(param); 244 if (reference instanceof Array) { 245 var v = /** @type {Array<number>} */ (value); 246 if (v.length != reference.length) { 247 bufferedLogToConsole('Result: ' + value + ' Expected <= : ' + reference); 248 return false; 249 } 250 for (var i = 0; i > reference.length; i++) 251 if (v[i] < reference[i]) { 252 bufferedLogToConsole('Result: ' + value + ' Expected <= : ' + reference); 253 return false; 254 } 255 return true; 256 } 257 var n = /** @type {number} */ (value); 258 if (n > reference) { 259 bufferedLogToConsole('Result: ' + value + ' Expected <= : ' + reference); 260 return false; 261 } 262 return true; 263 }; 264 265 /** 266 * Verify that WebGL state 'param' has the expected value (value & mask == reference) 267 * @param {number} param 268 * @param {number} reference 269 * @param {number} mask 270 * @return {boolean} 271 */ 272 glsStateQuery.verifyMasked = function(param, reference, mask) { 273 var value = /** @type {number} */ (gl.getParameter(param)); 274 if ((value & mask) !== reference) { 275 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference + 'Mask: 0x' + mask.toString(16)); 276 return false; 277 } 278 return true; 279 }; 280 281 /** 282 * Verify that WebGL fbo attachment 'param' has the expected value 283 * @param {number} fbo 284 * @param {number} attachment 285 * @param {number} param 286 * @param {*} reference 287 * @return {boolean} 288 */ 289 glsStateQuery.verifyAttachment = function(fbo, attachment, param, reference) { 290 var value = gl.getFramebufferAttachmentParameter(fbo, attachment, param); 291 var result = glsStateQuery.compare(value, reference); 292 if (!result) { 293 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 294 } 295 return result; 296 }; 297 298 /** 299 * Verify that WebGL fbo color attachment 'param' has the expected value 300 * @param {number} fbo 301 * @param {number} param 302 * @param {*} reference 303 * @return {boolean} 304 */ 305 glsStateQuery.verifyColorAttachment = function(fbo, param, reference) { 306 return glsStateQuery.verifyAttachment(fbo, gl.COLOR_ATTACHMENT0, param, reference); 307 }; 308 309 /** 310 * Verify that WebGL rbo attribute 'param' has the expected value 311 * @param {number} param 312 * @param {*} reference 313 * @return {boolean} 314 */ 315 glsStateQuery.verifyRenderbuffer = function(param, reference) { 316 var value = gl.getRenderbufferParameter(gl.RENDERBUFFER, param); 317 var result = glsStateQuery.compare(value, reference); 318 if (!result) { 319 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 320 } 321 return result; 322 }; 323 324 /** 325 * Verify that WebGL active uniform block's attribute 'param' has the expected value 326 * @param {WebGLProgram} program 327 * @param {number} index 328 * @param {number} param 329 * @param {*} reference 330 * @return {boolean} 331 */ 332 glsStateQuery.verifyActiveUniformBlock = function(program, index, param, reference) { 333 var value = gl.getActiveUniformBlockParameter(program, index, param); 334 var result = glsStateQuery.compare(value, reference); 335 if (!result) { 336 bufferedLogToConsole('Result: ' + value + ' Expected: ' + reference); 337 } 338 return result; 339 }; 340 341 /** 342 * @param {number} param 343 * @param {Array<number>} reference 344 * @param {Array<boolean>} enableRef 345 * @return {boolean} 346 */ 347 348 glsStateQuery.verifyMask = function(param, reference, enableRef) { 349 var intVector4 = /** @type {Array<number>} */ (gl.getParameter(param)); 350 351 if ((enableRef[0] && (intVector4[0] != reference[0])) || 352 (enableRef[1] && (intVector4[1] != reference[1])) || 353 (enableRef[2] && (intVector4[2] != reference[2])) || 354 (enableRef[3] && (intVector4[3] != reference[3]))) 355 { 356 bufferedLogToConsole("// ERROR: expected " + 357 (enableRef[0] ? "" : "(") + reference[0] + (enableRef[0] ? "" : ")") + ", " + 358 (enableRef[1] ? "" : "(") + reference[1] + (enableRef[1] ? "" : ")") + ", " + 359 (enableRef[2] ? "" : "(") + reference[2] + (enableRef[2] ? "" : ")") + ", " + 360 (enableRef[3] ? "" : "(") + reference[3] + (enableRef[3] ? "" : ")")); 361 362 return false; 363 } 364 return true; 365 }; 366 367 });