Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 184 insertions, 0 deletions

diff --git a/third_party/webkit/PerformanceTests/MotionMark/tests/3d/resources/webgl.js b/third_party/webkit/PerformanceTests/MotionMark/tests/3d/resources/webgl.js
new file mode 100644
index 0000000000..58f5df385e
--- /dev/null
+++ b/third_party/webkit/PerformanceTests/MotionMark/tests/3d/resources/webgl.js
@@ -0,0 +1,184 @@
+(function() {
+
+WebGLStage = Utilities.createSubclass(Stage,
+    function(element, options)
+    {
+        Stage.call(this);
+    },
+    {
+
+        initialize: function(benchmark, options)
+        {
+            Stage.prototype.initialize.call(this, benchmark, options);
+
+            this._numTriangles = 0;
+            this._bufferSize = 0;
+
+            this._gl = this.element.getContext("webgl");
+            var gl = this._gl;
+
+            gl.clearColor(0.5, 0.5, 0.5, 1);
+
+            // Create the vertex shader object.
+            var vertexShader = gl.createShader(gl.VERTEX_SHADER);
+
+            // The source code for the shader is extracted from the <script> element above.
+            gl.shaderSource(vertexShader, this._getFunctionSource("vertex"));
+
+            // Compile the shader.
+            gl.compileShader(vertexShader);
+            if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+                // We failed to compile. Output to the console and quit.
+                console.error("Vertex Shader failed to compile.");
+                console.error(gl.getShaderInfoLog(vertexShader));
+                return;
+            }
+
+            // Now do the fragment shader.
+            var fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+            gl.shaderSource(fragmentShader, this._getFunctionSource("fragment"));
+            gl.compileShader(fragmentShader);
+            if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+                console.error("Fragment Shader failed to compile.");
+                console.error(gl.getShaderInfoLog(fragmentShader));
+                return;
+            }
+
+            // We have two compiled shaders. Time to make the program.
+            var program = gl.createProgram();
+            gl.attachShader(program, vertexShader);
+            gl.attachShader(program, fragmentShader);
+            gl.linkProgram(program);
+
+            if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+                console.error("Unable to link shaders into program.");
+                return;
+            }
+
+            // Our program has two inputs. We have a single uniform "color",
+            // and one vertex attribute "position".
+
+            gl.useProgram(program);
+            this._uScale = gl.getUniformLocation(program, "scale");
+            this._uTime = gl.getUniformLocation(program, "time");
+            this._uOffsetX = gl.getUniformLocation(program, "offsetX");
+            this._uOffsetY = gl.getUniformLocation(program, "offsetY");
+            this._uScalar = gl.getUniformLocation(program, "scalar");
+            this._uScalarOffset = gl.getUniformLocation(program, "scalarOffset");
+
+            this._aPosition = gl.getAttribLocation(program, "position");
+            gl.enableVertexAttribArray(this._aPosition);
+
+            this._aColor = gl.getAttribLocation(program, "color");
+            gl.enableVertexAttribArray(this._aColor);
+
+            this._positionData = new Float32Array([
+                // x y z 1
+                   0,  0.1, 0, 1,
+                -0.1, -0.1, 0, 1,
+                 0.1, -0.1, 0, 1
+            ]);
+            this._positionBuffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._positionBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, this._positionData, gl.STATIC_DRAW);
+
+            this._colorData = new Float32Array([
+                1, 0, 0, 1,
+                0, 1, 0, 1,
+                0, 0, 1, 1
+            ]);
+            this._colorBuffer = gl.createBuffer();
+            gl.bindBuffer(gl.ARRAY_BUFFER, this._colorBuffer);
+            gl.bufferData(gl.ARRAY_BUFFER, this._colorData, gl.STATIC_DRAW);
+
+            this._resetIfNecessary();
+        },
+
+        _getFunctionSource: function(id)
+        {
+            return document.getElementById(id).text;
+        },
+
+        _resetIfNecessary: function()
+        {
+            if (this._numTriangles <= this._bufferSize)
+                return;
+
+            if (!this._bufferSize)
+                this._bufferSize = 128;
+
+            while (this._numTriangles > this._bufferSize)
+                this._bufferSize *= 4;
+
+            this._uniformData = new Float32Array(this._bufferSize * 6);
+            for (var i = 0; i < this._bufferSize; ++i) {
+                this._uniformData[i * 6 + 0] = Stage.random(0.2, 0.4);
+                this._uniformData[i * 6 + 1] = 0;
+                this._uniformData[i * 6 + 2] = Stage.random(-0.9, 0.9);
+                this._uniformData[i * 6 + 3] = Stage.random(-0.9, 0.9);
+                this._uniformData[i * 6 + 4] = Stage.random(0.5, 2);
+                this._uniformData[i * 6 + 5] = Stage.random(0, 10);
+            }
+        },
+
+        tune: function(count)
+        {
+            if (!count)
+                return;
+
+            this._numTriangles += count;
+            this._numTriangles = Math.max(this._numTriangles, 0);
+
+            this._resetIfNecessary();
+        },
+
+        animate: function(timeDelta)
+        {
+            var gl = this._gl;
+
+            gl.clear(gl.COLOR_BUFFER_BIT);
+
+            if (!this._startTime)
+                this._startTime = Stage.dateCounterValue(1000);
+            var elapsedTime = Stage.dateCounterValue(1000) - this._startTime;
+
+            for (var i = 0; i < this._numTriangles; ++i) {
+
+                this._uniformData[i * 6 + 1] = elapsedTime;
+
+                var uniformDataOffset = i * 6;
+                gl.uniform1f(this._uScale, this._uniformData[uniformDataOffset++]);
+                gl.uniform1f(this._uTime, this._uniformData[uniformDataOffset++]);
+                gl.uniform1f(this._uOffsetX, this._uniformData[uniformDataOffset++]);
+                gl.uniform1f(this._uOffsetY, this._uniformData[uniformDataOffset++]);
+                gl.uniform1f(this._uScalar, this._uniformData[uniformDataOffset++]);
+                gl.uniform1f(this._uScalarOffset, this._uniformData[uniformDataOffset++]);
+
+                gl.bindBuffer(gl.ARRAY_BUFFER, this._positionBuffer);
+                gl.vertexAttribPointer(this._aPosition, 4, gl.FLOAT, false, 0, 0);
+
+                gl.bindBuffer(gl.ARRAY_BUFFER, this._colorBuffer);
+                gl.vertexAttribPointer(this._aColor, 4, gl.FLOAT, false, 0, 0);
+
+                gl.drawArrays(gl.TRIANGLES, 0, 3);
+            }
+
+        },
+
+        complexity: function()
+        {
+            return this._numTriangles;
+        }
+    }
+);
+
+WebGLBenchmark = Utilities.createSubclass(Benchmark,
+    function(options)
+    {
+        Benchmark.call(this, new WebGLStage(), options);
+    }
+);
+
+window.benchmarkClass = WebGLBenchmark;
+
+})();