gpu.js/test/features/raw-output.js

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

describe('features: raw output');

function rawUnsignedPrecisionRenderOutput(mode) {
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(v) {
    return v[this.thread.x];
  }, {
    output: [1],
    precision: 'unsigned',
  });
  kernel.build([1]);
  kernel.run([1]);
  const result = kernel.renderRawOutput();
  assert.equal(result.constructor, Uint8Array);
  assert.deepEqual(result, new Uint8Array(new Float32Array([1]).buffer));
  gpu.destroy();
}

test('raw unsigned precision render output auto', () => {
  rawUnsignedPrecisionRenderOutput();
});

(GPU.isGPUSupported ? test : skip)('raw unsigned precision render output gpu', () => {
  rawUnsignedPrecisionRenderOutput('gpu');
});

(GPU.isWebGLSupported ? test : skip)('raw unsigned precision render output webgl', () => {
  rawUnsignedPrecisionRenderOutput('webgl');
});

(GPU.isWebGL2Supported ? test : skip)('raw unsigned precision render output webgl2', () => {
  rawUnsignedPrecisionRenderOutput('webgl2');
});

(GPU.isHeadlessGLSupported ? test : skip)('raw unsigned precision render output headlessgl', () => {
  rawUnsignedPrecisionRenderOutput('headlessgl');
});

test('raw unsigned precision render output cpu', () => {
  assert.throws(() => {
    rawUnsignedPrecisionRenderOutput('cpu');
  });
});


function rawSinglePrecisionRenderOutput(mode) {
  const gpu = new GPU({ mode });
  const kernel = gpu.createKernel(function(v) {
    return v[this.thread.x];
  }, {
    output: [1],
    precision: 'single',
  });
  kernel.build([1]);
  kernel.run([1]);
  const result = kernel.renderRawOutput();
  assert.equal(result.constructor, Float32Array);
  // TODO: there is an odd bug in headless gl that causes this to output:
  //   "0": 1,
  //   "1": 2097761,
  //   "2": 2.120494879387071e-36,
  //   "3": -814303.375
  //  For the time being, just check the first value, until this is fixed
  // assert.deepEqual(result, new Float32Array([1, 0, 0, 0]));
  assert.deepEqual(result.length, 4);
  assert.deepEqual(result[0], 1);
  gpu.destroy();
}

(GPU.isSinglePrecisionSupported ? test : skip)('raw single precision render output auto', () => {
  rawSinglePrecisionRenderOutput();
});

(GPU.isGPUSupported && GPU.isSinglePrecisionSupported ? test : skip)('raw single precision render output gpu', () => {
  rawSinglePrecisionRenderOutput('gpu');
});

(GPU.isWebGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('raw single precision render output webgl', () => {
  rawSinglePrecisionRenderOutput('webgl');
});

(GPU.isWebGL2Supported && GPU.isSinglePrecisionSupported ? test : skip)('raw single precision render output webgl2', () => {
  rawSinglePrecisionRenderOutput('webgl2');
});

(GPU.isHeadlessGLSupported && GPU.isSinglePrecisionSupported ? test : skip)('raw single precision render output headlessgl', () => {
  rawSinglePrecisionRenderOutput('headlessgl');
});

test('raw single precision render output cpu', () => {
  assert.throws(() => {
    rawSinglePrecisionRenderOutput('cpu');
  });
});