gpu.js/test/features/single-precision-textures.js

const { assert, skip, test, only, module: describe } = require('qunit');
const { GPU } = require('../../src');

describe('features: single precision textures');

function singlePrecisionTexturesWithArray(output, mode) {
  const original = [1, 2, 3, 4, 5, 6, 7, 8, 9];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.x];
  }, {
    output: [9],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(Array.from(result), original);
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Array auto', () => {
  singlePrecisionTexturesWithArray();
});

test('with Array cpu', () => {
  singlePrecisionTexturesWithArray('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Array gpu', () => {
  singlePrecisionTexturesWithArray('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array webgl', () => {
  singlePrecisionTexturesWithArray('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Array webgl2', () => {
  singlePrecisionTexturesWithArray('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array headlessgl', () => {
  singlePrecisionTexturesWithArray('headlessgl');
});

function singlePrecisionTexturesWithFloat32Array(output, mode) {
  const original = new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.x];
  }, {
    output: [9],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(Array.from(result), Array.from(original));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Float32Array auto', () => {
  singlePrecisionTexturesWithFloat32Array();
});

test('with Float32Array cpu', () => {
  singlePrecisionTexturesWithFloat32Array('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Float32Array gpu', () => {
  singlePrecisionTexturesWithFloat32Array('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array webgl', () => {
  singlePrecisionTexturesWithFloat32Array('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Float32Array webgl2', () => {
  singlePrecisionTexturesWithFloat32Array('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array headlessgl', () => {
  singlePrecisionTexturesWithFloat32Array('headlessgl');
});

function singlePrecisionTexturesWithUint16Array(output, mode) {
  const original = new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.x];
  }, {
    output: [9],
    precision: 'single',
  });

  const result = kernel(original);
  assert.deepEqual(Array.from(result), Array.from(original));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array auto', () => {
  singlePrecisionTexturesWithUint16Array();
});

test('with Uint16Array cpu', () => {
  singlePrecisionTexturesWithUint16Array('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array gpu', () => {
  singlePrecisionTexturesWithUint16Array('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array webgl', () => {
  singlePrecisionTexturesWithUint16Array('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint16Array webgl2', () => {
  singlePrecisionTexturesWithUint16Array('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array headlessgl', () => {
  singlePrecisionTexturesWithUint16Array('headlessgl');
});

function singlePrecisionTexturesWithUint8Array(output, mode) {
  const original = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]);
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.x];
  }, {
    output: [9],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(Array.from(result), Array.from(original));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array auto', () => {
  singlePrecisionTexturesWithUint8Array();
});

test('with Uint8Array cpu', () => {
  singlePrecisionTexturesWithUint8Array('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array gpu', () => {
  singlePrecisionTexturesWithUint8Array('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array webgl', () => {
  singlePrecisionTexturesWithUint8Array('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint8Array webgl2', () => {
  singlePrecisionTexturesWithUint8Array('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array headlessgl', () => {
  singlePrecisionTexturesWithUint8Array('headlessgl');
});

function singlePrecisionTexturesWithArray2D(output, mode) {
  const original = [
    [1, 2, 3, 4, 5, 6, 7, 8, 9],
    [10, 11, 12, 13, 14, 15, 16, 18, 19],
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.y][this.thread.x];
  }, {
    output: [9, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(array => Array.from(array)), original.map(array => Array.from(array)));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Array2D auto', () => {
  singlePrecisionTexturesWithArray2D();
});

test('with Array2D cpu', () => {
  singlePrecisionTexturesWithArray2D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Array2D gpu', () => {
  singlePrecisionTexturesWithArray2D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array2D webgl', () => {
  singlePrecisionTexturesWithArray2D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Array2D webgl2', () => {
  singlePrecisionTexturesWithArray2D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array2D headlessgl', () => {
  singlePrecisionTexturesWithArray2D('headlessgl');
});

function singlePrecisionTexturesWithFloat32Array2D(output, mode) {
  const original = [
    new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    new Float32Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.y][this.thread.x];
  }, {
    output: [9, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(array => Array.from(array)), original.map(array => Array.from(array)));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Float32Array2D auto', () => {
  singlePrecisionTexturesWithFloat32Array2D();
});

test('with Float32Array2D cpu', () => {
  singlePrecisionTexturesWithFloat32Array2D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Float32Array2D gpu', () => {
  singlePrecisionTexturesWithFloat32Array2D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array2D webgl', () => {
  singlePrecisionTexturesWithFloat32Array2D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Float32Array2D webgl2', () => {
  singlePrecisionTexturesWithFloat32Array2D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array2D headlessgl', () => {
  singlePrecisionTexturesWithFloat32Array2D('headlessgl');
});

function singlePrecisionTexturesWithUint16Array2D(output, mode) {
  const original = [
    new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    new Uint16Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.y][this.thread.x];
  }, {
    output: [9, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(array => Array.from(array)), original.map(array => Array.from(array)));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array2D auto', () => {
  singlePrecisionTexturesWithUint16Array2D();
});

test('with Uint16Array2D cpu', () => {
  singlePrecisionTexturesWithUint16Array2D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array2D gpu', () => {
  singlePrecisionTexturesWithUint16Array2D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array2D webgl', () => {
  singlePrecisionTexturesWithUint16Array2D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint16Array2D webgl2', () => {
  singlePrecisionTexturesWithUint16Array2D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array2D headlessgl', () => {
  singlePrecisionTexturesWithUint16Array2D('headlessgl');
});

function singlePrecisionTexturesWithUint8Array2D(output, mode) {
  const original = [
    new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
    new Uint8Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.y][this.thread.x];
  }, {
    output: [9, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(array => Array.from(array)), original.map(array => Array.from(array)));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array2D auto', () => {
  singlePrecisionTexturesWithUint8Array2D();
});

test('with Uint8Array2D cpu', () => {
  singlePrecisionTexturesWithUint8Array2D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array2D gpu', () => {
  singlePrecisionTexturesWithUint8Array2D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array2D webgl', () => {
  singlePrecisionTexturesWithUint8Array2D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint8Array2D webgl2', () => {
  singlePrecisionTexturesWithUint8Array2D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array2D headlessgl', () => {
  singlePrecisionTexturesWithUint8Array2D('headlessgl');
});

function singlePrecisionTexturesWithArray3D(output, mode) {
  const original = [
    [
      [1, 2, 3, 4, 5, 6, 7, 8, 9],
      [10, 11, 12, 13, 14, 15, 16, 18, 19],
    ],
    [
      [20, 21, 22, 23, 24, 25, 26, 27, 28],
      [29, 30, 31, 32, 33, 34, 35, 36, 37],
    ]
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.z][this.thread.y][this.thread.x];
  }, {
    output: [9, 2, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(matrix => matrix.map(array => Array.from(array))), original);
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Array3D auto', () => {
  singlePrecisionTexturesWithArray3D();
});

test('with Array3D cpu', () => {
  singlePrecisionTexturesWithArray3D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Array3D gpu', () => {
  singlePrecisionTexturesWithArray3D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array3D webgl', () => {
  singlePrecisionTexturesWithArray3D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Array3D webgl2', () => {
  singlePrecisionTexturesWithArray3D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Array3D headlessgl', () => {
  singlePrecisionTexturesWithArray3D('headlessgl');
});

function singlePrecisionTexturesWithFloat32Array3D(output, mode) {
  const original = [
    [
      new Float32Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
      new Float32Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
    ],
    [
      new Float32Array([20, 21, 22, 23, 24, 25, 26, 27, 28]),
      new Float32Array([29, 30, 31, 32, 33, 34, 35, 36, 37]),
    ]
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.z][this.thread.y][this.thread.x];
  }, {
    output: [9, 2, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(matrix => matrix.map(array => Array.from(array))), original.map(matrix => matrix.map(array => Array.from(array))));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Float32Array3D auto', () => {
  singlePrecisionTexturesWithFloat32Array3D();
});

test('with Float32Array3D cpu', () => {
  singlePrecisionTexturesWithFloat32Array3D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Float32Array3D gpu', () => {
  singlePrecisionTexturesWithFloat32Array3D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array3D webgl', () => {
  singlePrecisionTexturesWithFloat32Array3D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Float32Array3D webgl2', () => {
  singlePrecisionTexturesWithFloat32Array3D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Float32Array3D headlessgl', () => {
  singlePrecisionTexturesWithFloat32Array3D('headlessgl');
});

function singlePrecisionTexturesWithUint16Array3D(output, mode) {
  const original = [
    [
      new Uint16Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
      new Uint16Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
    ],
    [
      new Uint16Array([20, 21, 22, 23, 24, 25, 26, 27, 28]),
      new Uint16Array([29, 30, 31, 32, 33, 34, 35, 36, 37]),
    ]
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.z][this.thread.y][this.thread.x];
  }, {
    output: [9, 2, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(matrix => matrix.map(array => Array.from(array))), original.map(matrix => matrix.map(array => Array.from(array))));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array3D auto', () => {
  singlePrecisionTexturesWithUint16Array3D();
});

test('with Uint16Array3D cpu', () => {
  singlePrecisionTexturesWithUint16Array3D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint16Array3D gpu', () => {
  singlePrecisionTexturesWithUint16Array3D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array3D webgl', () => {
  singlePrecisionTexturesWithUint16Array3D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint16Array3D webgl2', () => {
  singlePrecisionTexturesWithUint16Array3D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint16Array3D headlessgl', () => {
  singlePrecisionTexturesWithUint16Array3D('headlessgl');
});

function singlePrecisionTexturesWithUint8Array3D(output, mode) {
  const original = [
    [
      new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
      new Uint8Array([10, 11, 12, 13, 14, 15, 16, 18, 19]),
    ],
    [
      new Uint8Array([20, 21, 22, 23, 24, 25, 26, 27, 28]),
      new Uint8Array([29, 30, 31, 32, 33, 34, 35, 36, 37]),
    ]
  ];
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(packed) {
    return packed[this.thread.z][this.thread.y][this.thread.x];
  }, {
    output: [9, 2, 2],
    precision: 'single'
  });

  const result = kernel(original);
  assert.deepEqual(result.map(matrix => matrix.map(array => Array.from(array))), original.map(matrix => matrix.map(array => Array.from(array))));
  gpu.destroy();
}

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array3D auto', () => {
  singlePrecisionTexturesWithUint8Array3D();
});

test('with Uint8Array3D cpu', () => {
  singlePrecisionTexturesWithUint8Array3D('cpu');
});

(GPU.isKernelMapSupported ? test : skip)('with Uint8Array3D gpu', () => {
  singlePrecisionTexturesWithUint8Array3D('gpu');
});

(GPU.isWebGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array3D webgl', () => {
  singlePrecisionTexturesWithUint8Array3D('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('with Uint8Array3D webgl2', () => {
  singlePrecisionTexturesWithUint8Array3D('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isKernelMapSupported ? test : skip)('with Uint8Array3D headlessgl', () => {
  singlePrecisionTexturesWithUint8Array3D('headlessgl');
});