/**

* gpu.js

* http://gpu.rocks/

*

* GPU Accelerated JavaScript

*

* @version 1.0.0-rc.7

* @date Sat Nov 11 2017 08:38:09 GMT-0500 (EST)

*

* @license MIT

* The MIT License

*

* Copyright (c) 2017 gpu.js Team

*/

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

}

_createClass(CPUFunctionBuilder, [{

key: 'polyfillStandardFunctions',

value: function polyfillStandardFunctions() {}

}]);

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() {

_classCallCheck(this, CPUFunctionNode);

return _possibleConstructorReturn(this, (CPUFunctionNode.__proto__ || Object.getPrototypeOf(CPUFunctionNode)).apply(this, arguments));

}

_createClass(CPUFunctionNode, [{

key: 'generate',

value: function generate() {

if (this.debug) {

console.log(this);

}

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

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: 'astGeneric',

value: function astGeneric(ast, retArr, funcParam) {

if (ast === null) {

throw this.astErrorOutput('NULL ast', ast, funcParam);

} else {

if (Array.isArray(ast)) {

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

this.astGeneric(ast[i], retArr, funcParam);

}

return retArr;

}

switch (ast.type) {

case 'FunctionDeclaration':

return this.astFunctionDeclaration(ast, retArr, funcParam);

case 'FunctionExpression':

return this.astFunctionExpression(ast, retArr, funcParam);

case 'ReturnStatement':

return this.astReturnStatement(ast, retArr, funcParam);

case 'Literal':

return this.astLiteral(ast, retArr, funcParam);

case 'BinaryExpression':

return this.astBinaryExpression(ast, retArr, funcParam);

case 'Identifier':

return this.astIdentifierExpression(ast, retArr, funcParam);

case 'AssignmentExpression':

return this.astAssignmentExpression(ast, retArr, funcParam);

case 'ExpressionStatement':

return this.astExpressionStatement(ast, retArr, funcParam);

case 'EmptyStatement':

return this.astEmptyStatement(ast, retArr, funcParam);

case 'BlockStatement':

return this.astBlockStatement(ast, retArr, funcParam);

case 'IfStatement':

return this.astIfStatement(ast, retArr, funcParam);

case 'BreakStatement':

return this.astBreakStatement(ast, retArr, funcParam);

case 'ContinueStatement':

return this.astContinueStatement(ast, retArr, funcParam);

case 'ForStatement':

return this.astForStatement(ast, retArr, funcParam);

case 'WhileStatement':

return this.astWhileStatement(ast, retArr, funcParam);

case 'VariableDeclaration':

return this.astVariableDeclaration(ast, retArr, funcParam);

case 'VariableDeclarator':

return this.astVariableDeclarator(ast, retArr, funcParam);

case 'ThisExpression':

return this.astThisExpression(ast, retArr, funcParam);

case 'SequenceExpression':

return this.astSequenceExpression(ast, retArr, funcParam);

case 'UnaryExpression':

return this.astUnaryExpression(ast, retArr, funcParam);

case 'UpdateExpression':

return this.astUpdateExpression(ast, retArr, funcParam);

case 'LogicalExpression':

return this.astLogicalExpression(ast, retArr, funcParam);

case 'MemberExpression':

return this.astMemberExpression(ast, retArr, funcParam);

case 'CallExpression':

return this.astCallExpression(ast, retArr, funcParam);

case 'ArrayExpression':

return this.astArrayExpression(ast, retArr, funcParam);

case 'DebuggerStatement':

return this.astDebuggerStatement(ast, retArr, funcParam);

}

throw this.astErrorOutput('Unknown ast type : ' + ast.type, ast, funcParam);

}

}

}, {

key: 'astFunctionDeclaration',

value: function astFunctionDeclaration(ast, retArr, funcParam) {

if (this.addFunction) {

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

}

return retArr;

}

}, {

key: 'astFunctionExpression',

value: function astFunctionExpression(ast, retArr, funcParam) {

if (!funcParam.isRootKernel) {

retArr.push('function');

funcParam.kernalAst = ast;

retArr.push(' ');

retArr.push(funcParam.functionName);

retArr.push('(');

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

var paramName = funcParam.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, funcParam);

retArr.push('\n');

}

if (!funcParam.isRootKernel) {

retArr.push('}\n');

}

return retArr;

}

}, {

key: 'astReturnStatement',

value: function astReturnStatement(ast, retArr, funcParam) {

if (funcParam.isRootKernel) {

retArr.push('kernelResult = ');

this.astGeneric(ast.argument, retArr, funcParam);

retArr.push(';');

} else if (funcParam.isSubKernel) {

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

this.astGeneric(ast.argument, retArr, funcParam);

retArr.push(';');

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

} else {

retArr.push('return ');

this.astGeneric(ast.argument, retArr, funcParam);

retArr.push(';');

}

return retArr;

}

}, {

key: 'astLiteral',

value: function astLiteral(ast, retArr, funcParam) {

if (isNaN(ast.value)) {

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

}

retArr.push(ast.value);

return retArr;

}

}, {

key: 'astBinaryExpression',

value: function astBinaryExpression(ast, retArr, funcParam) {

retArr.push('(');

this.astGeneric(ast.left, retArr, funcParam);

retArr.push(ast.operator);

this.astGeneric(ast.right, retArr, funcParam);

retArr.push(')');

return retArr;

}

}, {

key: 'astIdentifierExpression',

value: function astIdentifierExpression(idtNode, retArr, funcParam) {

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

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

}

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;

default:

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

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

} else {

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

if (userParamName !== null) {

retArr.push('user_' + userParamName);

} else {

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

}

}

}

return retArr;

}

}, {

key: 'astForStatement',

value: function astForStatement(forNode, retArr, funcParam) {

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

throw this.astErrorOutput('Invalid for statment', ast, funcParam);

}

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, funcParam);

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

retArr.push(';');

}

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

retArr.push(forNode.test.operator);

retArr.push('LOOP_MAX');

retArr.push(';');

this.astGeneric(forNode.update, retArr, funcParam);

retArr.push(')');

retArr.push('{\n');

retArr.push('if (');

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

retArr.push(forNode.test.operator);

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

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, funcParam);

}

} else {

this.astGeneric(forNode.body, retArr, funcParam);

}

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, funcParam);

retArr.push(';');

}

}

retArr.push('for (let ');

this.astGeneric(initArgument, retArr, funcParam);

retArr.push(';');

} else {

retArr.push('for (');

this.astGeneric(forNode.init, retArr, funcParam);

}

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

retArr.push(';');

this.astGeneric(forNode.update, retArr, funcParam);

retArr.push(')');

this.astGeneric(forNode.body, retArr, funcParam);

return retArr;

}

}

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

}

}, {

key: 'astWhileStatement',

value: function astWhileStatement(whileNode, retArr, funcParam) {

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

throw this.astErrorOutput('Invalid while statment', ast, funcParam);

}

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

retArr.push('if (');

this.astGeneric(whileNode.test, retArr, funcParam);

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

this.astGeneric(whileNode.body, retArr, funcParam);

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

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

retArr.push('}\n');

retArr.push('}\n');

return retArr;

}

}, {

key: 'astAssignmentExpression',

value: function astAssignmentExpression(assNode, retArr, funcParam) {

this.astGeneric(assNode.left, retArr, funcParam);

retArr.push(assNode.operator);

this.astGeneric(assNode.right, retArr, funcParam);

return retArr;

}

}, {

key: 'astEmptyStatement',

value: function astEmptyStatement(eNode, retArr, funcParam) {

return retArr;

}

}, {

key: 'astBlockStatement',

value: function astBlockStatement(bNode, retArr, funcParam) {

retArr.push('{\n');

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

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

}

retArr.push('}\n');

return retArr;

}

}, {

key: 'astExpressionStatement',

value: function astExpressionStatement(esNode, retArr, funcParam) {

this.astGeneric(esNode.expression, retArr, funcParam);

retArr.push(';\n');

return retArr;

}

}, {

key: 'astVariableDeclaration',

value: function astVariableDeclaration(vardecNode, retArr, funcParam) {

retArr.push('var ');

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

if (i > 0) {

retArr.push(',');

}

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

}

retArr.push(';');

return retArr;

}

}, {

key: 'astVariableDeclarator',

value: function astVariableDeclarator(ivardecNode, retArr, funcParam) {

this.astGeneric(ivardecNode.id, retArr, funcParam);

if (ivardecNode.init !== null) {

retArr.push('=');

this.astGeneric(ivardecNode.init, retArr, funcParam);

}

return retArr;

}

}, {

key: 'astIfStatement',

value: function astIfStatement(ifNode, retArr, funcParam) {

retArr.push('if (');

this.astGeneric(ifNode.test, retArr, funcParam);

retArr.push(')');

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

this.astGeneric(ifNode.consequent, retArr, funcParam);

} else {

retArr.push(' {\n');

this.astGeneric(ifNode.consequent, retArr, funcParam);

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

}

if (ifNode.alternate) {

retArr.push('else ');

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

this.astGeneric(ifNode.alternate, retArr, funcParam);

} else {

retArr.push(' {\n');

this.astGeneric(ifNode.alternate, retArr, funcParam);

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

}

}

return retArr;

}

}, {

key: 'astBreakStatement',

value: function astBreakStatement(brNode, retArr, funcParam) {

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

return retArr;

}

}, {

key: 'astContinueStatement',

value: function astContinueStatement(crNode, retArr, funcParam) {

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

return retArr;

}

}, {

key: 'astLogicalExpression',

value: function astLogicalExpression(logNode, retArr, funcParam) {

retArr.push('(');

this.astGeneric(logNode.left, retArr, funcParam);

retArr.push(logNode.operator);

this.astGeneric(logNode.right, retArr, funcParam);

retArr.push(')');

return retArr;

}

}, {

key: 'astUpdateExpression',

value: function astUpdateExpression(uNode, retArr, funcParam) {

if (uNode.prefix) {

retArr.push(uNode.operator);

this.astGeneric(uNode.argument, retArr, funcParam);

} else {

this.astGeneric(uNode.argument, retArr, funcParam);

retArr.push(uNode.operator);

}

return retArr;

}

}, {

key: 'astUnaryExpression',

value: function astUnaryExpression(uNode, retArr, funcParam) {

if (uNode.prefix) {

retArr.push(uNode.operator);

this.astGeneric(uNode.argument, retArr, funcParam);

} else {

this.astGeneric(uNode.argument, retArr, funcParam);

retArr.push(uNode.operator);

}

return retArr;

}

}, {

key: 'astThisExpression',

value: function astThisExpression(tNode, retArr, funcParam) {

retArr.push('_this');

return retArr;

}

}, {

key: 'astMemberExpression',

value: function astMemberExpression(mNode, retArr, funcParam) {

if (mNode.computed) {

if (mNode.object.type === 'Identifier') {

this.astGeneric(mNode.object, retArr, funcParam);

retArr.push('[');

this.astGeneric(mNode.property, retArr, funcParam);

retArr.push(']');

} else {

this.astGeneric(mNode.object, retArr, funcParam);

var last = retArr.pop();

retArr.push('][');

this.astGeneric(mNode.property, retArr, funcParam);

retArr.push(last);

}

} else {

var unrolled = this.astMemberExpressionUnroll(mNode);

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

unrolled = 'user_' + unrolled;

}

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

unrolled = '_' + unrolled;

}

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:

retArr.push(unrolled);

}

}

return retArr;

}

}, {

key: 'astSequenceExpression',

value: function astSequenceExpression(sNode, retArr, funcParam) {

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

if (i > 0) {

retArr.push(',');

}

this.astGeneric(sNode.expressions, retArr, funcParam);

}

return retArr;

}

}, {

key: 'astCallExpression',

value: function astCallExpression(ast, retArr, funcParam) {

if (ast.callee) {

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

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

funcParam.calledFunctions.push(funcName);

}

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

funcParam.calledFunctionsArguments[funcName] = [];

}

var functionArguments = [];

funcParam.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, funcParam);

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

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

if (paramIndex === -1) {

functionArguments.push(null);

} else {

functionArguments.push({

name: argument.name,

type: funcParam.paramTypes[paramIndex]

});

}

} else {

functionArguments.push(null);

}

}

retArr.push(')');

return retArr;

}

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

return retArr;

}

}, {

key: 'astArrayExpression',

value: function astArrayExpression(arrNode, retArr, funcParam) {

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, funcParam);

}

retArr.push(')');

return retArr;

}

}, {

key: 'astDebuggerStatement',

value: function astDebuggerStatement(arrNode, retArr, funcParam) {

retArr.push('debugger;');

return retArr;

}

}], [{

key: 'astFunctionPrototype',

value: function astFunctionPrototype(ast, retArr, funcParam) {

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

return retArr;

}

retArr.push(funcParam.returnType);

retArr.push(' ');

retArr.push(funcParam.functionName);

retArr.push('(');

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

if (i > 0) {

retArr.push(', ');

}

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

retArr.push(' ');

retArr.push('user_');

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

}

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

return retArr;

}

}]);

return CPUFunctionNode;

}(BaseFunctionNode);

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

'use strict';

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

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

module.exports = function (cpuKernel, name) {

return '() => {\n ' + kernelRunShortcut.toString() + ';\n const utils = {\n allPropertiesOf: function ' + utils.allPropertiesOf.toString() + ',\n clone: function ' + utils.clone.toString() + ',\n /*splitArray: function ' + utils.splitArray.toString() + ',\n getArgumentType: function ' + utils.getArgumentType.toString() + ',\n getOutput: function ' + utils.getOutput.toString() + ',\n dimToTexSize: function ' + utils.dimToTexSize.toString() + ',\n copyFlatten: function ' + utils.copyFlatten.toString() + ',\n flatten: function ' + utils.flatten.toString() + ',\n systemEndianness: \'' + utils.systemEndianness() + '\',\n initWebGl: function ' + utils.initWebGl.toString() + ',\n isArray: function ' + utils.isArray.toString() + '*/\n };\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 ' + cpuKernel.build.toString() + '\n run () { ' + cpuKernel.kernelString + ' }\n getKernelString() { return this._kernelString; }\n };\n return kernelRunShortcut(new Kernel());\n };';

};

},{"../../core/utils":25,"../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._fnBody = utils.getFunctionBodyFromString(fnString);

_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;

}

}

}

}, {

key: 'build',

value: function build() {

this.setupParams(arguments);

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

while (threadDim.length < 3) {

threadDim.push(1);

}

if (this.graphical) {

var canvas = this.getCanvas();

canvas.width = threadDim[0];

canvas.height = threadDim[1];

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

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: this.output,

debug: this.debug,

loopMaxIterations: this.loopMaxIterations

}, this.paramNames, this.paramTypes);

builder.addFunctions(this.functions, {

constants: this.constants,

output: this.output

});

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) {

this.subKernelOutputVariableNames = [];

var _i = 0;

for (var p in this.subKernelProperties) {

if (!this.subKernelProperties.hasOwnProperty(p)) continue;

var _subKernel = this.subKernelProperties[p];

builder.addSubKernel(_subKernel);

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

_i++;

}

}

var prototypes = builder.getPrototypes();

var kernel = prototypes.shift();

var kernelString = this._kernelString = '\n\t\tvar LOOP_MAX = ' + this._getLoopMaxString() + ';\n\t\tvar _this = this;\n ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' var ' + name + ' = null;\n';

}).join('')) + '\n return function (' + this.paramNames.map(function (paramName) {

return 'user_' + paramName;

}).join(', ') + ') {\n var ret = new Array(' + threadDim[2] + ');\n ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + 'Z = new Array(' + threadDim[2] + ');\n';

}).join('')) + '\n for (this.thread.z = 0; this.thread.z < ' + threadDim[2] + '; this.thread.z++) {\n ret[this.thread.z] = new Array(' + threadDim[1] + ');\n ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + 'Z[this.thread.z] = new Array(' + threadDim[1] + ');\n';

}).join('')) + '\n for (this.thread.y = 0; this.thread.y < ' + threadDim[1] + '; this.thread.y++) {\n ret[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + 'Z[this.thread.z][this.thread.y] = new Array(' + threadDim[0] + ');\n';

}).join('')) + '\n for (this.thread.x = 0; this.thread.x < ' + threadDim[0] + '; this.thread.x++) {\n var kernelResult;\n ' + kernel + '\n ret[this.thread.z][this.thread.y][this.thread.x] = kernelResult;\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + 'Z[this.thread.z][this.thread.y][this.thread.x] = ' + name + ';\n';

}).join('')) + '\n }\n }\n }\n \n if (this.graphical) {\n this._imageData.data.set(this._colorData);\n this._canvasCtx.putImageData(this._imageData, 0, 0);\n return;\n }\n \n if (this.output.length === 1) {\n ret = ret[0][0];\n' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + ' = ' + name + 'Z[0][0];\n';

}).join('')) + '\n \n } else if (this.output.length === 2) {\n ret = ret[0];\n ' + (this.subKernelOutputVariableNames === null ? '' : this.subKernelOutputVariableNames.map(function (name) {

return ' ' + name + ' = ' + name + 'Z[0];\n';

}).join('')) + '\n }\n \n ' + (this.subKernelOutputVariableNames === null ? 'return ret;\n' : this.subKernels !== null ? 'var result = [\n ' + this.subKernelOutputVariableNames.map(function (name) {

return '' + name;

}).join(',\n') + '\n ];\n result.result = ret;\n return result;\n' : 'return {\n result: ret,\n ' + Object.keys(this.subKernelProperties).map(function (name, i) {

return name + ': ' + _this2.subKernelOutputVariableNames[i];

}).join(',\n') + '\n };') + '\n ' + (prototypes.length > 0 ? prototypes.join('\n') : '') + '\n }.bind(this);';

return kernelString;

}

}, {

key: 'toString',

value: function toString() {

return kernelString(this);

}

}, {

key: 'precompileKernelObj',

value: function precompileKernelObj(argTypes) {

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

return {

threadDim: threadDim

};

}

}, {

key: '_getLoopMaxString',

value: function _getLoopMaxString() {

return this.loopMaxIterations ? ' ' + parseInt(this.loopMaxIterations) + ';\n' : ' 1000;\n';

}

}], [{

key: 'compileKernel',

value: function compileKernel(precompileObj) {

var threadDim = precompileObj.threadDim;

while (threadDim.length < 3) {

threadDim.push(1);

}

}

}]);

return CPUKernel;

}(KernelBase);

},{"../../core/utils":25,"../kernel-base":8,"./kernel-string":3}],5:[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; }