archive-gh-me/gpu.js
1
0
Fork 0
mirror of https://github.com/gpujs/gpu.js.git synced 2026-01-25 16:08:02 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #393 from gpujs/392-cpu-type-management

Browse Source 
fix: CPU transpilation issue for type management
This commit is contained in:
Robert Plummer 2018-11-01 14:17:34 -04:00 committed by GitHub
commit c97c86f408
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 515 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
bin/gpu-core.js
View File

@ -4,8 +4,8 @@
*
* GPU Accelerated JavaScript
*
* @version 1.10.1
* @date Thu Nov 01 2018 10:01:30 GMT-0400 (EDT)
* @version 1.10.2
* @date Thu Nov 01 2018 14:15:00 GMT-0400 (EDT)
*
* @license MIT
* The MIT License

4
bin/gpu-core.min.js vendored
View File

@ -4,8 +4,8 @@
*
* GPU Accelerated JavaScript
*
* @version 1.10.1
* @date Thu Nov 01 2018 10:01:30 GMT-0400 (EDT)
* @version 1.10.2
* @date Thu Nov 01 2018 14:15:00 GMT-0400 (EDT)
*
* @license MIT
* The MIT License

14
bin/gpu.js
View File

@ -4,8 +4,8 @@
*
* GPU Accelerated JavaScript
*
* @version 1.10.1
* @date Thu Nov 01 2018 10:01:30 GMT-0400 (EDT)
* @version 1.10.2
* @date Thu Nov 01 2018 14:15:00 GMT-0400 (EDT)
*
* @license MIT
* The MIT License
@ -125,8 +125,6 @@ module.exports = function (_BaseFunctionNode) {
if (i > 0) {
retArr.push(', ');
}
retArr.push(this.paramTypes[i]);
retArr.push(' ');
retArr.push('user_');
retArr.push(this.paramNames[i]);
}
@ -143,7 +141,6 @@ module.exports = function (_BaseFunctionNode) {
if (!this.isRootKernel) {
retArr.push('function');
this.kernalAst = ast;
retArr.push(' ');
retArr.push(this.functionName);
retArr.push('(');
@ -154,8 +151,6 @@ module.exports = function (_BaseFunctionNode) {
if (i > 0) {
retArr.push(', ');
}
retArr.push(' ');
retArr.push('user_');
retArr.push(paramName);
}
@ -773,7 +768,7 @@ module.exports = function (_BaseFunctionNode) {
value: function astArrayExpression(arrNode, retArr) {
var arrLen = arrNode.elements.length;
retArr.push('new Float32Array(');
retArr.push('[');
for (var i = 0; i < arrLen; ++i) {
if (i > 0) {
retArr.push(', ');
@ -781,7 +776,7 @@ module.exports = function (_BaseFunctionNode) {
var subNode = arrNode.elements[i];
this.astGeneric(subNode, retArr);
}
retArr.push(')');
retArr.push(']');
return retArr;
@ -2528,7 +2523,6 @@ module.exports = function (_FunctionNodeBase) {
if (this.isRootKernel) {
retArr.push('void');
this.kernalAst = ast;
} else {
var returnType = this.returnType;
var type = typeMap[returnType];

8
bin/gpu.min.js vendored
View File

File diff suppressed because one or more lines are too long

9
dist/backend/cpu/function-node.js vendored
View File

@ -143,8 +143,6 @@ module.exports = function (_BaseFunctionNode) {
if (i > 0) {
retArr.push(', ');
}
retArr.push(this.paramTypes[i]);
retArr.push(' ');
retArr.push('user_');
retArr.push(this.paramNames[i]);
}
@ -174,7 +172,6 @@ module.exports = function (_BaseFunctionNode) {
// Setup function return type and name
if (!this.isRootKernel) {
retArr.push('function');
this.kernalAst = ast;
retArr.push(' ');
retArr.push(this.functionName);
retArr.push('(');
@ -186,8 +183,6 @@ module.exports = function (_BaseFunctionNode) {
if (i > 0) {
retArr.push(', ');
}
retArr.push(' ');
retArr.push('user_');
retArr.push(paramName);
}
@ -1101,7 +1096,7 @@ module.exports = function (_BaseFunctionNode) {
value: function astArrayExpression(arrNode, retArr) {
var arrLen = arrNode.elements.length;
retArr.push('new Float32Array(');
retArr.push('[');
for (var i = 0; i < arrLen; ++i) {
if (i > 0) {
retArr.push(', ');
@ -1109,7 +1104,7 @@ module.exports = function (_BaseFunctionNode) {
var subNode = arrNode.elements[i];
this.astGeneric(subNode, retArr);
}
retArr.push(')');
retArr.push(']');
return retArr;

1
dist/backend/web-gl/function-node.js vendored
View File

@ -148,7 +148,6 @@ module.exports = function (_FunctionNodeBase) {
// Setup function return type and name
if (this.isRootKernel) {
retArr.push('void');
this.kernalAst = ast;
} else {
var returnType = this.returnType;
var type = typeMap[returnType];

2
package.json
View File

@ -1,6 +1,6 @@
{
"name": "gpu.js",
"version": "1.10.1",
"version": "1.10.2",
"description": "GPU Accelerated JavaScript",
"main": "./dist/index.js",
"files": ["dist", "bin"],

9
src/backend/cpu/function-node.js
View File

@ -120,8 +120,6 @@ module.exports = class CPUFunctionNode extends BaseFunctionNode {
if (i > 0) {
retArr.push(', ');
}
retArr.push(this.paramTypes[i]);
retArr.push(' ');
retArr.push('user_');
retArr.push(this.paramNames[i]);
}
@ -148,7 +146,6 @@ module.exports = class CPUFunctionNode extends BaseFunctionNode {
// Setup function return type and name
if (!this.isRootKernel) {
retArr.push('function');
this.kernalAst = ast;
retArr.push(' ');
retArr.push(this.functionName);
retArr.push('(');
@ -160,8 +157,6 @@ module.exports = class CPUFunctionNode extends BaseFunctionNode {
if (i > 0) {
retArr.push(', ');
}
retArr.push(' ');
retArr.push('user_');
retArr.push(paramName);
}
@ -1041,7 +1036,7 @@ module.exports = class CPUFunctionNode extends BaseFunctionNode {
astArrayExpression(arrNode, retArr) {
const arrLen = arrNode.elements.length;
retArr.push('new Float32Array(');
retArr.push('[');
for (let i = 0; i < arrLen; ++i) {
if (i > 0) {
retArr.push(', ');
@ -1049,7 +1044,7 @@ module.exports = class CPUFunctionNode extends BaseFunctionNode {
const subNode = arrNode.elements[i];
this.astGeneric(subNode, retArr)
}
retArr.push(')');
retArr.push(']');
return retArr;

1
src/backend/web-gl/function-node.js
View File

@ -123,7 +123,6 @@ module.exports = class WebGLFunctionNode extends FunctionNodeBase {
// Setup function return type and name
if (this.isRootKernel) {
retArr.push('void');
this.kernalAst = ast;
} else {
const returnType = this.returnType;
const type = typeMap[returnType];

618
test/features/type-management.js
View File

@ -1,189 +1,567 @@
/// test deep array type detection
QUnit.test("type detection - arrays directly vec2", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0];
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 direct() {\n\
(function() {
QUnit.test('type management - arrays directly - Array(2) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0];
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 direct() {\n\
return vec2(0.0, 0.0);\n\
}');
});
QUnit.test('type management - arrays directly - Array(2) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function direct() {
return [0, 0];
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 direct() {\n\
return vec2(0.0, 0.0);\n\
}');
});
QUnit.test("type detection - arrays directly vec3", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0, 0];
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 direct() {\n\
QUnit.test('type management - arrays directly - Array(2) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function direct() {
return [0, 0];
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'function direct() {\n\
return [0, 0];\n\
}');
});
})();
(function() {
QUnit.test('type management - arrays directly - Array(3) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0, 0];
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 direct() {\n\
return vec3(0.0, 0.0, 0.0);\n\
}');
});
});
QUnit.test('type management - arrays directly - Array(3) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function direct() {
return [0, 0, 0];
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 direct() {\n\
return vec3(0.0, 0.0, 0.0);\n\
}');
});
QUnit.test('type management - arrays directly - Array(3) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function direct() {
return [0, 0, 0];
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'function direct() {\n\
return [0, 0, 0];\n\
}');
});
})();
QUnit.test("type detection - arrays directly vec4", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0, 0, 0];
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 direct() {\n\
(function() {
QUnit.test('type management - arrays directly - Array(4) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function direct() {
return [0, 0, 0, 0];
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 direct() {\n\
return vec4(0.0, 0.0, 0.0, 0.0);\n\
}');
});
QUnit.test("type detection - arrays referenced directly vec2", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0];
return array;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 refDirect() {\n\
});
QUnit.test('type management - arrays directly - Array(4) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function direct() {
return [0, 0, 0, 0];
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 direct() {\n\
return vec4(0.0, 0.0, 0.0, 0.0);\n\
}');
});
QUnit.test("type management - arrays directly - Array(4) cpu", function(assert) {
var node = new GPU.CPUFunctionNode(null, function direct() {
return [0, 0, 0, 0];
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'function direct() {\n\
return [0, 0, 0, 0];\n\
}');
});
})();
(function() {
QUnit.test('type management - arrays referenced directly - Array(2) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0];
return array;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 refDirect() {\n\
vec2 user_array=vec2(0.0, 0.0);\n\
return user_array;\n\
}');
});
});
QUnit.test('type management - arrays referenced directly - Array(2) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function refDirect() {
const array = [0, 0];
return array;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 refDirect() {\n\
vec2 user_array=vec2(0.0, 0.0);\n\
return user_array;\n\
}');
});
QUnit.test('type management - arrays referenced directly - Array(2) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function refDirect() {
const array = [0, 0];
return array;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'function refDirect() {\n\
var user_array=[0, 0];\n\
return user_array;\n\
}');
});
})();
QUnit.test("type detection - arrays referenced directly vec3", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0, 0];
return array;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 refDirect() {\n\
(function(){
QUnit.test('type management - arrays referenced directly - Array(3) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0, 0];
return array;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 refDirect() {\n\
vec3 user_array=vec3(0.0, 0.0, 0.0);\n\
return user_array;\n\
}');
});
});
QUnit.test('type management - arrays referenced directly - Array(3) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function refDirect() {
const array = [0, 0, 0];
return array;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 refDirect() {\n\
vec3 user_array=vec3(0.0, 0.0, 0.0);\n\
return user_array;\n\
}');
});
QUnit.test('type management - arrays referenced directly - Array(3) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function refDirect() {
const array = [0, 0, 0];
return array;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'function refDirect() {\n\
var user_array=[0, 0, 0];\n\
return user_array;\n\
}');
});
})();
QUnit.test("type detection - arrays referenced directly vec4", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0, 0, 0];
return array;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 refDirect() {\n\
(function(){
QUnit.test('type management - arrays referenced directly - Array(4) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function refDirect() {
const array = [0, 0, 0, 0];
return array;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 refDirect() {\n\
vec4 user_array=vec4(0.0, 0.0, 0.0, 0.0);\n\
return user_array;\n\
}');
});
});
QUnit.test('type management - arrays referenced directly - Array(4) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function refDirect() {
const array = [0, 0, 0, 0];
return array;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 refDirect() {\n\
vec4 user_array=vec4(0.0, 0.0, 0.0, 0.0);\n\
return user_array;\n\
}');
});
QUnit.test('type management - arrays referenced directly - Array(4) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function refDirect() {
const array = [0, 0, 0, 0];
return array;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'function refDirect() {\n\
var user_array=[0, 0, 0, 0];\n\
return user_array;\n\
}');
});
})();
QUnit.test("type detection - arrays referenced indirectly vec2", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 indirect() {\n\
(function() {
QUnit.test('type management - arrays referenced indirectly - Array(2) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 indirect() {\n\
vec2 user_array=vec2(0.0, 0.0);\n\
vec2 user_array2=user_array;\n\
return user_array2;\n\
}');
});
});
QUnit.test('type management - arrays referenced indirectly - Array(2) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function indirect() {
const array = [0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 indirect() {\n\
vec2 user_array=vec2(0.0, 0.0);\n\
vec2 user_array2=user_array;\n\
return user_array2;\n\
}');
});
QUnit.test('type management - arrays referenced indirectly - Array(2) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function indirect() {
const array = [0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(2)' });
assert.equal(node.generate(), 'function indirect() {\n\
var user_array=[0, 0];\n\
var user_array2=user_array;\n\
return user_array2;\n\
}');
});
})();
QUnit.test("type detection - arrays referenced indirectly vec3", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 indirect() {\n\
(function() {
QUnit.test('type management - arrays referenced indirectly - Array(3) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 indirect() {\n\
vec3 user_array=vec3(0.0, 0.0, 0.0);\n\
vec3 user_array2=user_array;\n\
return user_array2;\n\
}');
});
});
QUnit.test('type management - arrays referenced indirectly - Array(3) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function indirect() {
const array = [0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 indirect() {\n\
vec3 user_array=vec3(0.0, 0.0, 0.0);\n\
vec3 user_array2=user_array;\n\
return user_array2;\n\
}');
});
QUnit.test('type management - arrays referenced indirectly - Array(3) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function indirect() {
const array = [0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(3)' });
assert.equal(node.generate(), 'function indirect() {\n\
var user_array=[0, 0, 0];\n\
var user_array2=user_array;\n\
return user_array2;\n\
}');
});
})();
QUnit.test("type detection - arrays referenced indirectly vec4", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 indirect() {\n\
(function() {
QUnit.test('type management - arrays referenced indirectly - Array(4) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function indirect() {
const array = [0, 0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 indirect() {\n\
vec4 user_array=vec4(0.0, 0.0, 0.0, 0.0);\n\
vec4 user_array2=user_array;\n\
return user_array2;\n\
}');
});
});
QUnit.test('type management - arrays referenced indirectly - Array(4) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function indirect() {
const array = [0, 0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 indirect() {\n\
vec4 user_array=vec4(0.0, 0.0, 0.0, 0.0);\n\
vec4 user_array2=user_array;\n\
return user_array2;\n\
}');
});
QUnit.test('type management - arrays referenced indirectly - Array(4) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function indirect() {
const array = [0, 0, 0, 0];
const array2 = array;
return array2;
}, { returnType: 'Array(4)' });
assert.equal(node.generate(), 'function indirect() {\n\
var user_array=[0, 0, 0, 0];\n\
var user_array2=user_array;\n\
return user_array2;\n\
}');
});
})();
QUnit.test("type detection - arrays arguments vec2", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' } });
assert.equal(node.generate(), 'float arguments(vec2 user_array, vec2 user_array2) {\n\
(function() {
QUnit.test('type management - arrays arguments - Array(2) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' } });
assert.equal(node.generate(), 'float arrayArguments(vec2 user_array, vec2 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test("type detection - arrays arguments vec3", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' } });
assert.equal(node.generate(), 'float arguments(vec3 user_array, vec3 user_array2) {\n\
});
QUnit.test('type management - arrays arguments - Array(2) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' } });
assert.equal(node.generate(), 'float arrayArguments(vec2 user_array, vec2 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
});
QUnit.test('type management - arrays arguments - Array(2) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' } });
assert.equal(node.generate(), 'function arrayArguments(user_array, user_array2) {\n\
var user_array3=[0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();
QUnit.test("type detection - arrays arguments vec4", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' } });
assert.equal(node.generate(), 'float arguments(vec4 user_array, vec4 user_array2) {\n\
(function() {
QUnit.test('type management - arrays arguments - Array(3) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' } });
assert.equal(node.generate(), 'float arrayArguments(vec3 user_array, vec3 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test("type detection - arrays inherited vec2", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' }, returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 inherited(vec2 user_array, vec2 user_array2) {\n\
});
QUnit.test('type management - arrays arguments - Array(3) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' } });
assert.equal(node.generate(), 'float arrayArguments(vec3 user_array, vec3 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
});
QUnit.test('type management - arrays arguments - Array(3) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' } });
assert.equal(node.generate(), 'function arrayArguments(user_array, user_array2) {\n\
var user_array3=[0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();
QUnit.test("type detection - arrays inherited vec3", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' }, returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 inherited(vec3 user_array, vec3 user_array2) {\n\
(function() {
QUnit.test('type management - arrays arguments - Array(4) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' } });
assert.equal(node.generate(), 'float arrayArguments(vec4 user_array, vec4 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays arguments - Array(4) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' } });
assert.equal(node.generate(), 'float arrayArguments(vec4 user_array, vec4 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays arguments - Array(4) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function arrayArguments(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' } });
assert.equal(node.generate(), 'function arrayArguments(user_array, user_array2) {\n\
var user_array3=[0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();
(function() {
QUnit.test('type management - arrays inherited - Array(2) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' }, returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 inherited(vec2 user_array, vec2 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays inherited - Array(2) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' }, returnType: 'Array(2)' });
assert.equal(node.generate(), 'vec2 inherited(vec2 user_array, vec2 user_array2) {\n\
vec2 user_array3=vec2(0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays inherited - Array(2) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(2)', array2: 'Array(2)' }, returnType: 'Array(2)' });
assert.equal(node.generate(), 'function inherited(user_array, user_array2) {\n\
var user_array3=[0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();
(function() {
QUnit.test('type management - arrays inherited - Array(3) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' }, returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 inherited(vec3 user_array, vec3 user_array2) {\n\
vec3 user_array3=vec3(0.0, 0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
});
QUnit.test('type management - arrays inherited - Array(3) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' }, returnType: 'Array(3)' });
assert.equal(node.generate(), 'vec3 inherited(vec3 user_array, vec3 user_array2) {\n\
vec3 user_array3=vec3(0.0, 0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays inherited - Array(3) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(3)', array2: 'Array(3)' }, returnType: 'Array(3)' });
assert.equal(node.generate(), 'function inherited(user_array, user_array2) {\n\
var user_array3=[0, 0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();
QUnit.test("type detection - arrays inherited vec4", function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' }, returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 inherited(vec4 user_array, vec4 user_array2) {\n\
(function() {
QUnit.test('type management - arrays inherited - Array(4) webgl', function(assert) {
var node = new GPU.WebGLFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' }, returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 inherited(vec4 user_array, vec4 user_array2) {\n\
vec4 user_array3=vec4(0.0, 0.0, 0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
});
QUnit.test('type management - arrays inherited - Array(4) webgl2', function(assert) {
var node = new GPU.WebGL2FunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' }, returnType: 'Array(4)' });
assert.equal(node.generate(), 'vec4 inherited(vec4 user_array, vec4 user_array2) {\n\
vec4 user_array3=vec4(0.0, 0.0, 0.0, 0.0);\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
QUnit.test('type management - arrays inherited - Array(4) cpu', function(assert) {
var node = new GPU.CPUFunctionNode(null, function inherited(array, array2) {
const array3 = [0, 0, 0, 0];
array3[0] = array[0];
array3[1] = array[1] * array2[1];
return array3;
}, { paramTypes: { array: 'Array(4)', array2: 'Array(4)' }, returnType: 'Array(4)' });
assert.equal(node.generate(), 'function inherited(user_array, user_array2) {\n\
var user_array3=[0, 0, 0, 0];\n\
user_array3[0]=user_array[0];\n\
user_array3[1]=(user_array[1]*user_array2[1]);\n\
return user_array3;\n\
}');
});
})();