@next2d/webgpu 3.0.0

package/src/Shader/wgsl/vertex/FilterVertex.js

@@ -0,0 +1,193 @@
+import { WgslFullscreenPositions, WgslUnitQuadVertices, WgslVertexOutput } from "../common/SharedWgsl";
+const createFullscreenQuadVertex = (yFlipTexCoord) => /* wgsl */ `
+${WgslVertexOutput}
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+${WgslFullscreenPositions}
+    var texCoords = array<vec2<f32>, 6>(
+        vec2<f32>(0.0, ${yFlipTexCoord ? "1.0" : "0.0"}),
+        vec2<f32>(1.0, ${yFlipTexCoord ? "1.0" : "0.0"}),
+        vec2<f32>(0.0, ${yFlipTexCoord ? "0.0" : "1.0"}),
+        vec2<f32>(0.0, ${yFlipTexCoord ? "0.0" : "1.0"}),
+        vec2<f32>(1.0, ${yFlipTexCoord ? "1.0" : "0.0"}),
+        vec2<f32>(1.0, ${yFlipTexCoord ? "0.0" : "1.0"})
+    );
+    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
+    output.texCoord = texCoords[vertexIndex];
+    return output;
+}
+`;
+export const BlurFilterVertex = createFullscreenQuadVertex(true);
+export const ComplexBlendVertex = createFullscreenQuadVertex(false);
+export const ComplexBlendCopyVertex = createFullscreenQuadVertex(false);
+export const NodeClearVertex = /* wgsl */ `
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+}
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    let ndc = input.position * 2.0 - 1.0;
+    output.position = vec4<f32>(ndc.x, ndc.y, 0.0, 1.0);
+    return output;
+}
+`;
+export const PositionedTextureVertex = /* wgsl */ `
+struct PositionUniforms {
+    offset: vec2<f32>,
+    size: vec2<f32>,
+    viewport: vec2<f32>,
+    padding: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+${WgslUnitQuadVertices}
+    let vertex = vertices[vertexIndex];
+    output.texCoord = vec2<f32>(vertex.x, 1.0 - vertex.y);
+    var position = vertex * uniforms.size + uniforms.offset;
+    position = position / uniforms.viewport;
+    position = position * 2.0 - 1.0;
+    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);
+    return output;
+}
+`;
+export const BitmapSyncVertex = /* wgsl */ `
+struct BitmapSyncUniforms {
+    nodeRect: vec4<f32>,
+    textureSize: vec2<f32>,
+    padding: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: BitmapSyncUniforms;
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+${WgslUnitQuadVertices}
+    let vertex = vertices[vertexIndex];
+    let pixelPos = vec2<f32>(
+        uniforms.nodeRect.x + vertex.x * uniforms.nodeRect.z,
+        uniforms.nodeRect.y + vertex.y * uniforms.nodeRect.w
+    );
+    let ndc = pixelPos / uniforms.textureSize * 2.0 - 1.0;
+    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);
+    output.texCoord = pixelPos / uniforms.textureSize;
+    return output;
+}
+`;
+export const BlendModeVertex = /* wgsl */ `
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) texCoord: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    output.position = vec4<f32>(input.position, 0.0, 1.0);
+    output.texCoord = input.texCoord;
+    return output;
+}
+`;
+const ScaleUniformsAndStruct = `
+struct ScaleUniforms {
+    matrix: vec4<f32>,
+    translate: vec2<f32>,
+    srcSize: vec2<f32>,
+    dstSize: vec2<f32>,
+    padding: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: ScaleUniforms;
+`;
+const ScaleTransformBody = `
+    var pos = vertex * uniforms.srcSize;
+    let a = uniforms.matrix.x;
+    let b = uniforms.matrix.y;
+    let c = uniforms.matrix.z;
+    let d = uniforms.matrix.w;
+    let tx = uniforms.translate.x;
+    let ty = uniforms.translate.y;
+    let transformedX = pos.x * a + pos.y * c + tx;
+    let transformedY = pos.x * b + pos.y * d + ty;
+    var position = vec2<f32>(transformedX, transformedY) / uniforms.dstSize;
+    position = position * 2.0 - 1.0;
+    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);
+`;
+const createScaleVertex = (yFlipTexCoord) => /* wgsl */ `
+${ScaleUniformsAndStruct}
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+${WgslUnitQuadVertices}
+    let vertex = vertices[vertexIndex];
+    output.texCoord = ${yFlipTexCoord ? "vec2<f32>(vertex.x, 1.0 - vertex.y)" : "vertex"};
+${ScaleTransformBody}
+    return output;
+}
+`;
+export const TextureScaleVertex = createScaleVertex(false);
+export const TextureScaleBlendVertex = createScaleVertex(true);
+export const ComplexBlendScaleVertex = createScaleVertex(false);
+const createOutputVertex = (yFlipTexCoord) => /* wgsl */ `
+struct PositionUniforms {
+    offset: vec2<f32>,
+    size: vec2<f32>,
+    viewport: vec2<f32>,
+    padding: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: PositionUniforms;
+
+@vertex
+fn main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+    var output: VertexOutput;
+${WgslUnitQuadVertices}
+    let vertex = vertices[vertexIndex];
+    output.texCoord = ${yFlipTexCoord ? "vec2<f32>(vertex.x, 1.0 - vertex.y)" : "vertex"};
+    var position = vertex * uniforms.size + uniforms.offset;
+    position = position / uniforms.viewport;
+    position = position * 2.0 - 1.0;
+    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);
+    return output;
+}
+`;
+export const ComplexBlendOutputVertex = createOutputVertex(false);
+export const FilterComplexBlendOutputVertex = createOutputVertex(true);

package/src/Shader/wgsl/vertex/GradientVertex.d.ts

@@ -0,0 +1 @@
+export declare const GradientFillVertex = "\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) v_uv: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n    @location(2) color: vec4<f32>,\n}\n\nstruct GradientUniforms {\n    inverseMatrix: mat3x3<f32>,\n    gradientType: f32,\n    focal: f32,\n    spread: f32,\n    radius: f32,\n    linearPoints: vec4<f32>,\n    color: vec4<f32>,\n    contextMatrix0: vec4<f32>,\n    contextMatrix1: vec4<f32>,\n    contextMatrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> gradient: GradientUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let contextMatrix = mat3x3<f32>(gradient.contextMatrix0.xyz, gradient.contextMatrix1.xyz, gradient.contextMatrix2.xyz);\n    let pos = contextMatrix * vec3<f32>(input.position, 1.0);\n    let ndc = vec2<f32>(pos.x * 2.0 - 1.0, pos.y * 2.0 - 1.0);\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    let uvPos = gradient.inverseMatrix * vec3<f32>(input.position, 1.0);\n    output.v_uv = uvPos.xy;\n    output.bezier = input.bezier;\n    output.color = gradient.color;\n    return output;\n}\n";

package/src/Shader/wgsl/vertex/GradientVertex.js

@@ -0,0 +1,44 @@
+export const GradientFillVertex = /* wgsl */ `
+override yFlipSign: f32 = 1.0;
+
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) bezier: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) v_uv: vec2<f32>,
+    @location(1) bezier: vec2<f32>,
+    @location(2) color: vec4<f32>,
+}
+
+struct GradientUniforms {
+    inverseMatrix: mat3x3<f32>,
+    gradientType: f32,
+    focal: f32,
+    spread: f32,
+    radius: f32,
+    linearPoints: vec4<f32>,
+    color: vec4<f32>,
+    contextMatrix0: vec4<f32>,
+    contextMatrix1: vec4<f32>,
+    contextMatrix2: vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> gradient: GradientUniforms;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    let contextMatrix = mat3x3<f32>(gradient.contextMatrix0.xyz, gradient.contextMatrix1.xyz, gradient.contextMatrix2.xyz);
+    let pos = contextMatrix * vec3<f32>(input.position, 1.0);
+    let ndc = vec2<f32>(pos.x * 2.0 - 1.0, pos.y * 2.0 - 1.0);
+    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);
+    let uvPos = gradient.inverseMatrix * vec3<f32>(input.position, 1.0);
+    output.v_uv = uvPos.xy;
+    output.bezier = input.bezier;
+    output.color = gradient.color;
+    return output;
+}
+`;

package/src/Shader/wgsl/vertex/InstancedVertex.d.ts

@@ -0,0 +1 @@
+export declare const InstancedVertex = "\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) texCoord: vec2<f32>,\n}\n\nstruct InstanceInput {\n    @location(2) textureRect: vec4<f32>,\n    @location(3) textureDim: vec4<f32>,\n    @location(4) matrixTx: vec4<f32>,\n    @location(5) matrixScale: vec4<f32>,\n    @location(6) mulColor: vec4<f32>,\n    @location(7) addColor: vec4<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) mulColor: vec4<f32>,\n    @location(2) addColor: vec4<f32>,\n}\n\n@vertex\nfn main(\n    input: VertexInput,\n    instance: InstanceInput,\n    @builtin(instance_index) instanceIdx: u32\n) -> VertexOutput {\n    var output: VertexOutput;\n    let texX = instance.textureRect.x + input.texCoord.x * instance.textureRect.z;\n    let texY = instance.textureRect.y + input.texCoord.y * instance.textureRect.w;\n    output.texCoord = vec2<f32>(texX, texY);\n    var pos = vec2<f32>(input.position.x, 1.0 - input.position.y);\n    pos = pos * vec2<f32>(instance.textureDim.x, instance.textureDim.y);\n    let scale0 = instance.matrixScale.x;\n    let rotate0 = instance.matrixScale.y;\n    let scale1 = instance.matrixScale.z;\n    let rotate1 = instance.matrixScale.w;\n    let transformedX = pos.x * scale0 + pos.y * scale1 + instance.matrixTx.x;\n    let transformedY = pos.x * rotate0 + pos.y * rotate1 + instance.matrixTx.y;\n    var position = vec2<f32>(transformedX, transformedY) / vec2<f32>(instance.textureDim.z, instance.textureDim.w);\n    position = position * 2.0 - 1.0;\n    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);\n    output.mulColor = instance.mulColor;\n    output.addColor = instance.addColor;\n    return output;\n}\n";

package/src/Shader/wgsl/vertex/InstancedVertex.js

@@ -0,0 +1,48 @@
+export const InstancedVertex = /* wgsl */ `
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) texCoord: vec2<f32>,
+}
+
+struct InstanceInput {
+    @location(2) textureRect: vec4<f32>,
+    @location(3) textureDim: vec4<f32>,
+    @location(4) matrixTx: vec4<f32>,
+    @location(5) matrixScale: vec4<f32>,
+    @location(6) mulColor: vec4<f32>,
+    @location(7) addColor: vec4<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+    @location(1) mulColor: vec4<f32>,
+    @location(2) addColor: vec4<f32>,
+}
+
+@vertex
+fn main(
+    input: VertexInput,
+    instance: InstanceInput,
+    @builtin(instance_index) instanceIdx: u32
+) -> VertexOutput {
+    var output: VertexOutput;
+    let texX = instance.textureRect.x + input.texCoord.x * instance.textureRect.z;
+    let texY = instance.textureRect.y + input.texCoord.y * instance.textureRect.w;
+    output.texCoord = vec2<f32>(texX, texY);
+    var pos = vec2<f32>(input.position.x, 1.0 - input.position.y);
+    pos = pos * vec2<f32>(instance.textureDim.x, instance.textureDim.y);
+    let scale0 = instance.matrixScale.x;
+    let rotate0 = instance.matrixScale.y;
+    let scale1 = instance.matrixScale.z;
+    let rotate1 = instance.matrixScale.w;
+    let transformedX = pos.x * scale0 + pos.y * scale1 + instance.matrixTx.x;
+    let transformedY = pos.x * rotate0 + pos.y * rotate1 + instance.matrixTx.y;
+    var position = vec2<f32>(transformedX, transformedY) / vec2<f32>(instance.textureDim.z, instance.textureDim.w);
+    position = position * 2.0 - 1.0;
+    output.position = vec4<f32>(position.x, -position.y, 0.0, 1.0);
+    output.mulColor = instance.mulColor;
+    output.addColor = instance.addColor;
+    return output;
+}
+`;

package/src/Shader/wgsl/vertex/MaskVertex.d.ts

@@ -0,0 +1 @@
+export declare const MaskVertex = "\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct Uniforms {\n    viewportSize: vec2<f32>,\n    _padding0: vec2<f32>,\n    matrixCol0: vec3<f32>,\n    _padding1: f32,\n    matrixCol1: vec3<f32>,\n    _padding2: f32,\n    matrixCol2: vec3<f32>,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrixCol0, uniforms.matrixCol1, uniforms.matrixCol2);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let pos = transformed.xy;\n    let ndc = pos * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n";

package/src/Shader/wgsl/vertex/MaskVertex.js

@@ -0,0 +1,36 @@
+export const MaskVertex = /* wgsl */ `
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) bezier: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) bezier: vec2<f32>,
+}
+
+struct Uniforms {
+    viewportSize: vec2<f32>,
+    _padding0: vec2<f32>,
+    matrixCol0: vec3<f32>,
+    _padding1: f32,
+    matrixCol1: vec3<f32>,
+    _padding2: f32,
+    matrixCol2: vec3<f32>,
+    _padding3: f32,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    let matrix = mat3x3<f32>(uniforms.matrixCol0, uniforms.matrixCol1, uniforms.matrixCol2);
+    let transformed = matrix * vec3<f32>(input.position, 1.0);
+    let pos = transformed.xy;
+    let ndc = pos * 2.0 - 1.0;
+    output.position = vec4<f32>(ndc.x, -ndc.y, 0.0, 1.0);
+    output.bezier = input.bezier;
+    return output;
+}
+`;

package/src/Shader/wgsl/vertex/StencilVertex.d.ts

@@ -0,0 +1,2 @@
+export declare const StencilWriteVertex = "\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.bezier = input.bezier;\n    return output;\n}\n";
+export declare const StencilFillVertex = "\noverride yFlipSign: f32 = 1.0;\n\nstruct VertexInput {\n    @location(0) position: vec2<f32>,\n    @location(1) bezier: vec2<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) color: vec4<f32>,\n}\n\nstruct FillUniforms {\n    color: vec4<f32>,\n    matrix0: vec4<f32>,\n    matrix1: vec4<f32>,\n    matrix2: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: FillUniforms;\n\n@vertex\nfn main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);\n    let transformed = matrix * vec3<f32>(input.position, 1.0);\n    let ndc = transformed.xy * 2.0 - 1.0;\n    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);\n    output.color = uniforms.color;\n    return output;\n}\n";

package/src/Shader/wgsl/vertex/StencilVertex.js

@@ -0,0 +1,66 @@
+export const StencilWriteVertex = /* wgsl */ `
+override yFlipSign: f32 = 1.0;
+
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) bezier: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) bezier: vec2<f32>,
+}
+
+struct FillUniforms {
+    color: vec4<f32>,
+    matrix0: vec4<f32>,
+    matrix1: vec4<f32>,
+    matrix2: vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: FillUniforms;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);
+    let transformed = matrix * vec3<f32>(input.position, 1.0);
+    let ndc = transformed.xy * 2.0 - 1.0;
+    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);
+    output.bezier = input.bezier;
+    return output;
+}
+`;
+export const StencilFillVertex = /* wgsl */ `
+override yFlipSign: f32 = 1.0;
+
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) bezier: vec2<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+}
+
+struct FillUniforms {
+    color: vec4<f32>,
+    matrix0: vec4<f32>,
+    matrix1: vec4<f32>,
+    matrix2: vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: FillUniforms;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    let matrix = mat3x3<f32>(uniforms.matrix0.xyz, uniforms.matrix1.xyz, uniforms.matrix2.xyz);
+    let transformed = matrix * vec3<f32>(input.position, 1.0);
+    let ndc = transformed.xy * 2.0 - 1.0;
+    output.position = vec4<f32>(ndc.x, ndc.y * yFlipSign, 0.0, 1.0);
+    output.color = uniforms.color;
+    return output;
+}
+`;

package/src/TextureManager/service/TextureManagerInitializeSamplersService.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @description サンプラーを初期化
+ *              Initialize samplers
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUSampler>} samplers
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, samplers: Map<string, GPUSampler>) => void;

package/src/TextureManager/service/TextureManagerInitializeSamplersService.js

@@ -0,0 +1,48 @@
+/**
+ * @description サンプラーを初期化
+ *              Initialize samplers
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUSampler>} samplers
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (device, samplers) => {
+    // デフォルトサンプラー（リニアフィルタリング）
+    const linearSampler = device.createSampler({
+        "magFilter": "linear",
+        "minFilter": "linear",
+        "mipmapFilter": "linear",
+        "addressModeU": "clamp-to-edge",
+        "addressModeV": "clamp-to-edge"
+    });
+    samplers.set("linear", linearSampler);
+    // ニアレストサンプラー
+    const nearestSampler = device.createSampler({
+        "magFilter": "nearest",
+        "minFilter": "nearest",
+        "mipmapFilter": "nearest",
+        "addressModeU": "clamp-to-edge",
+        "addressModeV": "clamp-to-edge"
+    });
+    samplers.set("nearest", nearestSampler);
+    // アトラス用サンプラー（min: linear, mag: nearest）
+    const atlasSampler = device.createSampler({
+        "magFilter": "nearest",
+        "minFilter": "linear",
+        "mipmapFilter": "nearest",
+        "addressModeU": "clamp-to-edge",
+        "addressModeV": "clamp-to-edge"
+    });
+    samplers.set("atlas_instanced_sampler", atlasSampler);
+    // リピートサンプラー
+    const repeatSampler = device.createSampler({
+        "magFilter": "linear",
+        "minFilter": "linear",
+        "mipmapFilter": "linear",
+        "addressModeU": "repeat",
+        "addressModeV": "repeat"
+    });
+    samplers.set("repeat", repeatSampler);
+};

package/src/TextureManager/usecase/TextureManagerCreateTextureFromImageBitmapUseCase.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description ImageBitmapからテクスチャを作成
+ *              Create texture from ImageBitmap
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUTexture>} textures
+ * @param  {string} name
+ * @param  {ImageBitmap} image_bitmap
+ * @return {GPUTexture}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, textures: Map<string, GPUTexture>, name: string, image_bitmap: ImageBitmap) => GPUTexture;

package/src/TextureManager/usecase/TextureManagerCreateTextureFromImageBitmapUseCase.js

@@ -0,0 +1,30 @@
+/**
+ * @description ImageBitmapからテクスチャを作成
+ *              Create texture from ImageBitmap
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUTexture>} textures
+ * @param  {string} name
+ * @param  {ImageBitmap} image_bitmap
+ * @return {GPUTexture}
+ * @method
+ * @protected
+ */
+export const execute = (device, textures, name, image_bitmap) => {
+    const texture = device.createTexture({
+        "size": { "width": image_bitmap.width, "height": image_bitmap.height },
+        "format": "rgba8unorm",
+        "usage": GPUTextureUsage.TEXTURE_BINDING |
+            GPUTextureUsage.COPY_DST |
+            GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    device.queue.copyExternalImageToTexture({
+        "source": image_bitmap,
+        "flipY": true
+    }, {
+        texture,
+        "premultipliedAlpha": true
+    }, { "width": image_bitmap.width, "height": image_bitmap.height });
+    textures.set(name, texture);
+    return texture;
+};

package/src/TextureManager/usecase/TextureManagerCreateTextureFromPixelsUseCase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description ピクセルデータからテクスチャを作成
+ *              Create texture from pixel data
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUTexture>} textures
+ * @param  {string} name
+ * @param  {Uint8Array} pixels
+ * @param  {number} width
+ * @param  {number} height
+ * @return {GPUTexture}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, textures: Map<string, GPUTexture>, name: string, pixels: Uint8Array, width: number, height: number) => GPUTexture;

package/src/TextureManager/usecase/TextureManagerCreateTextureFromPixelsUseCase.js

@@ -0,0 +1,26 @@
+/**
+ * @description ピクセルデータからテクスチャを作成
+ *              Create texture from pixel data
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, GPUTexture>} textures
+ * @param  {string} name
+ * @param  {Uint8Array} pixels
+ * @param  {number} width
+ * @param  {number} height
+ * @return {GPUTexture}
+ * @method
+ * @protected
+ */
+export const execute = (device, textures, name, pixels, width, height) => {
+    const texture = device.createTexture({
+        "size": { width, height },
+        "format": "rgba8unorm",
+        "usage": GPUTextureUsage.TEXTURE_BINDING |
+            GPUTextureUsage.COPY_DST |
+            GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    device.queue.writeTexture({ texture }, pixels.buffer, { "bytesPerRow": width * 4, "offset": pixels.byteOffset }, { width, height });
+    textures.set(name, texture);
+    return texture;
+};

package/src/TextureManager.d.ts

@@ -0,0 +1,15 @@
+export declare class TextureManager {
+    private device;
+    private textures;
+    private samplers;
+    constructor(device: GPUDevice);
+    createTexture(name: string, width: number, height: number, format?: GPUTextureFormat): GPUTexture;
+    createTextureFromPixels(name: string, pixels: Uint8Array, width: number, height: number): GPUTexture;
+    createTextureFromImageBitmap(name: string, imageBitmap: ImageBitmap): GPUTexture;
+    updateTexture(name: string, pixels: Uint8Array, width: number, height: number): void;
+    getTexture(name: string): GPUTexture | undefined;
+    getSampler(name: string): GPUSampler | undefined;
+    createSampler(name: string, smooth?: boolean): GPUSampler;
+    destroyTexture(name: string): void;
+    dispose(): void;
+}

package/src/TextureManager.js

@@ -0,0 +1,87 @@
+import { execute as textureManagerInitializeSamplersService } from "./TextureManager/service/TextureManagerInitializeSamplersService";
+import { execute as textureManagerCreateTextureFromPixelsUseCase } from "./TextureManager/usecase/TextureManagerCreateTextureFromPixelsUseCase";
+import { execute as textureManagerCreateTextureFromImageBitmapUseCase } from "./TextureManager/usecase/TextureManagerCreateTextureFromImageBitmapUseCase";
+export class TextureManager {
+    constructor(device) {
+        Object.defineProperty(this, "device", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "textures", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "samplers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.device = device;
+        this.textures = new Map();
+        this.samplers = new Map();
+        textureManagerInitializeSamplersService(device, this.samplers);
+    }
+    createTexture(name, width, height, format = "rgba8unorm") {
+        const texture = this.device.createTexture({
+            "size": { width, height },
+            "format": format,
+            "usage": GPUTextureUsage.TEXTURE_BINDING |
+                GPUTextureUsage.COPY_DST |
+                GPUTextureUsage.RENDER_ATTACHMENT
+        });
+        this.textures.set(name, texture);
+        return texture;
+    }
+    createTextureFromPixels(name, pixels, width, height) {
+        return textureManagerCreateTextureFromPixelsUseCase(this.device, this.textures, name, pixels, width, height);
+    }
+    createTextureFromImageBitmap(name, imageBitmap) {
+        return textureManagerCreateTextureFromImageBitmapUseCase(this.device, this.textures, name, imageBitmap);
+    }
+    updateTexture(name, pixels, width, height) {
+        const texture = this.textures.get(name);
+        if (texture) {
+            this.device.queue.writeTexture({ texture }, pixels.buffer, { "bytesPerRow": width * 4, "offset": pixels.byteOffset }, { width, height });
+        }
+    }
+    getTexture(name) {
+        return this.textures.get(name);
+    }
+    getSampler(name) {
+        return this.samplers.get(name);
+    }
+    createSampler(name, smooth = true) {
+        const existing = this.samplers.get(name);
+        if (existing) {
+            return existing;
+        }
+        const sampler = this.device.createSampler({
+            "magFilter": smooth ? "linear" : "nearest",
+            "minFilter": smooth ? "linear" : "nearest",
+            "mipmapFilter": smooth ? "linear" : "nearest",
+            "addressModeU": "clamp-to-edge",
+            "addressModeV": "clamp-to-edge"
+        });
+        this.samplers.set(name, sampler);
+        return sampler;
+    }
+    destroyTexture(name) {
+        const texture = this.textures.get(name);
+        if (texture) {
+            texture.destroy();
+            this.textures.delete(name);
+        }
+    }
+    dispose() {
+        for (const texture of this.textures.values()) {
+            texture.destroy();
+        }
+        this.textures.clear();
+        this.samplers.clear();
+    }
+}