Attachment 53058 Details for Bug 42516 – Test case for Firefox using llvmpipe as WebGL renderer

Test case for Firefox using llvmpipe as WebGL renderer

llvmpipeCrash.html (text/html), 4.37 KB, created by Christian Holler (:decoder) on 2011-11-02 07:25:18 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Christian Holler (:decoder)

Created: 2011-11-02 07:25:18 UTC

Size: 4.37 KB

patch

obsolete

><script>
>WebGLTestUtils = (function() {
>var error = function(msg) {
>  if (window.console) {
>    if (window.console.error) {
>      window.console.error(msg);
>    }
>    else if (window.console.log) {
>      window.console.log(msg);
>    }
>  }
>};
>var drawQuad = function(gl, opt_color) {
>  opt_color = opt_color || [255, 255, 255, 255];
>  gl.clearColor(
>      opt_color[0] / 255,
>      opt_color[1] / 255,
>      opt_color[2] / 255,
>      opt_color[3] / 255);
>  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
>  gl.drawArrays(gl.TRIANGLES, 0, 6);
>};
>var loadShader = function(gl, shaderSource, shaderType) {
>  // Create the shader object
>  var shader = gl.createShader(shaderType);
>  if (shader == null) {
>    error("*** Error: unable to create shader '"+shaderSource+"'");
>    return null;
>  }
>
>  // Load the shader source
>  gl.shaderSource(shader, shaderSource);
>  var err = gl.getError();
>  if (err != gl.NO_ERROR) {
>    error("*** Error loading shader '" + shader + "':" + glEnumToString(gl, err));
>    return null;
>  }
>
>  // Compile the shader
>  gl.compileShader(shader);
>
>  // Check the compile status
>  var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
>  if (!compiled) {
>    // Something went wrong during compilation; get the error
>    lastError = gl.getShaderInfoLog(shader);
>    error("*** Error compiling shader '" + shader + "':" + lastError);
>    gl.deleteShader(shader);
>    return null;
>  }
>
>  return shader;
>}
>var setupProgram = function(gl, shaders, opt_attribs, opt_locations) {
>  var program = gl.createProgram();
>  for (var ii = 0; ii < shaders.length; ++ii) {
>    gl.attachShader(program, shaders[ii]);
>  }
>  if (opt_attribs) {
>    for (var ii = 0; ii < opt_attribs.length; ++ii) {
>      gl.bindAttribLocation(
>          program,
>          opt_locations ? opt_locations[ii] : ii,
>          opt_attribs[ii]);
>    }
>  }
>  gl.linkProgram(program);
>
>  // Check the link status
>  var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
>  if (!linked) {
>      // something went wrong with the link
>      lastError = gl.getProgramInfoLog (program);
>      error("Error in program linking:" + lastError);
>
>      gl.deleteProgram(program);
>      return null;
>  }
>
>  gl.useProgram(program);
>  return program;
>};
>
>
>var loadShaderFromScript = function(gl, scriptId, opt_shaderType) {
>  var shaderSource = "";
>  var shaderType;
>  var shaderScript = document.getElementById(scriptId);
>  if (!shaderScript) {
>    throw("*** Error: unknown script element" + scriptId);
>  }
>  shaderSource = shaderScript.text;
>
>  if (!opt_shaderType) {
>    if (shaderScript.type == "x-shader/x-vertex") {
>      shaderType = gl.VERTEX_SHADER;
>    } else if (shaderScript.type == "x-shader/x-fragment") {
>      shaderType = gl.FRAGMENT_SHADER;
>    } else if (shaderType != gl.VERTEX_SHADER && shaderType != gl.FRAGMENT_SHADER) {
>      throw("*** Error: unknown shader type");
>      return null;
>    }
>  }
>
>  return loadShader(
>      gl, shaderSource, opt_shaderType ? opt_shaderType : shaderType);
>};
>
>var create3DContext = function(opt_canvas, opt_attributes) {
>  opt_canvas = opt_canvas || document.createElement("canvas");
>  var context = null;
>  try {
>    context = opt_canvas.getContext("webgl", opt_attributes);
>  } catch(e) {}
>  if (!context) {
>    try {
>      context = opt_canvas.getContext("experimental-webgl", opt_attributes);
>    } catch(e) {}
>  }
>  if (!context) {
>    testFailed("Unable to fetch WebGL rendering context for Canvas");
>  }
>  return context;
>};
>
>return {
>  create3DContext: create3DContext,
>  loadShaderFromScript: loadShaderFromScript,
>  setupProgram: setupProgram,
>  drawQuad: drawQuad,
>  none: false
>};
>
>}());
></script>
><script id="vshader" type="x-shader/x-vertex">
>attribute vec4 vPosition;
>void main()
>{
>    gl_Position = vPosition;
>}
></script>
><script id="fshader" type="x-shader/x-fragment">
>#define NUM_TEXTURES 8 // See spec
>precision mediump float;
>uniform sampler2D uni[1];
>void main()
>{
>    vec4 c = vec4(0,0,0,0);
>    for (int ii = 0; ii < NUM_TEXTURES; ++ii) {
>      c += texture2D(uni[ii], vec2(0.5, 0.5));
>    }
>    gl_FragColor = c;
>}
></script>
><script>
>var wtu = WebGLTestUtils;
>var canvas = document.getElementById("example");
>var gl = wtu.create3DContext(canvas);
>var program = wtu.setupProgram(
>    gl,
>    [wtu.loadShaderFromScript(gl, 'vshader', gl.VERTEX_SHADER),
>     wtu.loadShaderFromScript(gl, 'fshader', gl.FRAGMENT_SHADER)],
>    ['vPosition'], [0]);
>for (var ii = 0; ii < 8; ++ii) {
>}
>wtu.drawQuad(gl);
></script>

<script>
WebGLTestUtils = (function() {
var error = function(msg) {
  if (window.console) {
    if (window.console.error) {
      window.console.error(msg);
    }
    else if (window.console.log) {
      window.console.log(msg);
    }
  }
};
var drawQuad = function(gl, opt_color) {
  opt_color = opt_color || [255, 255, 255, 255];
  gl.clearColor(
      opt_color[0] / 255,
      opt_color[1] / 255,
      opt_color[2] / 255,
      opt_color[3] / 255);
  gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
  gl.drawArrays(gl.TRIANGLES, 0, 6);
};
var loadShader = function(gl, shaderSource, shaderType) {
  // Create the shader object
  var shader = gl.createShader(shaderType);
  if (shader == null) {
    error("*** Error: unable to create shader '"+shaderSource+"'");
    return null;
  }

  // Load the shader source
  gl.shaderSource(shader, shaderSource);
  var err = gl.getError();
  if (err != gl.NO_ERROR) {
    error("*** Error loading shader '" + shader + "':" + glEnumToString(gl, err));
    return null;
  }

  // Compile the shader
  gl.compileShader(shader);

  // Check the compile status
  var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
  if (!compiled) {
    // Something went wrong during compilation; get the error
    lastError = gl.getShaderInfoLog(shader);
    error("*** Error compiling shader '" + shader + "':" + lastError);
    gl.deleteShader(shader);
    return null;
  }

  return shader;
}
var setupProgram = function(gl, shaders, opt_attribs, opt_locations) {
  var program = gl.createProgram();
  for (var ii = 0; ii < shaders.length; ++ii) {
    gl.attachShader(program, shaders[ii]);
  }
  if (opt_attribs) {
    for (var ii = 0; ii < opt_attribs.length; ++ii) {
      gl.bindAttribLocation(
          program,
          opt_locations ? opt_locations[ii] : ii,
          opt_attribs[ii]);
    }
  }
  gl.linkProgram(program);

  // Check the link status
  var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
  if (!linked) {
      // something went wrong with the link
      lastError = gl.getProgramInfoLog (program);
      error("Error in program linking:" + lastError);

      gl.deleteProgram(program);
      return null;
  }

  gl.useProgram(program);
  return program;
};


var loadShaderFromScript = function(gl, scriptId, opt_shaderType) {
  var shaderSource = "";
  var shaderType;
  var shaderScript = document.getElementById(scriptId);
  if (!shaderScript) {
    throw("*** Error: unknown script element" + scriptId);
  }
  shaderSource = shaderScript.text;

  if (!opt_shaderType) {
    if (shaderScript.type == "x-shader/x-vertex") {
      shaderType = gl.VERTEX_SHADER;
    } else if (shaderScript.type == "x-shader/x-fragment") {
      shaderType = gl.FRAGMENT_SHADER;
    } else if (shaderType != gl.VERTEX_SHADER && shaderType != gl.FRAGMENT_SHADER) {
      throw("*** Error: unknown shader type");
      return null;
    }
  }

  return loadShader(
      gl, shaderSource, opt_shaderType ? opt_shaderType : shaderType);
};

var create3DContext = function(opt_canvas, opt_attributes) {
  opt_canvas = opt_canvas || document.createElement("canvas");
  var context = null;
  try {
    context = opt_canvas.getContext("webgl", opt_attributes);
  } catch(e) {}
  if (!context) {
    try {
      context = opt_canvas.getContext("experimental-webgl", opt_attributes);
    } catch(e) {}
  }
  if (!context) {
    testFailed("Unable to fetch WebGL rendering context for Canvas");
  }
  return context;
};

return {
  create3DContext: create3DContext,
  loadShaderFromScript: loadShaderFromScript,
  setupProgram: setupProgram,
  drawQuad: drawQuad,
  none: false
};

}());
</script>
<script id="vshader" type="x-shader/x-vertex">
attribute vec4 vPosition;
void main()
{
    gl_Position = vPosition;
}
</script>
<script id="fshader" type="x-shader/x-fragment">
#define NUM_TEXTURES 8 // See spec
precision mediump float;
uniform sampler2D uni[1];
void main()
{
    vec4 c = vec4(0,0,0,0);
    for (int ii = 0; ii < NUM_TEXTURES; ++ii) {
      c += texture2D(uni[ii], vec2(0.5, 0.5));
    }
    gl_FragColor = c;
}
</script>
<script>
var wtu = WebGLTestUtils;
var canvas = document.getElementById("example");
var gl = wtu.create3DContext(canvas);
var program = wtu.setupProgram(
    gl,
    [wtu.loadShaderFromScript(gl, 'vshader', gl.VERTEX_SHADER),
     wtu.loadShaderFromScript(gl, 'fshader', gl.FRAGMENT_SHADER)],
    ['vPosition'], [0]);
for (var ii = 0; ii < 8; ++ii) {
}
wtu.drawQuad(gl);
</script>

Actions: View

Attachments on bug 42516: 53058 | 53320

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.