What class is the alternative of Transform ?

[kaorukitao]

I use luma.gl for transform feedback.
On v8, I used class Transform.
I cannot find class Transform on v9, but documentation suggests to use Transform. Tutorial page shows me that class Transform is not yet ported to v9.
I found class BufferTransform, but documentation says that it is internal helper class.
Also I found class TransformFeedback. Documentation suggests to use device.createTransformFeedback, so I created the instance of Device, but the instance did not have the method createTransformFeedback.
What is the general way to run transform feedback on v9 ?
Thank you.

[ibgreen]

@kaorukitao

• The Transform class was one of the biggest challenges when we started WebGPU enabling luma.gl in v9.
• We broke it down into smaller experimental BufferTransform and TextureTransform classes that we exposed to deck.gl for validation, but we didn't finish documentation updates or provide any upgrade guides.
• TransformFeedback is a wrapper for the underlying buffer transform capability in WebGL, however it is not supported in WebGPU, where one needs to use compute shaders instead.
• I suspect that BufferTransform is your best bet, though you may need to rely more on the TSDoc comments in the source code rather than the documentation page.

@donmccurdy @felixpalmer

[kaorukitao]

Thank you. I try to use BufferTransform.

[kaorukitao]

I wrote below and ran.

import { Device } from "@luma.gl/core";
import { BufferTransform } from "@luma.gl/engine"
const canvas	= document.createElement( "canvas" );
const device	= new Device({
	gl: canvas.getContext( "webgl2" )
});
console.log( BufferTransform.isSupported( device ) );

The output is false.
Can I run transform feedback ?
Do I need additional scripts ?

Versions
@luma.gl/core 9.0.15
@luma.gl/engine 9.0.15

[kaorukitao]

I change policy.
I create device to use device.createTransformFeedback.
If I run into a problem, I will ask you all.
Thank you.

[kaorukitao]

I successed transform feedback using below:

import { luma } from "@luma.gl/core";
import { Model } from "@luma.gl/engine";
import { WebGLDevice } from '@luma.gl/webgl';
//shader source with raw-loader
import vs from "./shader.vs.glsl";
import fs from "./shader.fs.glsl";

luma.registerDevices([ WebGLDevice ]);

const readBufferData	= async ( buffer ) => {
	const data	= await buffer.readAsync();
	return new Float32Array( data.buffer );
};

window.addEventListener( "load", async () => {
	//data for input 4 elements per vertex, 2 vertices
	const srcData	= new Float32Array([
		0, 1, 2, 3,
		4, 5, 6, 7,
	]);
	const vertexCount	= 2;
	const device	= await luma.createDevice({
		type: "webgl",
		adapters: [ WebGLDevice ]
	});
	const dstBuffer	= device.createBuffer({
		byteLength: srcData.byteLength
	});
	const model	= new Model( device, {
		vs,
		fs,
		vertexCount,
		topology: "point-list",
		attributes: {
			aValue: device.createBuffer( srcData )
		},
		bufferLayout: [
			{
				name: "aValue",
				size: 4,
				stride: 4 * Float32Array.BYTES_PER_ELEMENT,
				offset: 0
			}
		],
		varyings: [ "vValue" ]
	});
	const transformFeedback	= device.createTransformFeedback({
		layout: model.pipeline.shaderLayout,
		buffers: {
			vValue: dstBuffer
		}
	});
	model.setTransformFeedback( transformFeedback );
	const renderPass = device.beginRenderPass({ discard: true });
	model.draw( renderPass );
	renderPass.end();
	const data	= await readBufferData( dstBuffer );
	
	console.log( data );
});

Thank you.