workbench.desktop.main.js · part 23

60 text occurrences from desktop/Cursor.app/Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js, part 23. Every entry preserves the shipped literal and its saved verdict or selection reason.

File contents and all parts · All files

     Slabs: ${this._slabs.length} of ${Math.floor(this._canvas.width/c)*Math.floor(this._canvas.height/l)}

use strict

New glyph

use strict

Attempt to create a texture atlas page past the limit ${fme.maximumPageCount}

Cannot warm atlas without color map

use strict

This browser does not support WebGPU

This browser supports WebGPU but it appears to be disabled

use strict

use strict

Data length ${e.length} does not match the number of properties in the collection (${this._propertySpecsMap.size})

use strict

struct Vertex {
	@location(0) position: vec2f,
};

struct LayoutInfo {
	canvasDims: vec2f,
	viewportOffset: vec2f,
	viewportDims: vec2f,
}

struct ScrollOffset {
	offset: vec2f,
}

struct Shape {
	position: vec2f,
	size: vec2f,
	color: vec4f,
};

struct VSOutput {
	@builtin(position) position: vec4f,
	@location(1)       color:    vec4f,
};

// Uniforms
@group(0) @binding(1) var<uniform>       layoutInfo:      LayoutInfo;

// Storage buffers
@group(0) @binding(0)            var<storage, read> shapes:          array<Shape>;
@group(0) @binding(2)      var<uniform>       scrollOffset:    ScrollOffset;

@vertex fn vs(
	vert: Vertex,
	@builtin(instance_index) instanceIndex: u32,
	@builtin(vertex_index) vertexIndex : u32
) -> VSOutput {
	let shape = shapes[instanceIndex];

	var vsOut: VSOutput;
	vsOut.position = vec4f(
		(
			// Top left corner
			vec2f(-1,  1) +
			// Convert pixel position to clipspace
			vec2f( 2, -2) / layoutInfo.canvasDims *
			// Shape position and size
			(layoutInfo.viewportOffset - scrollOffset.offset + shape.position + vert.position * shape.size)
		),
		0.0,
		1.0
	);
	vsOut.color = shape.color;
	return vsOut;
}

@fragment fn fs(vsOut: VSOutput) -> @location(0) vec4f {
	return vsOut.color;
}

use strict

Monaco rectangle renderer render pass

Monaco rectangle renderer uniform buffer

Monaco rectangle renderer scroll offset buffer

Monaco rectangle renderer shape buffer

Monaco rectangle renderer vertex buffer

Monaco rectangle renderer shader module

Monaco rectangle renderer render pipeline

Monaco rectangle renderer bind group

Monaco rectangle renderer command encoder

use strict

use strict

use strict

Cannot call ViewGpuContext.textureAtlas before device is resolved

maxColumn > maxGpuCols

${p}: ${h.style[p]}

inlineDecorations with unsupported types (${o.map(l=>`\`${l}\``).join(", ")})

inlineDecorations with unsupported CSS rules (${c.map(l=>`\`${l}\``).join(", ")})

inlineDecorations with unsupported CSS selectors (${a.map(l=>`\`${l}\``).join(", ")})

use strict

use strict

use strict

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(4)       var<uniform>       layoutInfo:      LayoutInfo;
@group(0) @binding(5)  var<uniform>       atlasDims:       vec2f;
@group(0) @binding(6)            var<uniform>       scrollOffset:    ScrollOffset;

// Storage buffers
@group(0) @binding(0)               var<storage, read> glyphInfo:       array<array<GlyphInfo, ${eie.maximumGlyphCount}>, ${fme.maximumPageCount}>;
@group(0) @binding(1)                   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];
	var glyph = glyphInfo[u32(cell.textureIndex)][u32(cell.glyphIndex)];

	var vsOut: VSOutput;
	// Multiple vert.position by 2,-2 to get it into clipspace which ranged from -1 to 1
	vsOut.position = vec4f(
		// Make everything relative to top left instead of center
		vec2f(-1, 1) +
		((vert.position * vec2f(2, -2)) / layoutInfo.canvasDims) * glyph.size +
		((cell.position * vec2f(2, -2)) / layoutInfo.canvasDims) +
		((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(2) var ourSampler: sampler;
@group(0) @binding(3)        var ourTexture: texture_2d_array<f32>;

@fragment fn fs(vsOut: VSOutput) -> @location(0) vec4f {
	return textureSample(ourTexture, ourSampler, vsOut.texcoord, u32(vsOut.layerIndex));
}

use strict

Monaco scroll offset buffer

Monaco full file cell buffer

Invalid color format 

Unexpected inline decoration style

Attempt to draw 0 objects

use strict

Monaco full file cell buffer

Monaco scroll offset buffer

Invalid color format 

Unexpected inline decoration style

Attempt to draw 0 objects

use strict

Monaco render pass

Monaco uniform buffer

Monaco atlas info uniform buffer

Monaco glyph storage buffer

Monaco atlas texture

Monaco vertex buffer

Monaco shader module

Monaco render pipeline

Monaco bind group

Monaco atlas sampler