const gpgl = require('gpgl');
let kernel = gpgl({
input: [
{ name: 'factor' }
],
output: {
size: [150, 60],
length: 3
},
shader: `
vec3 kernel(vec2 thread, vec2 size) {
return vec3(thread * factor, thread.x + thread.y);
}
`,
fallback: (context) => (threadX, threadY, sizeX, sizeY) => {
return [
threadX * context.factor,
threadY * context.factor,
threadX + threadY
];
}
});
let result = kernel(6);
Defining arrays is straightforward.
{ name: 'arr', size: 5 }
{ name: 'arr', size: [5] }
As always, more components can be added with length
. In GLSL, access to the values can be achieved by calling a function with the same name as the parameter. The size of the array can be obtained by adding _size
to its name.
float kernel(float position, float size) {
return arr(position) / arr_size;
}
// 4x2 matrix with 1 component
{ size: [2, 4] }
// 4x2 matrix with 3 components
{ size: [2, 4], length: 3 }
sum += a(3, 4);
A few options are available to manipulate the structure of the input or output values. Although they can be handy, they can add a significant delay if the data is too large.
-
groupComponents
– If true, components will not be flattened but appear as[x, y]
,[x, y, z]
or[x, y, z, w]
depending on the length. Not applicable when the length is 1. -
groupDimensions
– If true, each row will be contained in its own array. For instance, a 2x2 matrix would look like[[1, 2], [3, 4]]
instead of[1, 2, 3, 4]
. Not applicable when the size is one-dimensional.
Setting useFallback
to true will force the use of the fallback kernel.