/**

* gpu.js

* http://gpu.rocks/

*

* GPU Accelerated JavaScript

*

* @version 1.7.1

* @date Fri Sep 07 2018 18:47:52 GMT+0100 (BST)

*

* @license MIT

* The MIT License

*

* Copyright (c) 2018 gpu.js Team

*/

"use strict";(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){

'use strict';

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var FunctionBuilderBase = require('../function-builder-base');

var CPUFunctionNode = require('./function-node');

module.exports = function (_FunctionBuilderBase) {

_inherits(CPUFunctionBuilder, _FunctionBuilderBase);

function CPUFunctionBuilder() {

_classCallCheck(this, CPUFunctionBuilder);

var _this = _possibleConstructorReturn(this, (CPUFunctionBuilder.__proto__ || Object.getPrototypeOf(CPUFunctionBuilder)).call(this));

_this.Node = CPUFunctionNode;

return _this;

}

return CPUFunctionBuilder;

}(FunctionBuilderBase);

},{"../function-builder-base":6,"./function-node":2}],2:[function(require,module,exports){

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var BaseFunctionNode = require('../function-node-base');

var utils = require('../../core/utils');

module.exports = function (_BaseFunctionNode) {

_inherits(CPUFunctionNode, _BaseFunctionNode);

function CPUFunctionNode(functionName, jsFunction, options) {

_classCallCheck(this, CPUFunctionNode);

var _this = _possibleConstructorReturn(this, (CPUFunctionNode.__proto__ || Object.getPrototypeOf(CPUFunctionNode)).call(this, functionName, jsFunction, options));

_this.paramSizes = options ? options.paramSizes : [];

_this.memberStates = [];

return _this;

}

_createClass(CPUFunctionNode, [{

key: 'pushMemberState',

value: function pushMemberState(name) {

this.memberStates.push(name);

}

}, {

key: 'popMemberState',

value: function popMemberState(name) {

if (this.memberState === name) {

this.memberStates.pop();

} else {

throw new Error('Cannot popMemberState ' + name + ' when in ' + this.memberState);

}

}

}, {

key: 'generate',

value: function generate() {

if (this.debug) {

console.log(this);

}

this.functionStringArray = this.astGeneric(this.getJsAST(), []);

this.functionString = this.functionStringArray.join('').trim();

return this.functionString;

}

}, {

key: 'getFunctionPrototypeString',

value: function getFunctionPrototypeString() {

if (this.webGlFunctionPrototypeString) {

return this.webGlFunctionPrototypeString;

}

return this.webGlFunctionPrototypeString = this.generate();

}

}, {

key: 'astFunctionDeclaration',

value: function astFunctionDeclaration(ast, retArr) {

if (this.addFunction) {

this.addFunction(null, utils.getAstString(this.jsFunctionString, ast));

}

return retArr;

}

}, {

key: 'astFunctionPrototype',

value: function astFunctionPrototype(ast, retArr) {

if (this.isRootKernel || this.isSubKernel) {

return retArr;

}

retArr.push(this.returnType);

retArr.push(' ');

retArr.push(this.functionName);

retArr.push('(');

for (var i = 0; i < this.paramNames.length; ++i) {

if (i > 0) {

retArr.push(', ');

}

retArr.push(this.paramTypes[i]);

retArr.push(' ');

retArr.push('user_');

retArr.push(this.paramNames[i]);

}

retArr.push(');\n');

return retArr;

}

}, {

key: 'astFunctionExpression',

value: function astFunctionExpression(ast, retArr) {

if (!this.isRootKernel) {

retArr.push('function');

this.kernalAst = ast;

retArr.push(' ');

retArr.push(this.functionName);

retArr.push('(');

for (var i = 0; i < this.paramNames.length; ++i) {

var paramName = this.paramNames[i];

if (i > 0) {

retArr.push(', ');

}

retArr.push(' ');

retArr.push('user_');

retArr.push(paramName);

}

retArr.push(') {\n');

}

for (var _i = 0; _i < ast.body.body.length; ++_i) {

this.astGeneric(ast.body.body[_i], retArr);

retArr.push('\n');

}

if (!this.isRootKernel) {

retArr.push('}\n');

}

return retArr;

}

}, {

key: 'astReturnStatement',

value: function astReturnStatement(ast, retArr) {

if (this.isRootKernel) {

retArr.push('kernelResult = ');

this.astGeneric(ast.argument, retArr);

retArr.push(';');

} else if (this.isSubKernel) {

retArr.push(this.functionName + 'Result = ');

this.astGeneric(ast.argument, retArr);

retArr.push(';');

retArr.push('return ' + this.functionName + 'Result;');

} else {

retArr.push('return ');

this.astGeneric(ast.argument, retArr);

retArr.push(';');

}

return retArr;

}

}, {

key: 'astLiteral',

value: function astLiteral(ast, retArr) {

if (isNaN(ast.value)) {

throw this.astErrorOutput('Non-numeric literal not supported : ' + ast.value, ast);

}

retArr.push(ast.value);

return retArr;

}

}, {

key: 'astBinaryExpression',

value: function astBinaryExpression(ast, retArr) {

retArr.push('(');

this.astGeneric(ast.left, retArr);

retArr.push(ast.operator);

this.astGeneric(ast.right, retArr);

retArr.push(')');

return retArr;

}

}, {

key: 'astIdentifierExpression',

value: function astIdentifierExpression(idtNode, retArr) {

if (idtNode.type !== 'Identifier') {

throw this.astErrorOutput('IdentifierExpression - not an Identifier', idtNode);

}

switch (this.state) {

case 'input-index-y':

case 'input-index-z':

retArr.push('(');

}

switch (idtNode.name) {

case 'gpu_threadX':

retArr.push('threadId.x');

break;

case 'gpu_threadY':

retArr.push('threadId.y');

break;

case 'gpu_threadZ':

retArr.push('threadId.z');

break;

case 'gpu_outputX':

retArr.push('uOutputDim.x');

break;

case 'gpu_outputY':

retArr.push('uOutputDim.y');

break;

case 'gpu_outputZ':

retArr.push('uOutputDim.z');

break;

case 'Infinity':

retArr.push('Infinity');

break;

default:

if (this.constants && this.constants.hasOwnProperty(idtNode.name)) {

retArr.push('constants_' + idtNode.name);

} else {

var userParamName = this.getUserParamName(idtNode.name);

if (userParamName !== null) {

retArr.push('user_' + userParamName);

} else {

retArr.push('user_' + idtNode.name);

}

}

}

switch (this.state) {

case 'input-index-y':

{

var size = this.paramSizes[this.paramNames.indexOf(this.memberState)];

retArr.push(' * ' + size[0] + ')');

break;

}

case 'input-index-z':

{

var _size = this.paramSizes[this.paramNames.indexOf(this.memberState)];

retArr.push(' * ' + _size[0] * _size[1] + ')');

break;

}

}

return retArr;

}

}, {

key: 'astForStatement',

value: function astForStatement(forNode, retArr) {

if (forNode.type !== 'ForStatement') {

throw this.astErrorOutput('Invalid for statement', forNode);

}

if (forNode.test && forNode.test.type === 'BinaryExpression') {

if ((forNode.test.right.type === 'Identifier' || forNode.test.right.type === 'Literal') && forNode.test.operator === '<' && this.isIdentifierConstant(forNode.test.right.name) === false) {

if (!this.loopMaxIterations) {

console.warn('Warning: loopMaxIterations is not set! Using default of 1000 which may result in unintended behavior.');

console.warn('Set loopMaxIterations or use a for loop of fixed length to silence this message.');

}

retArr.push('for (');

this.astGeneric(forNode.init, retArr);

if (retArr[retArr.length - 1] !== ';') {

retArr.push(';');

}

this.astGeneric(forNode.test.left, retArr);

retArr.push(forNode.test.operator);

retArr.push('LOOP_MAX');

retArr.push(';');

this.astGeneric(forNode.update, retArr);

retArr.push(')');

retArr.push('{\n');

retArr.push('if (');

this.astGeneric(forNode.test.left, retArr);

retArr.push(forNode.test.operator);

this.astGeneric(forNode.test.right, retArr);

retArr.push(') {\n');

if (forNode.body.type === 'BlockStatement') {

for (var i = 0; i < forNode.body.body.length; i++) {

this.astGeneric(forNode.body.body[i], retArr);

}

} else {

this.astGeneric(forNode.body, retArr);

}

retArr.push('} else {\n');

retArr.push('break;\n');

retArr.push('}\n');

retArr.push('}\n');

return retArr;

} else if (forNode.init.declarations) {

var declarations = JSON.parse(JSON.stringify(forNode.init.declarations));

var updateArgument = forNode.update.argument;

if (!Array.isArray(declarations) || declarations.length < 1) {

console.log(this.jsFunctionString);

throw new Error('Error: Incompatible for loop declaration');

}

if (declarations.length > 1) {

var initArgument = null;

for (var _i2 = 0; _i2 < declarations.length; _i2++) {

var declaration = declarations[_i2];

if (declaration.id.name === updateArgument.name) {

initArgument = declaration;

declarations.splice(_i2, 1);

} else {

retArr.push('var ');

this.astGeneric(declaration, retArr);

retArr.push(';');

}

}

retArr.push('for (let ');

this.astGeneric(initArgument, retArr);

retArr.push(';');

} else {

retArr.push('for (');

this.astGeneric(forNode.init, retArr);

}

this.astGeneric(forNode.test, retArr);

retArr.push(';');

this.astGeneric(forNode.update, retArr);

retArr.push(')');

this.astGeneric(forNode.body, retArr);

return retArr;

}

}

throw this.astErrorOutput('Invalid for statement', forNode);

}

}, {

key: 'astWhileStatement',

value: function astWhileStatement(whileNode, retArr) {

if (whileNode.type !== 'WhileStatement') {

throw this.astErrorOutput('Invalid while statement', whileNode);

}

retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');

retArr.push('if (');

this.astGeneric(whileNode.test, retArr);

retArr.push(') {\n');

this.astGeneric(whileNode.body, retArr);

retArr.push('} else {\n');

retArr.push('break;\n');

retArr.push('}\n');

retArr.push('}\n');

return retArr;

}

}, {

key: 'astDoWhileStatement',

value: function astDoWhileStatement(doWhileNode, retArr) {

if (doWhileNode.type !== 'DoWhileStatement') {

throw this.astErrorOutput('Invalid while statement', doWhileNode);

}

retArr.push('for (let i = 0; i < LOOP_MAX; i++) {');

this.astGeneric(doWhileNode.body, retArr);

retArr.push('if (!');

this.astGeneric(doWhileNode.test, retArr);

retArr.push(') {\n');

retArr.push('break;\n');

retArr.push('}\n');

retArr.push('}\n');

return retArr;

}

}, {

key: 'astAssignmentExpression',

value: function astAssignmentExpression(assNode, retArr) {

this.astGeneric(assNode.left, retArr);

retArr.push(assNode.operator);

this.astGeneric(assNode.right, retArr);

return retArr;

}

}, {

key: 'astEmptyStatement',

value: function astEmptyStatement(eNode, retArr) {

return retArr;

}

}, {

key: 'astBlockStatement',

value: function astBlockStatement(bNode, retArr) {

retArr.push('{\n');

for (var i = 0; i < bNode.body.length; i++) {

this.astGeneric(bNode.body[i], retArr);

}

retArr.push('}\n');

return retArr;

}

}, {

key: 'astExpressionStatement',

value: function astExpressionStatement(esNode, retArr) {

this.astGeneric(esNode.expression, retArr);

retArr.push(';\n');

return retArr;

}

}, {

key: 'astVariableDeclaration',

value: function astVariableDeclaration(vardecNode, retArr) {

retArr.push('var ');

for (var i = 0; i < vardecNode.declarations.length; i++) {

this.declarations[vardecNode.declarations[i].id.name] = 'var';

if (i > 0) {

retArr.push(',');

}

this.astGeneric(vardecNode.declarations[i], retArr);

}

retArr.push(';');

return retArr;

}

}, {

key: 'astVariableDeclarator',

value: function astVariableDeclarator(ivardecNode, retArr) {

this.astGeneric(ivardecNode.id, retArr);

if (ivardecNode.init !== null) {

retArr.push('=');

this.astGeneric(ivardecNode.init, retArr);

}

return retArr;

}

}, {

key: 'astIfStatement',

value: function astIfStatement(ifNode, retArr) {

retArr.push('if (');

this.astGeneric(ifNode.test, retArr);

retArr.push(')');

if (ifNode.consequent.type === 'BlockStatement') {

this.astGeneric(ifNode.consequent, retArr);

} else {

retArr.push(' {\n');

this.astGeneric(ifNode.consequent, retArr);

retArr.push('\n}\n');

}

if (ifNode.alternate) {

retArr.push('else ');

if (ifNode.alternate.type === 'BlockStatement') {

this.astGeneric(ifNode.alternate, retArr);

} else {

retArr.push(' {\n');

this.astGeneric(ifNode.alternate, retArr);

retArr.push('\n}\n');

}

}

return retArr;

}

}, {

key: 'astBreakStatement',

value: function astBreakStatement(brNode, retArr) {

retArr.push('break;\n');

return retArr;

}

}, {

key: 'astContinueStatement',

value: function astContinueStatement(crNode, retArr) {

retArr.push('continue;\n');

return retArr;

}

}, {

key: 'astLogicalExpression',

value: function astLogicalExpression(logNode, retArr) {

retArr.push('(');

this.astGeneric(logNode.left, retArr);

retArr.push(logNode.operator);

this.astGeneric(logNode.right, retArr);

retArr.push(')');

return retArr;

}

}, {

key: 'astUpdateExpression',

value: function astUpdateExpression(uNode, retArr) {

if (uNode.prefix) {

retArr.push(uNode.operator);

this.astGeneric(uNode.argument, retArr);

} else {

this.astGeneric(uNode.argument, retArr);

retArr.push(uNode.operator);

}

return retArr;

}

}, {

key: 'astUnaryExpression',

value: function astUnaryExpression(uNode, retArr) {

if (uNode.prefix) {

retArr.push(uNode.operator);

this.astGeneric(uNode.argument, retArr);

} else {

this.astGeneric(uNode.argument, retArr);

retArr.push(uNode.operator);

}

return retArr;

}

}, {

key: 'astThisExpression',

value: function astThisExpression(tNode, retArr) {

retArr.push('_this');

return retArr;

}

}, {

key: 'astMemberExpression',

value: function astMemberExpression(mNode, retArr) {

if (mNode.computed) {

if (mNode.object.type === 'Identifier' || mNode.object.type === 'MemberExpression' && mNode.object.object.object && mNode.object.object.object.type === 'ThisExpression' && mNode.object.object.property.name === 'constants') {

this.pushState('identifier');

this.astGeneric(mNode.object, retArr);

this.popState('identifier');

retArr.push('[');

if (this.isInput(mNode.object.name)) {

this.astGeneric(mNode.property, retArr);

} else {

this.astGeneric(mNode.property, retArr);

}

retArr.push(']');

} else {

if (mNode.object.object) {

if (mNode.object.object.object && this.isInput(mNode.object.object.object.name)) {

this.pushMemberState(mNode.object.object.object.name);

this.pushState('input-index-z');

this.astGeneric(mNode.object, retArr);

var last = retArr.pop();

retArr.push(' + ');

this.popState('input-index-z');

this.pushState('input-index');

this.astGeneric(mNode.property, retArr);

this.popState('input-index');

retArr.push(last);

this.popMemberState(mNode.object.object.object.name);

} else if (this.isInput(mNode.object.object.name)) {

this.pushMemberState(mNode.object.object.name);

if (!this.isState('input-index-z')) {

this.pushState('input-index-y');

}

this.astGeneric(mNode.object, retArr);

var _last = retArr.pop();

retArr.push(' + ');

if (!this.isState('input-index-z')) {

this.popState('input-index-y');

}

var isInputIndexZ = this.isState('input-index-z');

if (isInputIndexZ) {

this.pushState('input-index-y');

} else {

this.pushState('input-index');

}

this.astGeneric(mNode.property, retArr);

if (isInputIndexZ) {

this.popState('input-index-y');

} else {

this.popState('input-index');

}

retArr.push(_last);

this.popMemberState(mNode.object.object.name);

} else {

this.astGeneric(mNode.object, retArr);

var _last2 = retArr.pop();

retArr.push('][');

this.astGeneric(mNode.property, retArr);

retArr.push(_last2);

}

} else {

this.astGeneric(mNode.object, retArr);

var _last3 = retArr.pop();

retArr.push('][');

this.astGeneric(mNode.property, retArr);

retArr.push(_last3);

}

}

} else {

var unrolled = this.astMemberExpressionUnroll(mNode);

if (mNode.property.type === 'Identifier' && mNode.computed) {

unrolled = 'user_' + unrolled;

}

if (unrolled.indexOf('this.constants') === 0) {

unrolled = 'constants_' + unrolled.substring(15);

} else if (unrolled.indexOf('this') === 0) {

unrolled = '_' + unrolled;

}

switch (this.state) {

case 'input-index-y':

case 'input-index-z':

retArr.push('(');

}

switch (unrolled) {

case '_this.output.x':

retArr.push(this.output[0]);

break;

case '_this.output.y':

retArr.push(this.output[1]);

break;

case '_this.output.z':

retArr.push(this.output[2]);

break;

default:

if (mNode.object && mNode.object.name && this.declarations[mNode.object.name]) {

retArr.push('user_');

}

retArr.push(unrolled);

}

switch (this.state) {

case 'input-index-y':

{

var size = this.paramSizes[this.paramNames.indexOf(this.memberState)];

retArr.push(' * ' + size[0] + ')');

break;

}

case 'input-index-z':

{

var _size2 = this.paramSizes[this.paramNames.indexOf(this.memberState)];

retArr.push(' * ' + _size2[0] * _size2[1] + ')');

break;

}

}

}

return retArr;

}

}, {

key: 'astSequenceExpression',

value: function astSequenceExpression(sNode, retArr) {

for (var i = 0; i < sNode.expressions.length; i++) {

if (i > 0) {

retArr.push(',');

}

this.astGeneric(sNode.expressions, retArr);

}

return retArr;

}

}, {

key: 'astCallExpression',

value: function astCallExpression(ast, retArr) {

if (ast.callee) {

var funcName = this.astMemberExpressionUnroll(ast.callee);

if (this.calledFunctions.indexOf(funcName) < 0) {

this.calledFunctions.push(funcName);

}

if (!this.hasOwnProperty('funcName')) {

this.calledFunctionsArguments[funcName] = [];

}

var functionArguments = [];

this.calledFunctionsArguments[funcName].push(functionArguments);

retArr.push(funcName);

retArr.push('(');

for (var i = 0; i < ast.arguments.length; ++i) {

var argument = ast.arguments[i];

if (i > 0) {

retArr.push(', ');

}

this.astGeneric(argument, retArr);

if (argument.type === 'Identifier') {

var paramIndex = this.paramNames.indexOf(argument.name);

if (paramIndex === -1) {

functionArguments.push(null);

} else {

functionArguments.push({

name: argument.name,

type: this.paramTypes[paramIndex]

});

}

} else {

functionArguments.push(null);

}

}

retArr.push(')');

return retArr;

}

throw this.astErrorOutput('Unknown CallExpression', ast);

return retArr;

}

}, {

key: 'astArrayExpression',

value: function astArrayExpression(arrNode, retArr) {

var arrLen = arrNode.elements.length;

retArr.push('new Float32Array(');

for (var i = 0; i < arrLen; ++i) {

if (i > 0) {

retArr.push(', ');

}

var subNode = arrNode.elements[i];

this.astGeneric(subNode, retArr);

}

retArr.push(')');

return retArr;

}

}, {

key: 'astDebuggerStatement',

value: function astDebuggerStatement(arrNode, retArr) {

retArr.push('debugger;');

return retArr;

}

}, {

key: 'memberState',

get: function get() {

return this.memberStates[this.memberStates.length - 1];

}

}]);

return CPUFunctionNode;

}(BaseFunctionNode);

},{"../../core/utils":32,"../function-node-base":7}],3:[function(require,module,exports){

'use strict';

var utils = require('../../core/utils');

var kernelRunShortcut = require('../kernel-run-shortcut');

function removeFnNoise(fn) {

if (/^function /.test(fn)) {

fn = fn.substring(9);

}

return fn.replace(/[_]typeof/g, 'typeof');

}

function removeNoise(str) {

return str.replace(/[_]typeof/g, 'typeof');

}

module.exports = function (cpuKernel, name) {

return '() => {\n ' + kernelRunShortcut.toString() + ';\n const utils = {\n allPropertiesOf: ' + removeNoise(utils.allPropertiesOf.toString()) + ',\n clone: ' + removeNoise(utils.clone.toString()) + ',\n checkOutput: ' + removeNoise(utils.checkOutput.toString()) + '\n };\n const Utils = utils;\n class ' + (name || 'Kernel') + ' {\n constructor() { \n this.argumentsLength = 0;\n this._canvas = null;\n this._webGl = null;\n this.built = false;\n this.program = null;\n this.paramNames = ' + JSON.stringify(cpuKernel.paramNames) + ';\n this.paramTypes = ' + JSON.stringify(cpuKernel.paramTypes) + ';\n this.texSize = ' + JSON.stringify(cpuKernel.texSize) + ';\n this.output = ' + JSON.stringify(cpuKernel.output) + ';\n this._kernelString = `' + cpuKernel._kernelString + '`;\n this.output = ' + JSON.stringify(cpuKernel.output) + ';\n\t\t this.run = function() {\n this.run = null;\n this.build();\n return this.run.apply(this, arguments);\n }.bind(this);\n this.thread = {\n x: 0,\n y: 0,\n z: 0\n };\n }\n setCanvas(canvas) { this._canvas = canvas; return this; }\n setWebGl(webGl) { this._webGl = webGl; return this; }\n ' + removeFnNoise(cpuKernel.build.toString()) + '\n ' + removeFnNoise(cpuKernel.setupParams.toString()) + '\n ' + removeFnNoise(cpuKernel.setupConstants.toString()) + '\n run () { ' + cpuKernel.kernelString + ' }\n getKernelString() { return this._kernelString; }\n ' + removeFnNoise(cpuKernel.validateOptions.toString()) + '\n };\n return kernelRunShortcut(new Kernel());\n };';

};

},{"../../core/utils":32,"../kernel-run-shortcut":9}],4:[function(require,module,exports){

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var KernelBase = require('../kernel-base');

var utils = require('../../core/utils');

var kernelString = require('./kernel-string');

module.exports = function (_KernelBase) {

_inherits(CPUKernel, _KernelBase);

function CPUKernel(fnString, settings) {

_classCallCheck(this, CPUKernel);

var _this = _possibleConstructorReturn(this, (CPUKernel.__proto__ || Object.getPrototypeOf(CPUKernel)).call(this, fnString, settings));

_this._fn = null;

_this.run = null;

_this._canvasCtx = null;

_this._imageData = null;

_this._colorData = null;

_this._kernelString = null;

_this.thread = {

x: 0,

y: 0,

z: 0

};

_this.run = function () {

this.run = null;

this.build.apply(this, arguments);

return this.run.apply(this, arguments);

}.bind(_this);

return _this;

}

_createClass(CPUKernel, [{

key: 'validateOptions',

value: function validateOptions() {

if (!this.output || this.output.length === 0) {

if (arguments.length !== 1) {

throw 'Auto dimensions only supported for kernels with only one input';

}

var argType = utils.getArgumentType(arguments[0]);

if (argType === 'Array') {

this.output = utils.getDimensions(argType);

} else if (argType === 'Texture') {

this.output = arguments[0].output;

} else {

throw 'Auto dimensions not supported for input type: ' + argType;

}

}

utils.checkOutput(this.output);

}

}, {

key: 'build',

value: function build() {

this.setupConstants();

this.setupParams(arguments);

this.validateOptions();

var canvas = this._canvas;

this._canvasCtx = canvas.getContext('2d');

var threadDim = this.threadDim = utils.clone(this.output);

while (threadDim.length < 3) {

threadDim.push(1);

}

if (this.graphical) {

canvas.width = threadDim[0];

canvas.height = threadDim[1];

this._imageData = this._canvasCtx.createImageData(threadDim[0], threadDim[1]);

this._colorData = new Uint8ClampedArray(threadDim[0] * threadDim[1] * 4);

}

var kernelString = this.getKernelString();

if (this.debug) {

console.log('Options:');

console.dir(this);

console.log('Function output:');

console.log(kernelString);

}

this.kernelString = kernelString;

this.run = new Function([], kernelString).bind(this)();

}

}, {

key: 'color',

value: function color(r, g, b, a) {

if (typeof a === 'undefined') {

a = 1;

}

r = Math.floor(r * 255);

g = Math.floor(g * 255);

b = Math.floor(b * 255);

a = Math.floor(a * 255);

var width = this.output[0];

var height = this.output[1];

var x = this.thread.x;

var y = height - this.thread.y - 1;

var index = x + y * width;

this._colorData[index * 4 + 0] = r;

this._colorData[index * 4 + 1] = g;

this._colorData[index * 4 + 2] = b;

this._colorData[index * 4 + 3] = a;

}

}, {

key: 'getKernelString',

value: function getKernelString() {

var _this2 = this;

if (this._kernelString !== null) return this._kernelString;

var builder = this.functionBuilder;

var threadDim = this.threadDim || (this.threadDim = utils.clone(this.output));

while (threadDim.length < 3) {

threadDim.push(1);

}

builder.addKernel(this.fnString, {

prototypeOnly: false,

constants: this.constants,

output: threadDim,

debug: this.debug,

loopMaxIterations: this.loopMaxIterations,

paramNames: this.paramNames,

paramTypes: this.paramTypes,

paramSizes: this.paramSizes,

constantTypes: this.constantTypes

});

builder.addFunctions(this.functions, {

constants: this.constants,

output: threadDim

});

builder.addNativeFunctions(this.nativeFunctions);

if (this.subKernels !== null) {

this.subKernelOutputTextures = [];

this.subKernelOutputVariableNames = [];

for (var i = 0; i < this.subKernels.length; i++) {

var subKernel = this.subKernels[i];

builder.addSubKernel(subKernel, {

prototypeOnly: false,

constants: this.constants,

output: this.output,

debug: this.debug,

loopMaxIterations: this.loopMaxIterations

});

this.subKernelOutputVariableNames.push(subKernel.name + 'Result');

}

} else if (this.subKernelProperties !== null) {