@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlasSlabAllocator.js

@@ -0,0 +1,258 @@
+import { getActiveWindow } from '../../../../base/browser/dom.js';
+import { BugIndicatingError } from '../../../../base/common/errors.js';
+import { TwoKeyMap } from '../../../../base/common/map.js';
+import { ensureNonNullable } from '../gpuUtils.js';
+class TextureAtlasSlabAllocator {
+    constructor(_canvas, _textureIndex, options) {
+        this._canvas = _canvas;
+        this._textureIndex = _textureIndex;
+        this._slabs = [];
+        this._activeSlabsByDims = ( new TwoKeyMap());
+        this._unusedRects = [];
+        this._openRegionsByHeight = ( new Map());
+        this._openRegionsByWidth = ( new Map());
+        this._allocatedGlyphs = ( new Set());
+        this._nextIndex = 0;
+        this._ctx = ensureNonNullable(this._canvas.getContext('2d', {
+            willReadFrequently: true
+        }));
+        this._slabW = Math.min(options?.slabW ?? (64 << (Math.floor(getActiveWindow().devicePixelRatio) - 1)), this._canvas.width);
+        this._slabH = Math.min(options?.slabH ?? this._slabW, this._canvas.height);
+        this._slabsPerRow = Math.floor(this._canvas.width / this._slabW);
+        this._slabsPerColumn = Math.floor(this._canvas.height / this._slabH);
+    }
+    allocate(rasterizedGlyph) {
+        const glyphWidth = rasterizedGlyph.boundingBox.right - rasterizedGlyph.boundingBox.left + 1;
+        const glyphHeight = rasterizedGlyph.boundingBox.bottom - rasterizedGlyph.boundingBox.top + 1;
+        if (glyphWidth > this._canvas.width || glyphHeight > this._canvas.height) {
+            throw ( new BugIndicatingError('Glyph is too large for the atlas page'));
+        }
+        if (glyphWidth > this._slabW || glyphHeight > this._slabH) {
+            if (this._allocatedGlyphs.size > 0) {
+                return undefined;
+            }
+            let sizeCandidate = this._canvas.width;
+            while (glyphWidth < sizeCandidate / 2 && glyphHeight < sizeCandidate / 2) {
+                sizeCandidate /= 2;
+            }
+            this._slabW = sizeCandidate;
+            this._slabH = sizeCandidate;
+            this._slabsPerRow = Math.floor(this._canvas.width / this._slabW);
+            this._slabsPerColumn = Math.floor(this._canvas.height / this._slabH);
+        }
+        const desiredSlabSize = {
+            w: glyphWidth,
+            h: glyphHeight,
+        };
+        let slab = this._activeSlabsByDims.get(desiredSlabSize.w, desiredSlabSize.h);
+        if (slab) {
+            const glyphsPerSlab = Math.floor(this._slabW / slab.entryW) * Math.floor(this._slabH / slab.entryH);
+            if (slab.count >= glyphsPerSlab) {
+                slab = undefined;
+            }
+        }
+        let dx;
+        let dy;
+        if (!slab) {
+            if (glyphWidth < glyphHeight) {
+                const openRegions = this._openRegionsByWidth.get(glyphWidth);
+                if (openRegions?.length) {
+                    for (let i = openRegions.length - 1; i >= 0; i--) {
+                        const r = openRegions[i];
+                        if (r.w >= glyphWidth && r.h >= glyphHeight) {
+                            dx = r.x;
+                            dy = r.y;
+                            if (glyphWidth < r.w) {
+                                this._unusedRects.push({
+                                    x: r.x + glyphWidth,
+                                    y: r.y,
+                                    w: r.w - glyphWidth,
+                                    h: glyphHeight
+                                });
+                            }
+                            r.y += glyphHeight;
+                            r.h -= glyphHeight;
+                            if (r.h === 0) {
+                                if (i === openRegions.length - 1) {
+                                    openRegions.pop();
+                                }
+                                else {
+                                    this._unusedRects.splice(i, 1);
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                const openRegions = this._openRegionsByHeight.get(glyphHeight);
+                if (openRegions?.length) {
+                    for (let i = openRegions.length - 1; i >= 0; i--) {
+                        const r = openRegions[i];
+                        if (r.w >= glyphWidth && r.h >= glyphHeight) {
+                            dx = r.x;
+                            dy = r.y;
+                            if (glyphHeight < r.h) {
+                                this._unusedRects.push({
+                                    x: r.x,
+                                    y: r.y + glyphHeight,
+                                    w: glyphWidth,
+                                    h: r.h - glyphHeight
+                                });
+                            }
+                            r.x += glyphWidth;
+                            r.w -= glyphWidth;
+                            if (r.h === 0) {
+                                if (i === openRegions.length - 1) {
+                                    openRegions.pop();
+                                }
+                                else {
+                                    this._unusedRects.splice(i, 1);
+                                }
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (dx === undefined || dy === undefined) {
+            if (!slab) {
+                if (this._slabs.length >= this._slabsPerRow * this._slabsPerColumn) {
+                    return undefined;
+                }
+                slab = {
+                    x: Math.floor(this._slabs.length % this._slabsPerRow) * this._slabW,
+                    y: Math.floor(this._slabs.length / this._slabsPerRow) * this._slabH,
+                    entryW: desiredSlabSize.w,
+                    entryH: desiredSlabSize.h,
+                    count: 0
+                };
+                const unusedW = this._slabW % slab.entryW;
+                const unusedH = this._slabH % slab.entryH;
+                if (unusedW) {
+                    addEntryToMapArray(this._openRegionsByWidth, unusedW, {
+                        x: slab.x + this._slabW - unusedW,
+                        w: unusedW,
+                        y: slab.y,
+                        h: this._slabH - (unusedH ?? 0)
+                    });
+                }
+                if (unusedH) {
+                    addEntryToMapArray(this._openRegionsByHeight, unusedH, {
+                        x: slab.x,
+                        w: this._slabW,
+                        y: slab.y + this._slabH - unusedH,
+                        h: unusedH
+                    });
+                }
+                this._slabs.push(slab);
+                this._activeSlabsByDims.set(desiredSlabSize.w, desiredSlabSize.h, slab);
+            }
+            const glyphsPerRow = Math.floor(this._slabW / slab.entryW);
+            dx = slab.x + Math.floor(slab.count % glyphsPerRow) * slab.entryW;
+            dy = slab.y + Math.floor(slab.count / glyphsPerRow) * slab.entryH;
+            slab.count++;
+        }
+        this._ctx.drawImage(rasterizedGlyph.source,
+        rasterizedGlyph.boundingBox.left, rasterizedGlyph.boundingBox.top, glyphWidth, glyphHeight,
+        dx, dy, glyphWidth, glyphHeight);
+        const glyph = {
+            pageIndex: this._textureIndex,
+            glyphIndex: this._nextIndex++,
+            x: dx,
+            y: dy,
+            w: glyphWidth,
+            h: glyphHeight,
+            originOffsetX: rasterizedGlyph.originOffset.x,
+            originOffsetY: rasterizedGlyph.originOffset.y
+        };
+        this._allocatedGlyphs.add(glyph);
+        return glyph;
+    }
+    getUsagePreview() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        const canvas = ( new OffscreenCanvas(w, h));
+        const ctx = ensureNonNullable(canvas.getContext('2d'));
+        ctx.fillStyle = "#808080" ;
+        ctx.fillRect(0, 0, w, h);
+        const slabW = 64 << (Math.floor(getActiveWindow().devicePixelRatio) - 1);
+        for (const slab of this._slabs) {
+            let x = 0;
+            let y = 0;
+            for (let i = 0; i < slab.count; i++) {
+                if (x + slab.entryW > slabW) {
+                    x = 0;
+                    y += slab.entryH;
+                }
+                ctx.fillStyle = "#FF0000" ;
+                ctx.fillRect(slab.x + x, slab.y + y, slab.entryW, slab.entryH);
+                x += slab.entryW;
+            }
+        }
+        for (const g of this._allocatedGlyphs) {
+            ctx.fillStyle = "#4040FF" ;
+            ctx.fillRect(g.x, g.y, g.w, g.h);
+        }
+        const unusedRegions = Array.from(( this._openRegionsByWidth.values())).flat().concat(Array.from(( this._openRegionsByHeight.values())).flat());
+        for (const r of unusedRegions) {
+            ctx.fillStyle = "#FF000088" ;
+            ctx.fillRect(r.x, r.y, r.w, r.h);
+        }
+        ctx.globalAlpha = 0.5;
+        ctx.drawImage(this._canvas, 0, 0);
+        ctx.globalAlpha = 1;
+        return canvas.convertToBlob();
+    }
+    getStats() {
+        const w = this._canvas.width;
+        const h = this._canvas.height;
+        let slabEntryPixels = 0;
+        let usedPixels = 0;
+        let slabEdgePixels = 0;
+        let wastedPixels = 0;
+        let restrictedPixels = 0;
+        const totalPixels = w * h;
+        const slabW = 64 << (Math.floor(getActiveWindow().devicePixelRatio) - 1);
+        const slabH = slabW;
+        for (const slab of this._slabs) {
+            for (let i = 0; i < slab.count; i++) {
+                slabEntryPixels += slab.entryW * slab.entryH;
+            }
+            const entriesPerRow = Math.floor(slabW / slab.entryW);
+            const entriesPerCol = Math.floor(slabH / slab.entryH);
+            const thisSlabPixels = slab.entryW * entriesPerRow * slab.entryH * entriesPerCol;
+            slabEdgePixels += (slabW * slabH) - thisSlabPixels;
+        }
+        for (const g of this._allocatedGlyphs) {
+            usedPixels += g.w * g.h;
+        }
+        const unusedRegions = Array.from(( this._openRegionsByWidth.values())).flat().concat(Array.from(( this._openRegionsByHeight.values())).flat());
+        for (const r of unusedRegions) {
+            restrictedPixels += r.w * r.h;
+        }
+        const edgeUsedPixels = slabEdgePixels - restrictedPixels;
+        wastedPixels = slabEntryPixels - (usedPixels - edgeUsedPixels);
+        const efficiency = usedPixels / (usedPixels + wastedPixels + restrictedPixels);
+        return [
+            `page[${this._textureIndex}]:`,
+            `     Total: ${totalPixels}px (${w}x${h})`,
+            `      Used: ${usedPixels}px (${((usedPixels / totalPixels) * 100).toFixed(2)}%)`,
+            `    Wasted: ${wastedPixels}px (${((wastedPixels / totalPixels) * 100).toFixed(2)}%)`,
+            `Restricted: ${restrictedPixels}px (${((restrictedPixels / totalPixels) * 100).toFixed(2)}%) (hard to allocate)`,
+            `Efficiency: ${efficiency === 1 ? '100' : (efficiency * 100).toFixed(2)}%`,
+            `     Slabs: ${this._slabs.length} of ${Math.floor(this._canvas.width / slabW) * Math.floor(this._canvas.height / slabH)}`
+        ].join('\n');
+    }
+}
+function addEntryToMapArray(map, key, entry) {
+    let list = map.get(key);
+    if (!list) {
+        list = [];
+        map.set(key, list);
+    }
+    list.push(entry);
+}
+export { TextureAtlasSlabAllocator };

package/vscode/src/vs/editor/browser/gpu/bufferDirtyTracker.js

@@ -0,0 +1,32 @@
+class BufferDirtyTracker {
+    get dataOffset() {
+        return this._startIndex;
+    }
+    get dirtySize() {
+        if (this._startIndex === undefined || this._endIndex === undefined) {
+            return undefined;
+        }
+        return this._endIndex - this._startIndex + 1;
+    }
+    get isDirty() { return this._startIndex !== undefined; }
+    flag(index, length = 1) {
+        this._flag(index);
+        if (length > 1) {
+            this._flag(index + length - 1);
+        }
+        return index;
+    }
+    _flag(index) {
+        if (this._startIndex === undefined || index < this._startIndex) {
+            this._startIndex = index;
+        }
+        if (this._endIndex === undefined || index > this._endIndex) {
+            this._endIndex = index;
+        }
+    }
+    clear() {
+        this._startIndex = undefined;
+        this._endIndex = undefined;
+    }
+}
+export { BufferDirtyTracker };

package/vscode/src/vs/editor/browser/gpu/fullFileRenderStrategy.js

@@ -0,0 +1,160 @@
+import { getActiveWindow } from '../../../base/browser/dom.js';
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { CursorColumns } from '../../common/core/cursorColumns.js';
+import { fullFileRenderStrategyWgsl } from './fullFileRenderStrategy.wgsl.js';
+import { GPULifecycle } from './gpuDisposable.js';
+import { quadVertices } from './gpuUtils.js';
+import { GlyphRasterizer } from './raster/glyphRasterizer.js';
+import { ViewGpuContext } from './viewGpuContext.js';
+class FullFileRenderStrategy extends Disposable {
+    static { this._lineCount = 3000; }
+    static { this._columnCount = 200; }
+    get bindGroupEntries() {
+        return [
+            { binding: 2 , resource: { buffer: this._cellBindBuffer } },
+            { binding: 7 , resource: { buffer: this._scrollOffsetBindBuffer } }
+        ];
+    }
+    constructor(_context, _device, _canvas, _atlas) {
+        super();
+        this._context = _context;
+        this._device = _device;
+        this._canvas = _canvas;
+        this._atlas = _atlas;
+        this.wgsl = fullFileRenderStrategyWgsl;
+        this._activeDoubleBufferIndex = 0;
+        this._upToDateLines = [( new Set()), ( new Set())];
+        this._visibleObjectCount = 0;
+        const fontFamily = this._context.configuration.options.get(51 );
+        const fontSize = this._context.configuration.options.get(54 );
+        this._glyphRasterizer = this._register(( new GlyphRasterizer(fontSize, fontFamily)));
+        const bufferSize = FullFileRenderStrategy._lineCount * FullFileRenderStrategy._columnCount * 6  * Float32Array.BYTES_PER_ELEMENT;
+        this._cellBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco full file cell buffer',
+            size: bufferSize,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._cellValueBuffers = [
+            ( new ArrayBuffer(bufferSize)),
+            ( new ArrayBuffer(bufferSize)),
+        ];
+        const scrollOffsetBufferSize = 2;
+        this._scrollOffsetBindBuffer = this._register(GPULifecycle.createBuffer(this._device, {
+            label: 'Monaco scroll offset buffer',
+            size: scrollOffsetBufferSize * Float32Array.BYTES_PER_ELEMENT,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        })).object;
+        this._scrollOffsetValueBuffers = [
+            ( new Float32Array(scrollOffsetBufferSize)),
+            ( new Float32Array(scrollOffsetBufferSize)),
+        ];
+    }
+    reset() {
+        for (const bufferIndex of [0, 1]) {
+            const buffer = ( new Float32Array(this._cellValueBuffers[bufferIndex]));
+            buffer.fill(0, 0, buffer.length);
+            this._device.queue.writeBuffer(this._cellBindBuffer, 0, buffer.buffer, 0, buffer.byteLength);
+            this._upToDateLines[bufferIndex].clear();
+        }
+        this._visibleObjectCount = 0;
+    }
+    update(viewportData, viewLineOptions) {
+        let chars = '';
+        let y = 0;
+        let x = 0;
+        let screenAbsoluteX = 0;
+        let screenAbsoluteY = 0;
+        let zeroToOneX = 0;
+        let zeroToOneY = 0;
+        let wgslX = 0;
+        let wgslY = 0;
+        let xOffset = 0;
+        let glyph;
+        let cellIndex = 0;
+        let tokenStartIndex = 0;
+        let tokenEndIndex = 0;
+        let tokenMetadata = 0;
+        let lineData;
+        let content = '';
+        let fillStartIndex = 0;
+        let fillEndIndex = 0;
+        let tokens;
+        const dpr = getActiveWindow().devicePixelRatio;
+        const scrollOffsetBuffer = this._scrollOffsetValueBuffers[this._activeDoubleBufferIndex];
+        scrollOffsetBuffer[0] = this._context.viewLayout.getCurrentScrollLeft() * dpr;
+        scrollOffsetBuffer[1] = this._context.viewLayout.getCurrentScrollTop() * dpr;
+        this._device.queue.writeBuffer(this._scrollOffsetBindBuffer, 0, scrollOffsetBuffer);
+        const cellBuffer = ( new Float32Array(this._cellValueBuffers[this._activeDoubleBufferIndex]));
+        const lineIndexCount = FullFileRenderStrategy._columnCount * 6 ;
+        const upToDateLines = this._upToDateLines[this._activeDoubleBufferIndex];
+        let dirtyLineStart = Number.MAX_SAFE_INTEGER;
+        let dirtyLineEnd = 0;
+        for (y = viewportData.startLineNumber; y <= viewportData.endLineNumber; y++) {
+            if (!ViewGpuContext.canRender(viewLineOptions, viewportData, y)) {
+                continue;
+            }
+            dirtyLineStart = Math.min(dirtyLineStart, y);
+            dirtyLineEnd = Math.max(dirtyLineEnd, y);
+            lineData = viewportData.getViewLineRenderingData(y);
+            content = lineData.content;
+            xOffset = 0;
+            tokens = lineData.tokens;
+            tokenStartIndex = lineData.minColumn - 1;
+            tokenEndIndex = 0;
+            for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {
+                tokenEndIndex = tokens.getEndOffset(tokenIndex);
+                if (tokenEndIndex <= tokenStartIndex) {
+                    continue;
+                }
+                tokenMetadata = tokens.getMetadata(tokenIndex);
+                for (x = tokenStartIndex; x < tokenEndIndex; x++) {
+                    if (x > FullFileRenderStrategy._columnCount) {
+                        break;
+                    }
+                    chars = content.charAt(x);
+                    if (chars === ' ') {
+                        continue;
+                    }
+                    if (chars === '\t') {
+                        xOffset = CursorColumns.nextRenderTabStop(x + xOffset, lineData.tabSize) - x - 1;
+                        continue;
+                    }
+                    glyph = this._atlas.getGlyph(this._glyphRasterizer, chars, tokenMetadata);
+                    screenAbsoluteX = Math.round((x + xOffset) * viewLineOptions.spaceWidth * dpr);
+                    screenAbsoluteY = (Math.ceil((
+                    (viewportData.relativeVerticalOffset[y - viewportData.startLineNumber] +
+                    Math.floor((viewportData.lineHeight - this._context.configuration.options.get(54 )) / 2))) * dpr));
+                    zeroToOneX = screenAbsoluteX / this._canvas.width;
+                    zeroToOneY = screenAbsoluteY / this._canvas.height;
+                    wgslX = zeroToOneX * 2 - 1;
+                    wgslY = zeroToOneY * 2 - 1;
+                    cellIndex = ((y - 1) * FullFileRenderStrategy._columnCount + (x + xOffset)) * 6 ;
+                    cellBuffer[cellIndex + 0 ] = wgslX;
+                    cellBuffer[cellIndex + 1 ] = -wgslY;
+                    cellBuffer[cellIndex + 4 ] = glyph.glyphIndex;
+                    cellBuffer[cellIndex + 5 ] = glyph.pageIndex;
+                }
+                tokenStartIndex = tokenEndIndex;
+            }
+            fillStartIndex = ((y - 1) * FullFileRenderStrategy._columnCount + (tokenEndIndex + xOffset)) * 6 ;
+            fillEndIndex = (y * FullFileRenderStrategy._columnCount) * 6 ;
+            cellBuffer.fill(0, fillStartIndex, fillEndIndex);
+            upToDateLines.add(y);
+        }
+        const visibleObjectCount = (viewportData.endLineNumber - viewportData.startLineNumber + 1) * lineIndexCount;
+        if (dirtyLineStart <= dirtyLineEnd) {
+            this._device.queue.writeBuffer(this._cellBindBuffer, (dirtyLineStart - 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT, cellBuffer.buffer, (dirtyLineStart - 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT, (dirtyLineEnd - dirtyLineStart + 1) * lineIndexCount * Float32Array.BYTES_PER_ELEMENT);
+        }
+        this._activeDoubleBufferIndex = this._activeDoubleBufferIndex ? 0 : 1;
+        this._visibleObjectCount = visibleObjectCount;
+        return visibleObjectCount;
+    }
+    draw(pass, viewportData) {
+        if (this._visibleObjectCount <= 0) {
+            throw ( new BugIndicatingError('Attempt to draw 0 objects'));
+        }
+        pass.draw(quadVertices.length / 2, this._visibleObjectCount, undefined, (viewportData.startLineNumber - 1) * FullFileRenderStrategy._columnCount);
+    }
+}
+export { FullFileRenderStrategy };

package/vscode/src/vs/editor/browser/gpu/fullFileRenderStrategy.wgsl.js

@@ -0,0 +1,88 @@
+const fullFileRenderStrategyWgsl =  `
+struct GlyphInfo {
+	position: vec2f,
+	size: vec2f,
+	origin: vec2f,
+};
+
+struct Vertex {
+	@location(0) position: vec2f,
+};
+
+struct Cell {
+	position: vec2f,
+	unused1: vec2f,
+	glyphIndex: f32,
+	textureIndex: f32
+};
+
+struct LayoutInfo {
+	canvasDims: vec2f,
+	viewportOffset: vec2f,
+	viewportDims: vec2f,
+}
+
+struct ScrollOffset {
+	offset: vec2f
+}
+
+struct VSOutput {
+	@builtin(position) position:   vec4f,
+	@location(1)       layerIndex: f32,
+	@location(0)       texcoord:   vec2f,
+};
+
+// Uniforms
+@group(0) @binding(${5 })       var<uniform>       layoutInfo:      LayoutInfo;
+@group(0) @binding(${6 })  var<uniform>       atlasDims:       vec2f;
+@group(0) @binding(${7 })            var<uniform>       scrollOffset:    ScrollOffset;
+
+// Storage buffers
+@group(0) @binding(${0 })              var<storage, read> glyphInfo0:      array<GlyphInfo>;
+@group(0) @binding(${1 })              var<storage, read> glyphInfo1:      array<GlyphInfo>;
+@group(0) @binding(${2 })                   var<storage, read> cells:           array<Cell>;
+
+@vertex fn vs(
+	vert: Vertex,
+	@builtin(instance_index) instanceIndex: u32,
+	@builtin(vertex_index) vertexIndex : u32
+) -> VSOutput {
+	let cell = cells[instanceIndex];
+	// TODO: Is there a nicer way to init this?
+	var glyph = glyphInfo0[0];
+	let glyphIndex = u32(cell.glyphIndex);
+	if (u32(cell.textureIndex) == 0) {
+		glyph = glyphInfo0[glyphIndex];
+	} else {
+		glyph = glyphInfo1[glyphIndex];
+	}
+
+	var vsOut: VSOutput;
+	// Multiple vert.position by 2,-2 to get it into clipspace which ranged from -1 to 1
+	vsOut.position = vec4f(
+		(((vert.position * vec2f(2, -2)) / layoutInfo.canvasDims)) * glyph.size + cell.position + ((glyph.origin * vec2f(2, -2)) / layoutInfo.canvasDims) + (((layoutInfo.viewportOffset - scrollOffset.offset * vec2(1, -1)) * 2) / layoutInfo.canvasDims),
+		0.0,
+		1.0
+	);
+
+	vsOut.layerIndex = cell.textureIndex;
+	// Textures are flipped from natural direction on the y-axis, so flip it back
+	vsOut.texcoord = vert.position;
+	vsOut.texcoord = (
+		// Glyph offset (0-1)
+		(glyph.position / atlasDims) +
+		// Glyph coordinate (0-1)
+		(vsOut.texcoord * (glyph.size / atlasDims))
+	);
+
+	return vsOut;
+}
+
+@group(0) @binding(${3 }) var ourSampler: sampler;
+@group(0) @binding(${4 })        var ourTexture: texture_2d_array<f32>;
+
+@fragment fn fs(vsOut: VSOutput) -> @location(0) vec4f {
+	return textureSample(ourTexture, ourSampler, vsOut.texcoord, u32(vsOut.layerIndex));
+}
+`;
+export { fullFileRenderStrategyWgsl };

package/vscode/src/vs/editor/browser/gpu/gpuDisposable.js

@@ -0,0 +1,42 @@
+import { isFunction } from '../../../base/common/types.js';
+var GPULifecycle;
+( (function(GPULifecycle) {
+    async function requestDevice(fallback) {
+        try {
+            if (!navigator.gpu) {
+                throw ( new Error('This browser does not support WebGPU'));
+            }
+            const adapter = (await navigator.gpu.requestAdapter());
+            if (!adapter) {
+                throw ( new Error('This browser supports WebGPU but it appears to be disabled'));
+            }
+            return wrapDestroyableInDisposable(await adapter.requestDevice());
+        }
+        catch (e) {
+            if (fallback) {
+                fallback(e.message);
+            }
+            throw e;
+        }
+    }
+    GPULifecycle.requestDevice = requestDevice;
+    function createBuffer(device, descriptor, initialValues) {
+        const buffer = device.createBuffer(descriptor);
+        if (initialValues) {
+            device.queue.writeBuffer(buffer, 0, isFunction(initialValues) ? initialValues() : initialValues);
+        }
+        return wrapDestroyableInDisposable(buffer);
+    }
+    GPULifecycle.createBuffer = createBuffer;
+    function createTexture(device, descriptor) {
+        return wrapDestroyableInDisposable(device.createTexture(descriptor));
+    }
+    GPULifecycle.createTexture = createTexture;
+})(GPULifecycle || (GPULifecycle = {})));
+function wrapDestroyableInDisposable(value) {
+    return {
+        object: value,
+        dispose: () => value.destroy()
+    };
+}
+export { GPULifecycle };

package/vscode/src/vs/editor/browser/gpu/gpuUtils.js

@@ -0,0 +1,44 @@
+import { BugIndicatingError } from '../../../base/common/errors.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+const quadVertices = ( new Float32Array([
+    1, 0,
+    1, 1,
+    0, 1,
+    0, 0,
+    0, 1,
+    1, 0,
+]));
+function ensureNonNullable(value) {
+    if (!value) {
+        throw ( new Error(`Value "${value}" cannot be null`));
+    }
+    return value;
+}
+function observeDevicePixelDimensions(element, parentWindow, callback) {
+    let observer = new parentWindow.ResizeObserver((entries) => {
+        const entry = entries.find((entry) => entry.target === element);
+        if (!entry) {
+            return;
+        }
+        if (!('devicePixelContentBoxSize' in entry)) {
+            observer?.disconnect();
+            observer = undefined;
+            return;
+        }
+        const width = entry.devicePixelContentBoxSize[0].inlineSize;
+        const height = entry.devicePixelContentBoxSize[0].blockSize;
+        if (width > 0 && height > 0) {
+            callback(width, height);
+        }
+    });
+    try {
+        observer.observe(element, { box: ['device-pixel-content-box'] });
+    }
+    catch {
+        observer.disconnect();
+        observer = undefined;
+        throw ( new BugIndicatingError('Could not observe device pixel dimensions'));
+    }
+    return toDisposable(() => observer?.disconnect());
+}
+export { ensureNonNullable, observeDevicePixelDimensions, quadVertices };