@daidr/minecraft-skin-renderer 0.1.0

package/dist/plugins/panorama/SkyboxGeometry.mjs

@@ -0,0 +1,132 @@
+//#region src/plugins/panorama/SkyboxGeometry.ts
+/**
+* Create a skybox cube geometry.
+* The cube is centered at origin with size 2 (from -1 to 1 on each axis).
+* Faces are wound to point inward (for rendering from inside the cube).
+*
+* @param size - Size of the cube (default 2.0)
+*/
+function createSkyboxGeometry(size = 2) {
+	const s = size / 2;
+	const vertices = new Float32Array([
+		-s,
+		-s,
+		s,
+		s,
+		-s,
+		s,
+		s,
+		s,
+		s,
+		-s,
+		s,
+		s,
+		s,
+		-s,
+		-s,
+		-s,
+		-s,
+		-s,
+		-s,
+		s,
+		-s,
+		s,
+		s,
+		-s,
+		-s,
+		s,
+		s,
+		s,
+		s,
+		s,
+		s,
+		s,
+		-s,
+		-s,
+		s,
+		-s,
+		-s,
+		-s,
+		-s,
+		s,
+		-s,
+		-s,
+		s,
+		-s,
+		s,
+		-s,
+		-s,
+		s,
+		s,
+		-s,
+		s,
+		s,
+		-s,
+		-s,
+		s,
+		s,
+		-s,
+		s,
+		s,
+		s,
+		-s,
+		-s,
+		-s,
+		-s,
+		-s,
+		s,
+		-s,
+		s,
+		s,
+		-s,
+		s,
+		-s
+	]);
+	const indices = new Uint16Array([
+		0,
+		1,
+		2,
+		0,
+		2,
+		3,
+		4,
+		5,
+		6,
+		4,
+		6,
+		7,
+		8,
+		9,
+		10,
+		8,
+		10,
+		11,
+		12,
+		13,
+		14,
+		12,
+		14,
+		15,
+		16,
+		17,
+		18,
+		16,
+		18,
+		19,
+		20,
+		21,
+		22,
+		20,
+		22,
+		23
+	]);
+	return {
+		vertices,
+		indices,
+		indexCount: indices.length
+	};
+}
+
+//#endregion
+export { createSkyboxGeometry };
+//# sourceMappingURL=SkyboxGeometry.mjs.map

package/dist/plugins/panorama/SkyboxGeometry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SkyboxGeometry.mjs","names":[],"sources":["../../../src/plugins/panorama/SkyboxGeometry.ts"],"sourcesContent":["/**\n * Skybox Geometry\n *\n * Creates a cube with faces pointing inward for panorama rendering.\n */\n\n/** Skybox geometry data */\nexport interface SkyboxGeometry {\n  /** Vertex positions (vec3 per vertex) */\n  vertices: Float32Array;\n  /** Triangle indices */\n  indices: Uint16Array;\n  /** Number of indices */\n  indexCount: number;\n}\n\n/**\n * Create a skybox cube geometry.\n * The cube is centered at origin with size 2 (from -1 to 1 on each axis).\n * Faces are wound to point inward (for rendering from inside the cube).\n *\n * @param size - Size of the cube (default 2.0)\n */\nexport function createSkyboxGeometry(size = 2.0): SkyboxGeometry {\n  const s = size / 2;\n\n  // 8 corners of the cube\n  // prettier-ignore\n  const vertices = new Float32Array([\n    // Front face (z = +s)\n    -s, -s,  s,   //  0: bottom-left\n     s, -s,  s,   //  1: bottom-right\n     s,  s,  s,   //  2: top-right\n    -s,  s,  s,   //  3: top-left\n\n    // Back face (z = -s)\n     s, -s, -s,   //  4: bottom-left (viewed from inside)\n    -s, -s, -s,   //  5: bottom-right\n    -s,  s, -s,   //  6: top-right\n     s,  s, -s,   //  7: top-left\n\n    // Top face (y = +s)\n    -s,  s,  s,   //  8: front-left\n     s,  s,  s,   //  9: front-right\n     s,  s, -s,   // 10: back-right\n    -s,  s, -s,   // 11: back-left\n\n    // Bottom face (y = -s)\n    -s, -s, -s,   // 12: back-left\n     s, -s, -s,   // 13: back-right\n     s, -s,  s,   // 14: front-right\n    -s, -s,  s,   // 15: front-left\n\n    // Right face (x = +s)\n     s, -s,  s,   // 16: front-bottom\n     s, -s, -s,   // 17: back-bottom\n     s,  s, -s,   // 18: back-top\n     s,  s,  s,   // 19: front-top\n\n    // Left face (x = -s)\n    -s, -s, -s,   // 20: back-bottom\n    -s, -s,  s,   // 21: front-bottom\n    -s,  s,  s,   // 22: front-top\n    -s,  s, -s,   // 23: back-top\n  ]);\n\n  // Indices for triangles (wound for inward-facing normals)\n  // Each face: 2 triangles, 6 indices\n  // prettier-ignore\n  const indices = new Uint16Array([\n    // Front face\n     0,  1,  2,   0,  2,  3,\n    // Back face\n     4,  5,  6,   4,  6,  7,\n    // Top face\n     8,  9, 10,   8, 10, 11,\n    // Bottom face\n    12, 13, 14,  12, 14, 15,\n    // Right face\n    16, 17, 18,  16, 18, 19,\n    // Left face\n    20, 21, 22,  20, 22, 23,\n  ]);\n\n  return {\n    vertices,\n    indices,\n    indexCount: indices.length,\n  };\n}\n"],"mappings":";;;;;;;;AAuBA,SAAgB,qBAAqB,OAAO,GAAqB;CAC/D,MAAM,IAAI,OAAO;CAIjB,MAAM,WAAW,IAAI,aAAa;EAEhC,CAAC;EAAG,CAAC;EAAI;EACR;EAAG,CAAC;EAAI;EACR;EAAI;EAAI;EACT,CAAC;EAAI;EAAI;EAGR;EAAG,CAAC;EAAG,CAAC;EACT,CAAC;EAAG,CAAC;EAAG,CAAC;EACT,CAAC;EAAI;EAAG,CAAC;EACR;EAAI;EAAG,CAAC;EAGT,CAAC;EAAI;EAAI;EACR;EAAI;EAAI;EACR;EAAI;EAAG,CAAC;EACT,CAAC;EAAI;EAAG,CAAC;EAGT,CAAC;EAAG,CAAC;EAAG,CAAC;EACR;EAAG,CAAC;EAAG,CAAC;EACR;EAAG,CAAC;EAAI;EACT,CAAC;EAAG,CAAC;EAAI;EAGR;EAAG,CAAC;EAAI;EACR;EAAG,CAAC;EAAG,CAAC;EACR;EAAI;EAAG,CAAC;EACR;EAAI;EAAI;EAGT,CAAC;EAAG,CAAC;EAAG,CAAC;EACT,CAAC;EAAG,CAAC;EAAI;EACT,CAAC;EAAI;EAAI;EACT,CAAC;EAAI;EAAG,CAAC;EACV,CAAC;CAKF,MAAM,UAAU,IAAI,YAAY;EAE7B;EAAI;EAAI;EAAK;EAAI;EAAI;EAErB;EAAI;EAAI;EAAK;EAAI;EAAI;EAErB;EAAI;EAAG;EAAM;EAAG;EAAI;EAErB;EAAI;EAAI;EAAK;EAAI;EAAI;EAErB;EAAI;EAAI;EAAK;EAAI;EAAI;EAErB;EAAI;EAAI;EAAK;EAAI;EAAI;EACtB,CAAC;AAEF,QAAO;EACL;EACA;EACA,YAAY,QAAQ;EACrB"}

package/dist/plugins/panorama/plugin.d.mts

@@ -0,0 +1,8 @@
+import { BackgroundPlugin } from "../../core/plugins/types.mjs";
+
+//#region src/plugins/panorama/plugin.d.ts
+/** Panorama plugin instance */
+declare const PanoramaPlugin: BackgroundPlugin;
+//#endregion
+export { PanoramaPlugin };
+//# sourceMappingURL=plugin.d.mts.map

package/dist/plugins/panorama/plugin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.mts","names":[],"sources":["../../../src/plugins/panorama/plugin.ts"],"mappings":";;;;cAwBa,cAAA,EAAgB,gBAAA"}

package/dist/plugins/panorama/plugin.mjs

@@ -0,0 +1,13 @@
+import { createPanoramaRenderer } from "./PanoramaRenderer.mjs";
+
+//#region src/plugins/panorama/plugin.ts
+/** Panorama plugin instance */
+const PanoramaPlugin = {
+	type: "background",
+	name: "panorama",
+	createRenderer: createPanoramaRenderer
+};
+
+//#endregion
+export { PanoramaPlugin };
+//# sourceMappingURL=plugin.mjs.map

package/dist/plugins/panorama/plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.mjs","names":[],"sources":["../../../src/plugins/panorama/plugin.ts"],"sourcesContent":["/**\n * Panorama Plugin\n *\n * Adds equirectangular panorama background support to the skin viewer.\n *\n * @example\n * ```ts\n * import { use } from 'minecraft-skin-renderer'\n * import { PanoramaPlugin } from 'minecraft-skin-renderer/panorama'\n *\n * use(PanoramaPlugin)\n *\n * const viewer = await createSkinViewer({\n *   canvas,\n *   skin: '...',\n *   panorama: 'https://example.com/panorama.jpg',\n * })\n * ```\n */\n\nimport type { BackgroundPlugin } from \"../../core/plugins/types\";\nimport { createPanoramaRenderer } from \"./PanoramaRenderer\";\n\n/** Panorama plugin instance */\nexport const PanoramaPlugin: BackgroundPlugin = {\n  type: \"background\",\n  name: \"panorama\",\n\n  createRenderer: createPanoramaRenderer,\n};\n"],"mappings":";;;;AAwBA,MAAa,iBAAmC;CAC9C,MAAM;CACN,MAAM;CAEN,gBAAgB;CACjB"}

package/dist/plugins/panorama/shaders/webgl.mjs

@@ -0,0 +1,59 @@
+//#region src/plugins/panorama/shaders/webgl.ts
+/**
+* WebGL panorama shaders
+*
+* Renders an equirectangular panorama texture on a skybox.
+*/
+const PANORAMA_VERTEX_SHADER = `#version 300 es
+
+precision highp float;
+
+layout(location = 0) in vec3 a_position;
+
+uniform mat4 u_viewMatrix;
+uniform mat4 u_projectionMatrix;
+
+out vec3 v_direction;
+
+void main() {
+    v_direction = a_position;
+
+    // Remove translation from view matrix (only rotation)
+    mat4 viewRotation = u_viewMatrix;
+    viewRotation[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+    vec4 pos = u_projectionMatrix * viewRotation * vec4(a_position, 1.0);
+
+    // Set z = w so depth is always at far plane
+    gl_Position = pos.xyww;
+}
+`;
+const PANORAMA_FRAGMENT_SHADER = `#version 300 es
+
+precision highp float;
+
+in vec3 v_direction;
+
+uniform sampler2D u_panorama;
+
+out vec4 fragColor;
+
+const float PI = 3.14159265359;
+
+void main() {
+    vec3 dir = normalize(v_direction);
+
+    // Convert direction to equirectangular UV coordinates
+    // atan(z, x) gives horizontal angle (-PI to PI)
+    // asin(y) gives vertical angle (-PI/2 to PI/2)
+    float u = atan(dir.z, dir.x) / (2.0 * PI) + 0.5;
+    float v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;
+
+    // Flip V to match standard equirectangular orientation
+    fragColor = texture(u_panorama, vec2(u, 1.0 - v));
+}
+`;
+
+//#endregion
+export { PANORAMA_FRAGMENT_SHADER, PANORAMA_VERTEX_SHADER };
+//# sourceMappingURL=webgl.mjs.map

package/dist/plugins/panorama/shaders/webgl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl.mjs","names":[],"sources":["../../../../src/plugins/panorama/shaders/webgl.ts"],"sourcesContent":["/**\n * WebGL panorama shaders\n *\n * Renders an equirectangular panorama texture on a skybox.\n */\n\nexport const PANORAMA_VERTEX_SHADER = `#version 300 es\n\nprecision highp float;\n\nlayout(location = 0) in vec3 a_position;\n\nuniform mat4 u_viewMatrix;\nuniform mat4 u_projectionMatrix;\n\nout vec3 v_direction;\n\nvoid main() {\n    v_direction = a_position;\n\n    // Remove translation from view matrix (only rotation)\n    mat4 viewRotation = u_viewMatrix;\n    viewRotation[3] = vec4(0.0, 0.0, 0.0, 1.0);\n\n    vec4 pos = u_projectionMatrix * viewRotation * vec4(a_position, 1.0);\n\n    // Set z = w so depth is always at far plane\n    gl_Position = pos.xyww;\n}\n`;\n\nexport const PANORAMA_FRAGMENT_SHADER = `#version 300 es\n\nprecision highp float;\n\nin vec3 v_direction;\n\nuniform sampler2D u_panorama;\n\nout vec4 fragColor;\n\nconst float PI = 3.14159265359;\n\nvoid main() {\n    vec3 dir = normalize(v_direction);\n\n    // Convert direction to equirectangular UV coordinates\n    // atan(z, x) gives horizontal angle (-PI to PI)\n    // asin(y) gives vertical angle (-PI/2 to PI/2)\n    float u = atan(dir.z, dir.x) / (2.0 * PI) + 0.5;\n    float v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;\n\n    // Flip V to match standard equirectangular orientation\n    fragColor = texture(u_panorama, vec2(u, 1.0 - v));\n}\n`;\n"],"mappings":";;;;;;AAMA,MAAa,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;AAyBtC,MAAa,2BAA2B"}

package/dist/plugins/panorama/shaders/webgpu.mjs

@@ -0,0 +1,70 @@
+//#region src/plugins/panorama/shaders/webgpu.ts
+/**
+* WebGPU panorama shaders
+*
+* Renders an equirectangular panorama texture on a skybox.
+* Uses the same bind group layout as the skin shader for compatibility.
+*/
+const PANORAMA_WGSL_SHADER = `
+// Uniform buffer matching the WebGPU renderer's layout
+// We only use viewMatrix and projectionMatrix
+struct Uniforms {
+    modelMatrix: mat4x4<f32>,       // offset 0
+    viewMatrix: mat4x4<f32>,        // offset 64
+    projectionMatrix: mat4x4<f32>,  // offset 128
+    boneMatrices: array<mat4x4<f32>, 24>, // offset 192
+    alphaTest: f32,                 // offset 1728
+}
+
+// Group 0: Uniforms (matches WebGPU renderer)
+@group(0) @binding(0) var<uniform> uniforms: Uniforms;
+
+// Group 1: Textures (matches WebGPU renderer)
+@group(1) @binding(0) var panoramaSampler: sampler;
+@group(1) @binding(1) var panoramaTexture: texture_2d<f32>;
+
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) direction: vec3<f32>,
+}
+
+const PI: f32 = 3.14159265359;
+
+@vertex
+fn vs_main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+
+    output.direction = input.position;
+
+    // Remove translation from view matrix (only rotation)
+    var viewRotation = uniforms.viewMatrix;
+    viewRotation[3] = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+
+    let pos = uniforms.projectionMatrix * viewRotation * vec4<f32>(input.position, 1.0);
+
+    // Set z = w so depth is always at far plane
+    output.position = vec4<f32>(pos.xy, pos.w, pos.w);
+
+    return output;
+}
+
+@fragment
+fn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let dir = normalize(input.direction);
+
+    // Convert direction to equirectangular UV coordinates
+    let u = atan2(dir.z, dir.x) / (2.0 * PI) + 0.5;
+    let v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;
+
+    // Flip V to match standard equirectangular orientation
+    return textureSample(panoramaTexture, panoramaSampler, vec2<f32>(u, 1.0 - v));
+}
+`;
+
+//#endregion
+export { PANORAMA_WGSL_SHADER };
+//# sourceMappingURL=webgpu.mjs.map

package/dist/plugins/panorama/shaders/webgpu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu.mjs","names":[],"sources":["../../../../src/plugins/panorama/shaders/webgpu.ts"],"sourcesContent":["/**\n * WebGPU panorama shaders\n *\n * Renders an equirectangular panorama texture on a skybox.\n * Uses the same bind group layout as the skin shader for compatibility.\n */\n\nexport const PANORAMA_WGSL_SHADER = `\n// Uniform buffer matching the WebGPU renderer's layout\n// We only use viewMatrix and projectionMatrix\nstruct Uniforms {\n    modelMatrix: mat4x4<f32>,       // offset 0\n    viewMatrix: mat4x4<f32>,        // offset 64\n    projectionMatrix: mat4x4<f32>,  // offset 128\n    boneMatrices: array<mat4x4<f32>, 24>, // offset 192\n    alphaTest: f32,                 // offset 1728\n}\n\n// Group 0: Uniforms (matches WebGPU renderer)\n@group(0) @binding(0) var<uniform> uniforms: Uniforms;\n\n// Group 1: Textures (matches WebGPU renderer)\n@group(1) @binding(0) var panoramaSampler: sampler;\n@group(1) @binding(1) var panoramaTexture: texture_2d<f32>;\n\nstruct VertexInput {\n    @location(0) position: vec3<f32>,\n}\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) direction: vec3<f32>,\n}\n\nconst PI: f32 = 3.14159265359;\n\n@vertex\nfn vs_main(input: VertexInput) -> VertexOutput {\n    var output: VertexOutput;\n\n    output.direction = input.position;\n\n    // Remove translation from view matrix (only rotation)\n    var viewRotation = uniforms.viewMatrix;\n    viewRotation[3] = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n\n    let pos = uniforms.projectionMatrix * viewRotation * vec4<f32>(input.position, 1.0);\n\n    // Set z = w so depth is always at far plane\n    output.position = vec4<f32>(pos.xy, pos.w, pos.w);\n\n    return output;\n}\n\n@fragment\nfn fs_main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let dir = normalize(input.direction);\n\n    // Convert direction to equirectangular UV coordinates\n    let u = atan2(dir.z, dir.x) / (2.0 * PI) + 0.5;\n    let v = asin(clamp(dir.y, -1.0, 1.0)) / PI + 0.5;\n\n    // Flip V to match standard equirectangular orientation\n    return textureSample(panoramaTexture, panoramaSampler, vec2<f32>(u, 1.0 - v));\n}\n`;\n"],"mappings":";;;;;;;AAOA,MAAa,uBAAuB"}

package/dist/texture/TextureLoader.d.mts

@@ -0,0 +1,22 @@
+//#region src/texture/TextureLoader.d.ts
+/**
+ * Texture loading utilities
+ */
+/** Texture source types */
+type TextureSource = string | Blob | HTMLImageElement | ImageBitmap;
+/**
+ * Load and process a skin texture
+ * Handles old 64x32 format conversion
+ */
+declare function loadSkinTexture(source: TextureSource): Promise<ImageBitmap>;
+/**
+ * Load a cape texture
+ */
+declare function loadCapeTexture(source: TextureSource): Promise<ImageBitmap>;
+/**
+ * Load an elytra texture (uses cape texture format)
+ */
+declare function loadElytraTexture(source: TextureSource): Promise<ImageBitmap>;
+//#endregion
+export { TextureSource, loadCapeTexture, loadElytraTexture, loadSkinTexture };
+//# sourceMappingURL=TextureLoader.d.mts.map

package/dist/texture/TextureLoader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureLoader.d.mts","names":[],"sources":["../../src/texture/TextureLoader.ts"],"mappings":";;AAOA;;;KAAY,aAAA,YAAyB,IAAA,GAAO,gBAAA,GAAmB,WAAA;;;;;iBAiGzC,eAAA,CAAgB,MAAA,EAAQ,aAAA,GAAgB,OAAA,CAAQ,WAAA;;;AA0BtE;iBAAsB,eAAA,CAAgB,MAAA,EAAQ,aAAA,GAAgB,OAAA,CAAQ,WAAA;;;;iBAOhD,iBAAA,CAAkB,MAAA,EAAQ,aAAA,GAAgB,OAAA,CAAQ,WAAA"}

package/dist/texture/TextureLoader.mjs

@@ -0,0 +1,114 @@
+import { convertOldSkinFormat, isOldSkinFormat } from "../model/uv/SkinUV.mjs";
+
+//#region src/texture/TextureLoader.ts
+/**
+* Texture loading utilities
+*/
+/**
+* Load an image from various sources
+*/
+async function loadImage(source) {
+	if (source instanceof HTMLImageElement) {
+		if (source.complete) return source;
+		return new Promise((resolve, reject) => {
+			source.addEventListener("load", () => resolve(source));
+			source.addEventListener("error", reject);
+		});
+	}
+	if (source instanceof ImageBitmap) {
+		const canvas = document.createElement("canvas");
+		canvas.width = source.width;
+		canvas.height = source.height;
+		canvas.getContext("2d").drawImage(source, 0, 0);
+		return loadImage(canvas.toDataURL());
+	}
+	const url = source instanceof Blob ? URL.createObjectURL(source) : source;
+	const image = new Image();
+	if (typeof source === "string" && !source.startsWith("data:")) image.crossOrigin = "anonymous";
+	return new Promise((resolve, reject) => {
+		image.addEventListener("load", () => {
+			if (source instanceof Blob) URL.revokeObjectURL(url);
+			resolve(image);
+		});
+		image.addEventListener("error", (e) => {
+			if (source instanceof Blob) URL.revokeObjectURL(url);
+			reject(/* @__PURE__ */ new Error(`Failed to load image: ${e.type}`));
+		});
+		image.src = url;
+	});
+}
+/**
+* Load an image and return as ImageBitmap
+*/
+async function loadImageBitmap(source) {
+	if (source instanceof ImageBitmap) return source;
+	if (source instanceof Blob) return createImageBitmap(source);
+	const image = await loadImage(source);
+	return createImageBitmap(image);
+}
+/**
+* Generic texture loader (alias for loadImageBitmap)
+*/
+const loadTexture = loadImageBitmap;
+/**
+* Get image data from an image source
+*/
+function getImageData(source) {
+	const canvas = document.createElement("canvas");
+	const width = source instanceof HTMLCanvasElement ? source.width : source.width;
+	const height = source instanceof HTMLCanvasElement ? source.height : source.height;
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(source, 0, 0);
+	return ctx.getImageData(0, 0, width, height);
+}
+/**
+* Load and process a skin texture
+* Handles old 64x32 format conversion
+*/
+async function loadSkinTexture(source) {
+	const image = await loadImage(source);
+	const width = image.width;
+	const height = image.height;
+	if (isOldSkinFormat(width, height)) {
+		const convertedData = convertOldSkinFormat(getImageData(image));
+		const canvas = document.createElement("canvas");
+		canvas.width = 64;
+		canvas.height = 64;
+		canvas.getContext("2d").putImageData(convertedData, 0, 0);
+		return createImageBitmap(canvas);
+	}
+	return createImageBitmap(image);
+}
+/**
+* Load a cape texture
+*/
+async function loadCapeTexture(source) {
+	return loadImageBitmap(source);
+}
+/**
+* Load an elytra texture (uses cape texture format)
+*/
+async function loadElytraTexture(source) {
+	return loadImageBitmap(source);
+}
+/**
+* Create a placeholder texture (magenta/black checkerboard)
+*/
+async function createPlaceholderTexture(width = 64, height = 64) {
+	const canvas = document.createElement("canvas");
+	canvas.width = width;
+	canvas.height = height;
+	const ctx = canvas.getContext("2d");
+	const size = 8;
+	for (let y = 0; y < height; y += size) for (let x = 0; x < width; x += size) {
+		ctx.fillStyle = (x / size + y / size) % 2 === 0 ? "#ff00ff" : "#000000";
+		ctx.fillRect(x, y, size, size);
+	}
+	return createImageBitmap(canvas);
+}
+
+//#endregion
+export { createPlaceholderTexture, loadCapeTexture, loadElytraTexture, loadSkinTexture, loadTexture };
+//# sourceMappingURL=TextureLoader.mjs.map

package/dist/texture/TextureLoader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextureLoader.mjs","names":[],"sources":["../../src/texture/TextureLoader.ts"],"sourcesContent":["/**\n * Texture loading utilities\n */\n\nimport { isOldSkinFormat, convertOldSkinFormat } from \"../model/uv/SkinUV\";\n\n/** Texture source types */\nexport type TextureSource = string | Blob | HTMLImageElement | ImageBitmap;\n\n/**\n * Load an image from various sources\n */\nexport async function loadImage(source: TextureSource): Promise<HTMLImageElement> {\n  if (source instanceof HTMLImageElement) {\n    if (source.complete) {\n      return source;\n    }\n    return new Promise((resolve, reject) => {\n      source.addEventListener(\"load\", () => resolve(source));\n      source.addEventListener(\"error\", reject);\n    });\n  }\n\n  if (source instanceof ImageBitmap) {\n    // Convert ImageBitmap to HTMLImageElement via canvas\n    const canvas = document.createElement(\"canvas\");\n    canvas.width = source.width;\n    canvas.height = source.height;\n    const ctx = canvas.getContext(\"2d\")!;\n    ctx.drawImage(source, 0, 0);\n    const dataUrl = canvas.toDataURL();\n    return loadImage(dataUrl);\n  }\n\n  const url = source instanceof Blob ? URL.createObjectURL(source) : source;\n  const image = new Image();\n\n  // Handle CORS for external URLs\n  if (typeof source === \"string\" && !source.startsWith(\"data:\")) {\n    image.crossOrigin = \"anonymous\";\n  }\n\n  return new Promise((resolve, reject) => {\n    image.addEventListener(\"load\", () => {\n      // Revoke blob URL after loading\n      if (source instanceof Blob) {\n        URL.revokeObjectURL(url);\n      }\n      resolve(image);\n    });\n    image.addEventListener(\"error\", (e) => {\n      if (source instanceof Blob) {\n        URL.revokeObjectURL(url);\n      }\n      reject(new Error(`Failed to load image: ${e.type}`));\n    });\n    image.src = url;\n  });\n}\n\n/**\n * Load an image and return as ImageBitmap\n */\nexport async function loadImageBitmap(source: TextureSource): Promise<ImageBitmap> {\n  if (source instanceof ImageBitmap) {\n    return source;\n  }\n\n  if (source instanceof Blob) {\n    return createImageBitmap(source);\n  }\n\n  const image = await loadImage(source);\n  return createImageBitmap(image);\n}\n\n/**\n * Generic texture loader (alias for loadImageBitmap)\n */\nexport const loadTexture = loadImageBitmap;\n\n/**\n * Get image data from an image source\n */\nexport function getImageData(\n  source: HTMLImageElement | ImageBitmap | HTMLCanvasElement,\n): ImageData {\n  const canvas = document.createElement(\"canvas\");\n  const width = source instanceof HTMLCanvasElement ? source.width : source.width;\n  const height = source instanceof HTMLCanvasElement ? source.height : source.height;\n\n  canvas.width = width;\n  canvas.height = height;\n\n  const ctx = canvas.getContext(\"2d\")!;\n  ctx.drawImage(source, 0, 0);\n\n  return ctx.getImageData(0, 0, width, height);\n}\n\n/**\n * Load and process a skin texture\n * Handles old 64x32 format conversion\n */\nexport async function loadSkinTexture(source: TextureSource): Promise<ImageBitmap> {\n  const image = await loadImage(source);\n  const width = image.width;\n  const height = image.height;\n\n  // Check if it's old format and needs conversion\n  if (isOldSkinFormat(width, height)) {\n    const imageData = getImageData(image);\n    const convertedData = convertOldSkinFormat(imageData);\n\n    // Create canvas with converted data\n    const canvas = document.createElement(\"canvas\");\n    canvas.width = 64;\n    canvas.height = 64;\n    const ctx = canvas.getContext(\"2d\")!;\n    ctx.putImageData(convertedData, 0, 0);\n\n    return createImageBitmap(canvas);\n  }\n\n  return createImageBitmap(image);\n}\n\n/**\n * Load a cape texture\n */\nexport async function loadCapeTexture(source: TextureSource): Promise<ImageBitmap> {\n  return loadImageBitmap(source);\n}\n\n/**\n * Load an elytra texture (uses cape texture format)\n */\nexport async function loadElytraTexture(source: TextureSource): Promise<ImageBitmap> {\n  return loadImageBitmap(source);\n}\n\n/**\n * Detect if a skin uses slim (3-pixel) arms\n * This checks if the specific pixel areas for slim arms are transparent\n */\nexport function detectSlimModel(imageData: ImageData): boolean {\n  // Check the rightmost column of the right arm area\n  // If it's fully transparent, it's likely a slim skin\n  const data = imageData.data;\n\n  // Check pixels at x=46, y=52 (right arm overlay area)\n  // In classic skins, this would have content; in slim, it's transparent\n  for (let y = 52; y < 64; y++) {\n    const idx = (y * 64 + 46) * 4;\n    if (data[idx + 3] > 0) {\n      return false; // Has content, likely classic\n    }\n  }\n\n  return true; // Transparent, likely slim\n}\n\n/**\n * Create a placeholder texture (magenta/black checkerboard)\n */\nexport async function createPlaceholderTexture(width = 64, height = 64): Promise<ImageBitmap> {\n  const canvas = document.createElement(\"canvas\");\n  canvas.width = width;\n  canvas.height = height;\n\n  const ctx = canvas.getContext(\"2d\")!;\n  const size = 8;\n\n  for (let y = 0; y < height; y += size) {\n    for (let x = 0; x < width; x += size) {\n      const isEven = (x / size + y / size) % 2 === 0;\n      ctx.fillStyle = isEven ? \"#ff00ff\" : \"#000000\";\n      ctx.fillRect(x, y, size, size);\n    }\n  }\n\n  return createImageBitmap(canvas);\n}\n\n/**\n * Create a solid color texture\n */\nexport async function createSolidTexture(\n  color: string,\n  width = 64,\n  height = 64,\n): Promise<ImageBitmap> {\n  const canvas = document.createElement(\"canvas\");\n  canvas.width = width;\n  canvas.height = height;\n\n  const ctx = canvas.getContext(\"2d\")!;\n  ctx.fillStyle = color;\n  ctx.fillRect(0, 0, width, height);\n\n  return createImageBitmap(canvas);\n}\n"],"mappings":";;;;;;;;;AAYA,eAAsB,UAAU,QAAkD;AAChF,KAAI,kBAAkB,kBAAkB;AACtC,MAAI,OAAO,SACT,QAAO;AAET,SAAO,IAAI,SAAS,SAAS,WAAW;AACtC,UAAO,iBAAiB,cAAc,QAAQ,OAAO,CAAC;AACtD,UAAO,iBAAiB,SAAS,OAAO;IACxC;;AAGJ,KAAI,kBAAkB,aAAa;EAEjC,MAAM,SAAS,SAAS,cAAc,SAAS;AAC/C,SAAO,QAAQ,OAAO;AACtB,SAAO,SAAS,OAAO;AAEvB,EADY,OAAO,WAAW,KAAK,CAC/B,UAAU,QAAQ,GAAG,EAAE;AAE3B,SAAO,UADS,OAAO,WAAW,CACT;;CAG3B,MAAM,MAAM,kBAAkB,OAAO,IAAI,gBAAgB,OAAO,GAAG;CACnE,MAAM,QAAQ,IAAI,OAAO;AAGzB,KAAI,OAAO,WAAW,YAAY,CAAC,OAAO,WAAW,QAAQ,CAC3D,OAAM,cAAc;AAGtB,QAAO,IAAI,SAAS,SAAS,WAAW;AACtC,QAAM,iBAAiB,cAAc;AAEnC,OAAI,kBAAkB,KACpB,KAAI,gBAAgB,IAAI;AAE1B,WAAQ,MAAM;IACd;AACF,QAAM,iBAAiB,UAAU,MAAM;AACrC,OAAI,kBAAkB,KACpB,KAAI,gBAAgB,IAAI;AAE1B,0BAAO,IAAI,MAAM,yBAAyB,EAAE,OAAO,CAAC;IACpD;AACF,QAAM,MAAM;GACZ;;;;;AAMJ,eAAsB,gBAAgB,QAA6C;AACjF,KAAI,kBAAkB,YACpB,QAAO;AAGT,KAAI,kBAAkB,KACpB,QAAO,kBAAkB,OAAO;CAGlC,MAAM,QAAQ,MAAM,UAAU,OAAO;AACrC,QAAO,kBAAkB,MAAM;;;;;AAMjC,MAAa,cAAc;;;;AAK3B,SAAgB,aACd,QACW;CACX,MAAM,SAAS,SAAS,cAAc,SAAS;CAC/C,MAAM,QAAQ,kBAAkB,oBAAoB,OAAO,QAAQ,OAAO;CAC1E,MAAM,SAAS,kBAAkB,oBAAoB,OAAO,SAAS,OAAO;AAE5E,QAAO,QAAQ;AACf,QAAO,SAAS;CAEhB,MAAM,MAAM,OAAO,WAAW,KAAK;AACnC,KAAI,UAAU,QAAQ,GAAG,EAAE;AAE3B,QAAO,IAAI,aAAa,GAAG,GAAG,OAAO,OAAO;;;;;;AAO9C,eAAsB,gBAAgB,QAA6C;CACjF,MAAM,QAAQ,MAAM,UAAU,OAAO;CACrC,MAAM,QAAQ,MAAM;CACpB,MAAM,SAAS,MAAM;AAGrB,KAAI,gBAAgB,OAAO,OAAO,EAAE;EAElC,MAAM,gBAAgB,qBADJ,aAAa,MAAM,CACgB;EAGrD,MAAM,SAAS,SAAS,cAAc,SAAS;AAC/C,SAAO,QAAQ;AACf,SAAO,SAAS;AAEhB,EADY,OAAO,WAAW,KAAK,CAC/B,aAAa,eAAe,GAAG,EAAE;AAErC,SAAO,kBAAkB,OAAO;;AAGlC,QAAO,kBAAkB,MAAM;;;;;AAMjC,eAAsB,gBAAgB,QAA6C;AACjF,QAAO,gBAAgB,OAAO;;;;;AAMhC,eAAsB,kBAAkB,QAA6C;AACnF,QAAO,gBAAgB,OAAO;;;;;AA2BhC,eAAsB,yBAAyB,QAAQ,IAAI,SAAS,IAA0B;CAC5F,MAAM,SAAS,SAAS,cAAc,SAAS;AAC/C,QAAO,QAAQ;AACf,QAAO,SAAS;CAEhB,MAAM,MAAM,OAAO,WAAW,KAAK;CACnC,MAAM,OAAO;AAEb,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK,KAC/B,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK,MAAM;AAEpC,MAAI,aADY,IAAI,OAAO,IAAI,QAAQ,MAAM,IACpB,YAAY;AACrC,MAAI,SAAS,GAAG,GAAG,MAAM,KAAK;;AAIlC,QAAO,kBAAkB,OAAO"}

package/dist/viewer/BoneMatrixComputer.mjs

@@ -0,0 +1,82 @@
+import { mat4Identity, mat4Multiply, mat4Translate } from "../core/math/mat4.mjs";
+import { quatToMat4 } from "../core/math/quat.mjs";
+import "../core/math/index.mjs";
+import { BoneIndex } from "../model/types.mjs";
+
+//#region src/viewer/BoneMatrixComputer.ts
+/**
+* Bone Matrix Computer
+*
+* Computes world matrices for all bones in the skeleton hierarchy.
+* Separated from SkinViewer for better modularity and testability.
+*/
+/** Bone processing order (parent-first) */
+const BONE_ORDER = [
+	BoneIndex.Root,
+	BoneIndex.Body,
+	BoneIndex.Head,
+	BoneIndex.RightArm,
+	BoneIndex.LeftArm,
+	BoneIndex.RightLeg,
+	BoneIndex.LeftLeg,
+	BoneIndex.HeadOverlay,
+	BoneIndex.BodyOverlay,
+	BoneIndex.RightArmOverlay,
+	BoneIndex.LeftArmOverlay,
+	BoneIndex.RightLegOverlay,
+	BoneIndex.LeftLegOverlay,
+	BoneIndex.Cape,
+	BoneIndex.LeftWing,
+	BoneIndex.RightWing
+];
+/** Number of bones in the skeleton */
+const BONE_COUNT = 24;
+/** Size of bone matrix data in floats */
+const BONE_MATRICES_SIZE = BONE_COUNT * 16;
+/**
+* Compute bone matrices for the skeleton.
+*
+* This computes the world-space transformation matrix for each bone,
+* taking into account the bone hierarchy (parent transforms propagate to children).
+*
+* @param skeleton - The player skeleton with bone transforms
+* @returns Float32Array containing all bone matrices (24 bones * 16 floats each)
+*/
+function computeBoneMatrices(skeleton) {
+	const matrices = new Float32Array(BONE_MATRICES_SIZE);
+	const setMatrix = (index, matrix) => {
+		matrices.set(matrix, index * 16);
+	};
+	for (let i = 0; i < BONE_COUNT; i++) setMatrix(i, mat4Identity());
+	const worldMatrices = /* @__PURE__ */ new Map();
+	for (const boneIndex of BONE_ORDER) {
+		const bone = skeleton.bones.get(boneIndex);
+		if (!bone) continue;
+		let parentMatrix = mat4Identity();
+		if (bone.parentIndex !== null) parentMatrix = worldMatrices.get(bone.parentIndex) ?? mat4Identity();
+		const pos = bone.position;
+		const offset = bone.positionOffset;
+		const pivot = bone.pivot;
+		let localMatrix = mat4Identity();
+		localMatrix = mat4Translate(localMatrix, [
+			pos[0] + offset[0],
+			pos[1] + offset[1],
+			pos[2] + offset[2]
+		]);
+		localMatrix = mat4Translate(localMatrix, pivot);
+		localMatrix = mat4Multiply(localMatrix, quatToMat4(bone.rotation));
+		localMatrix = mat4Translate(localMatrix, [
+			-pivot[0],
+			-pivot[1],
+			-pivot[2]
+		]);
+		const worldMatrix = mat4Multiply(parentMatrix, localMatrix);
+		worldMatrices.set(boneIndex, worldMatrix);
+		setMatrix(boneIndex, worldMatrix);
+	}
+	return matrices;
+}
+
+//#endregion
+export { BONE_COUNT, BONE_MATRICES_SIZE, computeBoneMatrices };
+//# sourceMappingURL=BoneMatrixComputer.mjs.map

package/dist/viewer/BoneMatrixComputer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoneMatrixComputer.mjs","names":[],"sources":["../../src/viewer/BoneMatrixComputer.ts"],"sourcesContent":["/**\n * Bone Matrix Computer\n *\n * Computes world matrices for all bones in the skeleton hierarchy.\n * Separated from SkinViewer for better modularity and testability.\n */\n\nimport { mat4Identity, mat4Multiply, mat4Translate, quatToMat4 } from \"../core/math\";\nimport type { Mat4 } from \"../core/math\";\nimport { BoneIndex } from \"../model/types\";\nimport type { PlayerSkeleton } from \"../model/types\";\n\n/** Bone processing order (parent-first) */\nconst BONE_ORDER = [\n  BoneIndex.Root,\n  BoneIndex.Body,\n  BoneIndex.Head,\n  BoneIndex.RightArm,\n  BoneIndex.LeftArm,\n  BoneIndex.RightLeg,\n  BoneIndex.LeftLeg,\n  BoneIndex.HeadOverlay,\n  BoneIndex.BodyOverlay,\n  BoneIndex.RightArmOverlay,\n  BoneIndex.LeftArmOverlay,\n  BoneIndex.RightLegOverlay,\n  BoneIndex.LeftLegOverlay,\n  BoneIndex.Cape,\n  BoneIndex.LeftWing,\n  BoneIndex.RightWing,\n];\n\n/** Number of bones in the skeleton */\nexport const BONE_COUNT = 24;\n\n/** Size of bone matrix data in floats */\nexport const BONE_MATRICES_SIZE = BONE_COUNT * 16;\n\n/**\n * Bone matrix cache for efficient updates.\n * Maintains a dirty flag to avoid unnecessary recalculations.\n */\nexport interface BoneMatrixCache {\n  /** Pre-allocated Float32Array for all bone matrices */\n  matrices: Float32Array;\n  /** Whether the matrices need to be recomputed */\n  dirty: boolean;\n}\n\n/**\n * Create a new bone matrix cache\n */\nexport function createBoneMatrixCache(): BoneMatrixCache {\n  return {\n    matrices: new Float32Array(BONE_MATRICES_SIZE),\n    dirty: true,\n  };\n}\n\n/**\n * Compute bone matrices for the skeleton.\n *\n * This computes the world-space transformation matrix for each bone,\n * taking into account the bone hierarchy (parent transforms propagate to children).\n *\n * @param skeleton - The player skeleton with bone transforms\n * @returns Float32Array containing all bone matrices (24 bones * 16 floats each)\n */\nexport function computeBoneMatrices(skeleton: PlayerSkeleton): Float32Array {\n  const matrices = new Float32Array(BONE_MATRICES_SIZE);\n\n  // Helper to set matrix for bone index\n  const setMatrix = (index: number, matrix: Mat4) => {\n    matrices.set(matrix, index * 16);\n  };\n\n  // Initialize all matrices to identity\n  for (let i = 0; i < BONE_COUNT; i++) {\n    setMatrix(i, mat4Identity());\n  }\n\n  // Compute world matrices for each bone\n  const worldMatrices = new Map<BoneIndex, Mat4>();\n\n  // Process bones in parent-first order\n  for (const boneIndex of BONE_ORDER) {\n    const bone = skeleton.bones.get(boneIndex);\n    if (!bone) continue;\n\n    // Get parent matrix\n    let parentMatrix = mat4Identity();\n    if (bone.parentIndex !== null) {\n      parentMatrix = worldMatrices.get(bone.parentIndex) ?? mat4Identity();\n    }\n\n    // Compute local matrix:\n    // 1. Translate to bone position (relative to parent) + animation offset\n    // 2. Apply rotation around pivot point\n    const pos = bone.position;\n    const offset = bone.positionOffset;\n    const pivot = bone.pivot;\n\n    // Local transform: translate to position, then rotate around pivot\n    let localMatrix = mat4Identity();\n\n    // Translate to bone position + animation offset\n    localMatrix = mat4Translate(localMatrix, [\n      pos[0] + offset[0],\n      pos[1] + offset[1],\n      pos[2] + offset[2],\n    ]);\n\n    // Translate to pivot, rotate, translate back\n    localMatrix = mat4Translate(localMatrix, pivot);\n    localMatrix = mat4Multiply(localMatrix, quatToMat4(bone.rotation));\n    localMatrix = mat4Translate(localMatrix, [-pivot[0], -pivot[1], -pivot[2]]);\n\n    // Compute world matrix\n    const worldMatrix = mat4Multiply(parentMatrix, localMatrix);\n    worldMatrices.set(boneIndex, worldMatrix);\n\n    // Store in uniform buffer\n    setMatrix(boneIndex, worldMatrix);\n  }\n\n  return matrices;\n}\n\n/**\n * Update bone matrix cache if dirty.\n *\n * @param cache - The bone matrix cache to update\n * @param skeleton - The player skeleton\n * @returns true if matrices were recomputed, false if cache was valid\n */\nexport function updateBoneMatrixCache(cache: BoneMatrixCache, skeleton: PlayerSkeleton): boolean {\n  if (!cache.dirty) {\n    return false;\n  }\n\n  const newMatrices = computeBoneMatrices(skeleton);\n  cache.matrices.set(newMatrices);\n  cache.dirty = false;\n\n  return true;\n}\n\n/**\n * Mark the bone matrix cache as dirty (needs recomputation).\n */\nexport function markBoneMatricesDirty(cache: BoneMatrixCache): void {\n  cache.dirty = true;\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAM,aAAa;CACjB,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACX;;AAGD,MAAa,aAAa;;AAG1B,MAAa,qBAAqB,aAAa;;;;;;;;;;AAgC/C,SAAgB,oBAAoB,UAAwC;CAC1E,MAAM,WAAW,IAAI,aAAa,mBAAmB;CAGrD,MAAM,aAAa,OAAe,WAAiB;AACjD,WAAS,IAAI,QAAQ,QAAQ,GAAG;;AAIlC,MAAK,IAAI,IAAI,GAAG,IAAI,YAAY,IAC9B,WAAU,GAAG,cAAc,CAAC;CAI9B,MAAM,gCAAgB,IAAI,KAAsB;AAGhD,MAAK,MAAM,aAAa,YAAY;EAClC,MAAM,OAAO,SAAS,MAAM,IAAI,UAAU;AAC1C,MAAI,CAAC,KAAM;EAGX,IAAI,eAAe,cAAc;AACjC,MAAI,KAAK,gBAAgB,KACvB,gBAAe,cAAc,IAAI,KAAK,YAAY,IAAI,cAAc;EAMtE,MAAM,MAAM,KAAK;EACjB,MAAM,SAAS,KAAK;EACpB,MAAM,QAAQ,KAAK;EAGnB,IAAI,cAAc,cAAc;AAGhC,gBAAc,cAAc,aAAa;GACvC,IAAI,KAAK,OAAO;GAChB,IAAI,KAAK,OAAO;GAChB,IAAI,KAAK,OAAO;GACjB,CAAC;AAGF,gBAAc,cAAc,aAAa,MAAM;AAC/C,gBAAc,aAAa,aAAa,WAAW,KAAK,SAAS,CAAC;AAClE,gBAAc,cAAc,aAAa;GAAC,CAAC,MAAM;GAAI,CAAC,MAAM;GAAI,CAAC,MAAM;GAAG,CAAC;EAG3E,MAAM,cAAc,aAAa,cAAc,YAAY;AAC3D,gBAAc,IAAI,WAAW,YAAY;AAGzC,YAAU,WAAW,YAAY;;AAGnC,QAAO"}

package/dist/viewer/RenderLoop.mjs

@@ -0,0 +1,45 @@
+//#region src/viewer/RenderLoop.ts
+/**
+* Create a render loop
+*/
+function createRenderLoop(onUpdate, onRender) {
+	return {
+		isRunning: false,
+		lastTime: 0,
+		frameId: null,
+		onUpdate,
+		onRender
+	};
+}
+/**
+* Start the render loop
+*/
+function startRenderLoop(loop) {
+	if (loop.isRunning) return;
+	loop.isRunning = true;
+	loop.lastTime = performance.now();
+	const tick = (currentTime) => {
+		if (!loop.isRunning) return;
+		const deltaTime = (currentTime - loop.lastTime) / 1e3;
+		loop.lastTime = currentTime;
+		const cappedDelta = Math.min(deltaTime, .1);
+		loop.onUpdate(cappedDelta);
+		loop.onRender();
+		loop.frameId = requestAnimationFrame(tick);
+	};
+	loop.frameId = requestAnimationFrame(tick);
+}
+/**
+* Stop the render loop
+*/
+function stopRenderLoop(loop) {
+	loop.isRunning = false;
+	if (loop.frameId !== null) {
+		cancelAnimationFrame(loop.frameId);
+		loop.frameId = null;
+	}
+}
+
+//#endregion
+export { createRenderLoop, startRenderLoop, stopRenderLoop };
+//# sourceMappingURL=RenderLoop.mjs.map

package/dist/viewer/RenderLoop.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderLoop.mjs","names":[],"sources":["../../src/viewer/RenderLoop.ts"],"sourcesContent":["/**\n * Render loop management\n */\n\n/** Render loop state */\nexport interface RenderLoop {\n  isRunning: boolean;\n  lastTime: number;\n  frameId: number | null;\n  onUpdate: (deltaTime: number) => void;\n  onRender: () => void;\n}\n\n/**\n * Create a render loop\n */\nexport function createRenderLoop(\n  onUpdate: (deltaTime: number) => void,\n  onRender: () => void,\n): RenderLoop {\n  return {\n    isRunning: false,\n    lastTime: 0,\n    frameId: null,\n    onUpdate,\n    onRender,\n  };\n}\n\n/**\n * Start the render loop\n */\nexport function startRenderLoop(loop: RenderLoop): void {\n  if (loop.isRunning) return;\n\n  loop.isRunning = true;\n  loop.lastTime = performance.now();\n\n  const tick = (currentTime: number) => {\n    if (!loop.isRunning) return;\n\n    const deltaTime = (currentTime - loop.lastTime) / 1000; // Convert to seconds\n    loop.lastTime = currentTime;\n\n    // Cap delta time to prevent huge jumps\n    const cappedDelta = Math.min(deltaTime, 0.1);\n\n    loop.onUpdate(cappedDelta);\n    loop.onRender();\n\n    loop.frameId = requestAnimationFrame(tick);\n  };\n\n  loop.frameId = requestAnimationFrame(tick);\n}\n\n/**\n * Stop the render loop\n */\nexport function stopRenderLoop(loop: RenderLoop): void {\n  loop.isRunning = false;\n\n  if (loop.frameId !== null) {\n    cancelAnimationFrame(loop.frameId);\n    loop.frameId = null;\n  }\n}\n\n/**\n * Check if render loop is running\n */\nexport function isRenderLoopRunning(loop: RenderLoop): boolean {\n  return loop.isRunning;\n}\n"],"mappings":";;;;AAgBA,SAAgB,iBACd,UACA,UACY;AACZ,QAAO;EACL,WAAW;EACX,UAAU;EACV,SAAS;EACT;EACA;EACD;;;;;AAMH,SAAgB,gBAAgB,MAAwB;AACtD,KAAI,KAAK,UAAW;AAEpB,MAAK,YAAY;AACjB,MAAK,WAAW,YAAY,KAAK;CAEjC,MAAM,QAAQ,gBAAwB;AACpC,MAAI,CAAC,KAAK,UAAW;EAErB,MAAM,aAAa,cAAc,KAAK,YAAY;AAClD,OAAK,WAAW;EAGhB,MAAM,cAAc,KAAK,IAAI,WAAW,GAAI;AAE5C,OAAK,SAAS,YAAY;AAC1B,OAAK,UAAU;AAEf,OAAK,UAAU,sBAAsB,KAAK;;AAG5C,MAAK,UAAU,sBAAsB,KAAK;;;;;AAM5C,SAAgB,eAAe,MAAwB;AACrD,MAAK,YAAY;AAEjB,KAAI,KAAK,YAAY,MAAM;AACzB,uBAAqB,KAAK,QAAQ;AAClC,OAAK,UAAU"}

package/dist/viewer/RenderState.mjs

@@ -0,0 +1,44 @@
+import { mat4Identity } from "../core/math/mat4.mjs";
+import "../core/math/index.mjs";
+
+//#region src/viewer/RenderState.ts
+/**
+* Render State Management
+*
+* Manages pre-allocated render objects to avoid GC pressure during rendering.
+* Also handles bind group caching for efficient draw calls.
+*/
+/**
+* Create pre-allocated render bind groups.
+* These objects are reused each frame to avoid garbage collection.
+*/
+function createRenderBindGroups() {
+	const modelMatrix = mat4Identity();
+	const uniforms = {
+		u_modelMatrix: modelMatrix,
+		u_viewMatrix: null,
+		u_projectionMatrix: null,
+		"u_boneMatrices[0]": null,
+		u_alphaTest: .01
+	};
+	const skinTextures = { u_skinTexture: null };
+	const capeTextures = { u_skinTexture: null };
+	return {
+		modelMatrix,
+		uniforms,
+		skinTextures,
+		capeTextures,
+		skinBindGroup: {
+			uniforms,
+			textures: skinTextures
+		},
+		capeBindGroup: {
+			uniforms,
+			textures: capeTextures
+		}
+	};
+}
+
+//#endregion
+export { createRenderBindGroups };
+//# sourceMappingURL=RenderState.mjs.map