three-text 0.4.11 → 0.5.0

package/dist/webgl-vector/index.cjs

@@ -0,0 +1,243 @@
+'use strict';
+
+function assertCreate(value, label) {
+    if (!value) {
+        throw new Error(`Failed to create ${label}`);
+    }
+    return value;
+}
+function compileShader(gl, type, source) {
+    const shader = assertCreate(gl.createShader(type), 'shader');
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        const info = gl.getShaderInfoLog(shader) || 'unknown shader compile error';
+        gl.deleteShader(shader);
+        throw new Error(info);
+    }
+    return shader;
+}
+function linkProgram(gl, vertexSource, fragmentSource) {
+    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+    const program = assertCreate(gl.createProgram(), 'program');
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        const info = gl.getProgramInfoLog(program) || 'unknown program link error';
+        gl.deleteProgram(program);
+        throw new Error(info);
+    }
+    return program;
+}
+function getUniform(gl, program, name) {
+    const location = gl.getUniformLocation(program, name);
+    if (!location) {
+        throw new Error(`Missing uniform "${name}"`);
+    }
+    return location;
+}
+function createProgramWithMvp(gl, vertexSource, fragmentSource) {
+    const program = linkProgram(gl, vertexSource, fragmentSource);
+    return {
+        program,
+        mvp: getUniform(gl, program, 'u_mvp')
+    };
+}
+function createColorProgram(gl, vertexSource, fragmentSource) {
+    const program = linkProgram(gl, vertexSource, fragmentSource);
+    return {
+        program,
+        mvp: getUniform(gl, program, 'u_mvp'),
+        color: getUniform(gl, program, 'u_color')
+    };
+}
+function createGeometryResources(gl, data) {
+    const interiorVAO = assertCreate(gl.createVertexArray(), 'interior VAO');
+    const interiorPositionBuffer = assertCreate(gl.createBuffer(), 'interior position buffer');
+    const interiorIndexBuffer = assertCreate(gl.createBuffer(), 'interior index buffer');
+    gl.bindVertexArray(interiorVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, interiorPositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data.interiorPositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, interiorIndexBuffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.interiorIndices, gl.STATIC_DRAW);
+    const curveVAO = assertCreate(gl.createVertexArray(), 'curve VAO');
+    const curvePositionBuffer = assertCreate(gl.createBuffer(), 'curve position buffer');
+    gl.bindVertexArray(curveVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, curvePositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data.curvePositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    const fillVAO = assertCreate(gl.createVertexArray(), 'fill VAO');
+    const fillPositionBuffer = assertCreate(gl.createBuffer(), 'fill position buffer');
+    const fillIndexBuffer = assertCreate(gl.createBuffer(), 'fill index buffer');
+    const fillPositions = new Float32Array([
+        data.planeBounds.min.x,
+        data.planeBounds.min.y,
+        0,
+        data.planeBounds.max.x,
+        data.planeBounds.min.y,
+        0,
+        data.planeBounds.max.x,
+        data.planeBounds.max.y,
+        0,
+        data.planeBounds.min.x,
+        data.planeBounds.max.y,
+        0
+    ]);
+    const fillIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+    gl.bindVertexArray(fillVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, fillPositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, fillPositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, fillIndexBuffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, fillIndices, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    return {
+        interiorVAO,
+        interiorPositionBuffer,
+        interiorIndexBuffer,
+        interiorIndexCount: data.interiorIndices.length,
+        curveVAO,
+        curvePositionBuffer,
+        curveVertexCount: data.curvePositions.length / 3,
+        fillVAO,
+        fillPositionBuffer,
+        fillIndexBuffer,
+        fillIndexCount: fillIndices.length
+    };
+}
+function destroyGeometryResources(gl, resources) {
+    gl.deleteVertexArray(resources.interiorVAO);
+    gl.deleteBuffer(resources.interiorPositionBuffer);
+    gl.deleteBuffer(resources.interiorIndexBuffer);
+    gl.deleteVertexArray(resources.curveVAO);
+    gl.deleteBuffer(resources.curvePositionBuffer);
+    gl.deleteVertexArray(resources.fillVAO);
+    gl.deleteBuffer(resources.fillPositionBuffer);
+    gl.deleteBuffer(resources.fillIndexBuffer);
+}
+function createWebGLVectorRenderer(gl) {
+    const interiorVertexShader = `#version 300 es
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_mvp;
+void main() {
+  gl_Position = u_mvp * vec4(a_position, 1.0);
+}`;
+    const interiorFragmentShader = `#version 300 es
+precision highp float;
+out vec4 outColor;
+void main() {
+  outColor = vec4(1.0);
+}`;
+    const curveVertexShader = `#version 300 es
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_mvp;
+out vec2 v_uv;
+void main() {
+  int localVertex = gl_VertexID % 3;
+  float u = float(localVertex) * 0.5;
+  v_uv = vec2(u, floor(u));
+  gl_Position = u_mvp * vec4(a_position, 1.0);
+}`;
+    const curveFragmentShader = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 outColor;
+void main() {
+  vec2 px = dFdx(v_uv);
+  vec2 py = dFdy(v_uv);
+  float fx = 2.0 * v_uv.x * px.x - px.y;
+  float fy = 2.0 * v_uv.x * py.x - py.y;
+  float denom = sqrt(fx * fx + fy * fy);
+  if (denom < 1e-6) {
+    discard;
+  }
+  float sd = (v_uv.x * v_uv.x - v_uv.y) / denom;
+  float alpha = clamp(0.5 - sd, 0.0, 1.0);
+  if (alpha <= 0.0) {
+    discard;
+  }
+  outColor = vec4(1.0, 1.0, 1.0, alpha);
+}`;
+    const colorVertexShader = interiorVertexShader;
+    const colorFragmentShader = `#version 300 es
+precision highp float;
+uniform vec4 u_color;
+out vec4 outColor;
+void main() {
+  outColor = u_color;
+}`;
+    const interiorProgram = createProgramWithMvp(gl, interiorVertexShader, interiorFragmentShader);
+    const curveProgram = createProgramWithMvp(gl, curveVertexShader, curveFragmentShader);
+    const colorProgram = createColorProgram(gl, colorVertexShader, colorFragmentShader);
+    let geometryResources = null;
+    return {
+        setGeometry(data) {
+            if (geometryResources) {
+                destroyGeometryResources(gl, geometryResources);
+            }
+            geometryResources = createGeometryResources(gl, data);
+        },
+        render(mvp, color) {
+            if (!geometryResources) {
+                return;
+            }
+            gl.disable(gl.CULL_FACE);
+            gl.disable(gl.DEPTH_TEST);
+            gl.depthMask(false);
+            gl.clearStencil(0);
+            gl.stencilMask(0xff);
+            gl.clear(gl.STENCIL_BUFFER_BIT);
+            gl.enable(gl.STENCIL_TEST);
+            gl.stencilFunc(gl.ALWAYS, 0, 0xff);
+            gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);
+            gl.colorMask(false, false, false, false);
+            if (geometryResources.interiorIndexCount > 0) {
+                gl.useProgram(interiorProgram.program);
+                gl.uniformMatrix4fv(interiorProgram.mvp, false, mvp);
+                gl.bindVertexArray(geometryResources.interiorVAO);
+                gl.drawElements(gl.TRIANGLES, geometryResources.interiorIndexCount, gl.UNSIGNED_INT, 0);
+            }
+            if (geometryResources.curveVertexCount > 0) {
+                gl.enable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+                gl.useProgram(curveProgram.program);
+                gl.uniformMatrix4fv(curveProgram.mvp, false, mvp);
+                gl.bindVertexArray(geometryResources.curveVAO);
+                gl.drawArrays(gl.TRIANGLES, 0, geometryResources.curveVertexCount);
+                gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+            }
+            gl.stencilFunc(gl.NOTEQUAL, 0, 0xff);
+            gl.stencilOp(gl.KEEP, gl.KEEP, gl.ZERO);
+            gl.colorMask(true, true, true, true);
+            gl.useProgram(colorProgram.program);
+            gl.uniformMatrix4fv(colorProgram.mvp, false, mvp);
+            gl.uniform4fv(colorProgram.color, color);
+            gl.bindVertexArray(geometryResources.fillVAO);
+            gl.drawElements(gl.TRIANGLES, geometryResources.fillIndexCount, gl.UNSIGNED_SHORT, 0);
+            gl.bindVertexArray(null);
+            gl.useProgram(null);
+            gl.disable(gl.STENCIL_TEST);
+            gl.depthMask(true);
+        },
+        dispose() {
+            if (geometryResources) {
+                destroyGeometryResources(gl, geometryResources);
+                geometryResources = null;
+            }
+            gl.deleteProgram(interiorProgram.program);
+            gl.deleteProgram(curveProgram.program);
+            gl.deleteProgram(colorProgram.program);
+        }
+    };
+}
+
+exports.createWebGLVectorRenderer = createWebGLVectorRenderer;

package/dist/webgl-vector/index.d.ts

@@ -0,0 +1,34 @@
+interface BoundingBox {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+interface LoopBlinnMeshData {
+    interiorPositions: Float32Array;
+    interiorIndices: Uint32Array;
+    curvePositions: Float32Array;
+    planeBounds: BoundingBox;
+    stats: {
+        glyphCount: number;
+        contourCount: number;
+        interiorTriangleCount: number;
+        curveTriangleCount: number;
+    };
+}
+
+interface WebGLVectorRenderer {
+    setGeometry(data: LoopBlinnMeshData): void;
+    render(mvp: Float32Array, color: Float32Array): void;
+    dispose(): void;
+}
+declare function createWebGLVectorRenderer(gl: WebGL2RenderingContext): WebGLVectorRenderer;
+
+export { WebGLVectorRenderer, createWebGLVectorRenderer };

package/dist/webgl-vector/index.js

@@ -0,0 +1,241 @@
+function assertCreate(value, label) {
+    if (!value) {
+        throw new Error(`Failed to create ${label}`);
+    }
+    return value;
+}
+function compileShader(gl, type, source) {
+    const shader = assertCreate(gl.createShader(type), 'shader');
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        const info = gl.getShaderInfoLog(shader) || 'unknown shader compile error';
+        gl.deleteShader(shader);
+        throw new Error(info);
+    }
+    return shader;
+}
+function linkProgram(gl, vertexSource, fragmentSource) {
+    const vertexShader = compileShader(gl, gl.VERTEX_SHADER, vertexSource);
+    const fragmentShader = compileShader(gl, gl.FRAGMENT_SHADER, fragmentSource);
+    const program = assertCreate(gl.createProgram(), 'program');
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        const info = gl.getProgramInfoLog(program) || 'unknown program link error';
+        gl.deleteProgram(program);
+        throw new Error(info);
+    }
+    return program;
+}
+function getUniform(gl, program, name) {
+    const location = gl.getUniformLocation(program, name);
+    if (!location) {
+        throw new Error(`Missing uniform "${name}"`);
+    }
+    return location;
+}
+function createProgramWithMvp(gl, vertexSource, fragmentSource) {
+    const program = linkProgram(gl, vertexSource, fragmentSource);
+    return {
+        program,
+        mvp: getUniform(gl, program, 'u_mvp')
+    };
+}
+function createColorProgram(gl, vertexSource, fragmentSource) {
+    const program = linkProgram(gl, vertexSource, fragmentSource);
+    return {
+        program,
+        mvp: getUniform(gl, program, 'u_mvp'),
+        color: getUniform(gl, program, 'u_color')
+    };
+}
+function createGeometryResources(gl, data) {
+    const interiorVAO = assertCreate(gl.createVertexArray(), 'interior VAO');
+    const interiorPositionBuffer = assertCreate(gl.createBuffer(), 'interior position buffer');
+    const interiorIndexBuffer = assertCreate(gl.createBuffer(), 'interior index buffer');
+    gl.bindVertexArray(interiorVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, interiorPositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data.interiorPositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, interiorIndexBuffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data.interiorIndices, gl.STATIC_DRAW);
+    const curveVAO = assertCreate(gl.createVertexArray(), 'curve VAO');
+    const curvePositionBuffer = assertCreate(gl.createBuffer(), 'curve position buffer');
+    gl.bindVertexArray(curveVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, curvePositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data.curvePositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    const fillVAO = assertCreate(gl.createVertexArray(), 'fill VAO');
+    const fillPositionBuffer = assertCreate(gl.createBuffer(), 'fill position buffer');
+    const fillIndexBuffer = assertCreate(gl.createBuffer(), 'fill index buffer');
+    const fillPositions = new Float32Array([
+        data.planeBounds.min.x,
+        data.planeBounds.min.y,
+        0,
+        data.planeBounds.max.x,
+        data.planeBounds.min.y,
+        0,
+        data.planeBounds.max.x,
+        data.planeBounds.max.y,
+        0,
+        data.planeBounds.min.x,
+        data.planeBounds.max.y,
+        0
+    ]);
+    const fillIndices = new Uint16Array([0, 1, 2, 0, 2, 3]);
+    gl.bindVertexArray(fillVAO);
+    gl.bindBuffer(gl.ARRAY_BUFFER, fillPositionBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, fillPositions, gl.STATIC_DRAW);
+    gl.enableVertexAttribArray(0);
+    gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, fillIndexBuffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, fillIndices, gl.STATIC_DRAW);
+    gl.bindVertexArray(null);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+    return {
+        interiorVAO,
+        interiorPositionBuffer,
+        interiorIndexBuffer,
+        interiorIndexCount: data.interiorIndices.length,
+        curveVAO,
+        curvePositionBuffer,
+        curveVertexCount: data.curvePositions.length / 3,
+        fillVAO,
+        fillPositionBuffer,
+        fillIndexBuffer,
+        fillIndexCount: fillIndices.length
+    };
+}
+function destroyGeometryResources(gl, resources) {
+    gl.deleteVertexArray(resources.interiorVAO);
+    gl.deleteBuffer(resources.interiorPositionBuffer);
+    gl.deleteBuffer(resources.interiorIndexBuffer);
+    gl.deleteVertexArray(resources.curveVAO);
+    gl.deleteBuffer(resources.curvePositionBuffer);
+    gl.deleteVertexArray(resources.fillVAO);
+    gl.deleteBuffer(resources.fillPositionBuffer);
+    gl.deleteBuffer(resources.fillIndexBuffer);
+}
+function createWebGLVectorRenderer(gl) {
+    const interiorVertexShader = `#version 300 es
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_mvp;
+void main() {
+  gl_Position = u_mvp * vec4(a_position, 1.0);
+}`;
+    const interiorFragmentShader = `#version 300 es
+precision highp float;
+out vec4 outColor;
+void main() {
+  outColor = vec4(1.0);
+}`;
+    const curveVertexShader = `#version 300 es
+layout(location = 0) in vec3 a_position;
+uniform mat4 u_mvp;
+out vec2 v_uv;
+void main() {
+  int localVertex = gl_VertexID % 3;
+  float u = float(localVertex) * 0.5;
+  v_uv = vec2(u, floor(u));
+  gl_Position = u_mvp * vec4(a_position, 1.0);
+}`;
+    const curveFragmentShader = `#version 300 es
+precision highp float;
+in vec2 v_uv;
+out vec4 outColor;
+void main() {
+  vec2 px = dFdx(v_uv);
+  vec2 py = dFdy(v_uv);
+  float fx = 2.0 * v_uv.x * px.x - px.y;
+  float fy = 2.0 * v_uv.x * py.x - py.y;
+  float denom = sqrt(fx * fx + fy * fy);
+  if (denom < 1e-6) {
+    discard;
+  }
+  float sd = (v_uv.x * v_uv.x - v_uv.y) / denom;
+  float alpha = clamp(0.5 - sd, 0.0, 1.0);
+  if (alpha <= 0.0) {
+    discard;
+  }
+  outColor = vec4(1.0, 1.0, 1.0, alpha);
+}`;
+    const colorVertexShader = interiorVertexShader;
+    const colorFragmentShader = `#version 300 es
+precision highp float;
+uniform vec4 u_color;
+out vec4 outColor;
+void main() {
+  outColor = u_color;
+}`;
+    const interiorProgram = createProgramWithMvp(gl, interiorVertexShader, interiorFragmentShader);
+    const curveProgram = createProgramWithMvp(gl, curveVertexShader, curveFragmentShader);
+    const colorProgram = createColorProgram(gl, colorVertexShader, colorFragmentShader);
+    let geometryResources = null;
+    return {
+        setGeometry(data) {
+            if (geometryResources) {
+                destroyGeometryResources(gl, geometryResources);
+            }
+            geometryResources = createGeometryResources(gl, data);
+        },
+        render(mvp, color) {
+            if (!geometryResources) {
+                return;
+            }
+            gl.disable(gl.CULL_FACE);
+            gl.disable(gl.DEPTH_TEST);
+            gl.depthMask(false);
+            gl.clearStencil(0);
+            gl.stencilMask(0xff);
+            gl.clear(gl.STENCIL_BUFFER_BIT);
+            gl.enable(gl.STENCIL_TEST);
+            gl.stencilFunc(gl.ALWAYS, 0, 0xff);
+            gl.stencilOp(gl.KEEP, gl.KEEP, gl.INVERT);
+            gl.colorMask(false, false, false, false);
+            if (geometryResources.interiorIndexCount > 0) {
+                gl.useProgram(interiorProgram.program);
+                gl.uniformMatrix4fv(interiorProgram.mvp, false, mvp);
+                gl.bindVertexArray(geometryResources.interiorVAO);
+                gl.drawElements(gl.TRIANGLES, geometryResources.interiorIndexCount, gl.UNSIGNED_INT, 0);
+            }
+            if (geometryResources.curveVertexCount > 0) {
+                gl.enable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+                gl.useProgram(curveProgram.program);
+                gl.uniformMatrix4fv(curveProgram.mvp, false, mvp);
+                gl.bindVertexArray(geometryResources.curveVAO);
+                gl.drawArrays(gl.TRIANGLES, 0, geometryResources.curveVertexCount);
+                gl.disable(gl.SAMPLE_ALPHA_TO_COVERAGE);
+            }
+            gl.stencilFunc(gl.NOTEQUAL, 0, 0xff);
+            gl.stencilOp(gl.KEEP, gl.KEEP, gl.ZERO);
+            gl.colorMask(true, true, true, true);
+            gl.useProgram(colorProgram.program);
+            gl.uniformMatrix4fv(colorProgram.mvp, false, mvp);
+            gl.uniform4fv(colorProgram.color, color);
+            gl.bindVertexArray(geometryResources.fillVAO);
+            gl.drawElements(gl.TRIANGLES, geometryResources.fillIndexCount, gl.UNSIGNED_SHORT, 0);
+            gl.bindVertexArray(null);
+            gl.useProgram(null);
+            gl.disable(gl.STENCIL_TEST);
+            gl.depthMask(true);
+        },
+        dispose() {
+            if (geometryResources) {
+                destroyGeometryResources(gl, geometryResources);
+                geometryResources = null;
+            }
+            gl.deleteProgram(interiorProgram.program);
+            gl.deleteProgram(curveProgram.program);
+            gl.deleteProgram(colorProgram.program);
+        }
+    };
+}
+
+export { createWebGLVectorRenderer };