@daidr/minecraft-skin-renderer 0.1.0

package/dist/index.mjs

@@ -0,0 +1,19 @@
+import { use } from "./core/renderer/registry.mjs";
+import { vec3, vec3Add, vec3AddMut, vec3Clone, vec3CopyMut, vec3Cross, vec3CrossMut, vec3Distance, vec3Dot, vec3Equals, vec3Length, vec3LengthSq, vec3Lerp, vec3LerpMut, vec3Mul, vec3Negate, vec3Normalize, vec3NormalizeMut, vec3Scale, vec3ScaleMut, vec3Sub, vec3SubMut, vec3ToFloat32Array, vec3TransformMat4, vec3Zero, vec3ZeroMut } from "./core/math/vec3.mjs";
+import { mat4Clone, mat4Copy, mat4FromRotationX, mat4FromRotationY, mat4FromRotationZ, mat4FromScaling, mat4FromTranslation, mat4FromTranslationMut, mat4GetScaling, mat4GetTranslation, mat4Identity, mat4IdentityMut, mat4Invert, mat4LookAt, mat4Multiply, mat4MultiplyMut, mat4Ortho, mat4Perspective, mat4RotateX, mat4RotateY, mat4RotateZ, mat4Scale, mat4ScaleMut, mat4Translate, mat4TranslateMut, mat4Transpose, mat4Zero } from "./core/math/mat4.mjs";
+import { quat, quatClone, quatCopyMut, quatDot, quatEquals, quatFromAxisAngle, quatFromEuler, quatGetAxisAngle, quatIdentity, quatIdentityMut, quatInvert, quatLength, quatMultiply, quatMultiplyMut, quatNormalize, quatNormalizeMut, quatRotateVec3, quatRotateX, quatRotateY, quatRotateZ, quatSlerp, quatSlerpMut, quatToFloat32Array, quatToMat4, quatToMat4Mut } from "./core/math/quat.mjs";
+import { EPSILON, HALF_PI, PI, TWO_PI, approxEquals, clamp, degToRad, fract, isPowerOfTwo, isZero, lerp, mapRange, nextPowerOfTwo, radToDeg, seededRandom, sign, smoothstep, wrap } from "./core/math/utils.mjs";
+import "./core/math/index.mjs";
+import { createCamera } from "./core/camera/Camera.mjs";
+import { createOrbitControls } from "./core/camera/OrbitControls.mjs";
+import { detectBestBackend, isWebGL2Supported, isWebGPUSupported } from "./core/renderer/types.mjs";
+import { PART_NAMES, createDefaultVisibility } from "./model/types.mjs";
+import { createPlayerSkeleton } from "./model/PlayerModel.mjs";
+import { loadCapeTexture, loadElytraTexture, loadSkinTexture } from "./texture/TextureLoader.mjs";
+import { getAnimation, registerAnimation } from "./animation/types.mjs";
+import { createAnimationController, updateAnimationController } from "./animation/AnimationController.mjs";
+import { createSkinViewer } from "./viewer/SkinViewer.mjs";
+import "./viewer/index.mjs";
+import "./model/index.mjs";
+
+export { EPSILON, HALF_PI, PART_NAMES, PI, TWO_PI, approxEquals, clamp, createAnimationController, createCamera, createDefaultVisibility, createOrbitControls, createPlayerSkeleton, createSkinViewer, degToRad, detectBestBackend, fract, getAnimation, isPowerOfTwo, isWebGL2Supported, isWebGPUSupported, isZero, lerp, loadCapeTexture, loadElytraTexture, loadSkinTexture, mapRange, mat4Clone, mat4Copy, mat4FromRotationX, mat4FromRotationY, mat4FromRotationZ, mat4FromScaling, mat4FromTranslation, mat4FromTranslationMut, mat4GetScaling, mat4GetTranslation, mat4Identity, mat4IdentityMut, mat4Invert, mat4LookAt, mat4Multiply, mat4MultiplyMut, mat4Ortho, mat4Perspective, mat4RotateX, mat4RotateY, mat4RotateZ, mat4Scale, mat4ScaleMut, mat4Translate, mat4TranslateMut, mat4Transpose, mat4Zero, nextPowerOfTwo, quat, quatClone, quatCopyMut, quatDot, quatEquals, quatFromAxisAngle, quatFromEuler, quatGetAxisAngle, quatIdentity, quatIdentityMut, quatInvert, quatLength, quatMultiply, quatMultiplyMut, quatNormalize, quatNormalizeMut, quatRotateVec3, quatRotateX, quatRotateY, quatRotateZ, quatSlerp, quatSlerpMut, quatToFloat32Array, quatToMat4, quatToMat4Mut, radToDeg, registerAnimation, seededRandom, sign, smoothstep, updateAnimationController, use, vec3, vec3Add, vec3AddMut, vec3Clone, vec3CopyMut, vec3Cross, vec3CrossMut, vec3Distance, vec3Dot, vec3Equals, vec3Length, vec3LengthSq, vec3Lerp, vec3LerpMut, vec3Mul, vec3Negate, vec3Normalize, vec3NormalizeMut, vec3Scale, vec3ScaleMut, vec3Sub, vec3SubMut, vec3ToFloat32Array, vec3TransformMat4, vec3Zero, vec3ZeroMut, wrap };

package/dist/model/PlayerModel.d.mts

@@ -0,0 +1,8 @@
+import { ModelVariant, PlayerSkeleton } from "./types.mjs";
+
+//#region src/model/PlayerModel.d.ts
+/** Create the player skeleton */
+declare function createPlayerSkeleton(variant?: ModelVariant): PlayerSkeleton;
+//#endregion
+export { createPlayerSkeleton };
+//# sourceMappingURL=PlayerModel.d.mts.map

package/dist/model/PlayerModel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayerModel.d.mts","names":[],"sources":["../../src/model/PlayerModel.ts"],"mappings":";;;;iBA2DgB,oBAAA,CAAqB,OAAA,GAAS,YAAA,GAA2B,cAAA"}

package/dist/model/PlayerModel.mjs

@@ -0,0 +1,253 @@
+import { quatFromEuler, quatIdentity } from "../core/math/quat.mjs";
+import { degToRad } from "../core/math/utils.mjs";
+import "../core/math/index.mjs";
+import { BoneIndex } from "./types.mjs";
+import { BONE_OVERLAY_SCALE } from "./constants.mjs";
+
+//#region src/model/PlayerModel.ts
+/**
+* Player model skeleton definition
+* Based on Minecraft's player model structure
+*/
+/**
+* Minecraft player dimensions (in pixels, 1 pixel = 1 unit)
+* Head: 8x8x8
+* Body: 8x12x4
+* Arms: 4x12x4 (classic) or 3x12x4 (slim)
+* Legs: 4x12x4
+*/
+/** Create a bone definition */
+function createBone(index, name, parentIndex, position, pivot, size) {
+	return {
+		index,
+		name,
+		parentIndex,
+		position,
+		pivot,
+		rotation: quatIdentity(),
+		positionOffset: [
+			0,
+			0,
+			0
+		],
+		size
+	};
+}
+/** Create an overlay bone that follows a parent bone with inflated size */
+function createOverlayBone(index, name, parentIndex, parentSize, scale = BONE_OVERLAY_SCALE) {
+	return createBone(index, name, parentIndex, [
+		0,
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		parentSize[0] + scale * 2,
+		parentSize[1] + scale * 2,
+		parentSize[2] + scale * 2
+	]);
+}
+/** Create the player skeleton */
+function createPlayerSkeleton(variant = "classic") {
+	const armWidth = variant === "slim" ? 3 : 4;
+	const bones = /* @__PURE__ */ new Map();
+	bones.set(BoneIndex.Root, createBone(BoneIndex.Root, "root", null, [
+		0,
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	]));
+	bones.set(BoneIndex.Body, createBone(BoneIndex.Body, "body", BoneIndex.Root, [
+		0,
+		24,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		8,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.Head, createBone(BoneIndex.Head, "head", BoneIndex.Body, [
+		0,
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		8,
+		8,
+		8
+	]));
+	bones.set(BoneIndex.RightArm, createBone(BoneIndex.RightArm, "rightArm", BoneIndex.Body, [
+		-(4 + armWidth / 2),
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		armWidth,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.LeftArm, createBone(BoneIndex.LeftArm, "leftArm", BoneIndex.Body, [
+		4 + armWidth / 2,
+		0,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		armWidth,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.RightLeg, createBone(BoneIndex.RightLeg, "rightLeg", BoneIndex.Body, [
+		-2,
+		-12,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		4,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.LeftLeg, createBone(BoneIndex.LeftLeg, "leftLeg", BoneIndex.Body, [
+		2,
+		-12,
+		0
+	], [
+		0,
+		0,
+		0
+	], [
+		4,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.HeadOverlay, createOverlayBone(BoneIndex.HeadOverlay, "headOverlay", BoneIndex.Head, [
+		8,
+		8,
+		8
+	]));
+	bones.set(BoneIndex.BodyOverlay, createOverlayBone(BoneIndex.BodyOverlay, "bodyOverlay", BoneIndex.Body, [
+		8,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.RightArmOverlay, createOverlayBone(BoneIndex.RightArmOverlay, "rightArmOverlay", BoneIndex.RightArm, [
+		armWidth,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.LeftArmOverlay, createOverlayBone(BoneIndex.LeftArmOverlay, "leftArmOverlay", BoneIndex.LeftArm, [
+		armWidth,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.RightLegOverlay, createOverlayBone(BoneIndex.RightLegOverlay, "rightLegOverlay", BoneIndex.RightLeg, [
+		4,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.LeftLegOverlay, createOverlayBone(BoneIndex.LeftLegOverlay, "leftLegOverlay", BoneIndex.LeftLeg, [
+		4,
+		12,
+		4
+	]));
+	bones.set(BoneIndex.Cape, createBone(BoneIndex.Cape, "cape", BoneIndex.Body, [
+		0,
+		0,
+		-2
+	], [
+		0,
+		0,
+		0
+	], [
+		10,
+		16,
+		1
+	]));
+	bones.set(BoneIndex.LeftWing, createBone(BoneIndex.LeftWing, "leftWing", BoneIndex.Body, [
+		5,
+		-1,
+		-2
+	], [
+		0,
+		0,
+		0
+	], [
+		10,
+		20,
+		2
+	]));
+	bones.set(BoneIndex.RightWing, createBone(BoneIndex.RightWing, "rightWing", BoneIndex.Body, [
+		-5,
+		-1,
+		-2
+	], [
+		0,
+		0,
+		0
+	], [
+		10,
+		20,
+		2
+	]));
+	const leftWing = bones.get(BoneIndex.LeftWing);
+	const rightWing = bones.get(BoneIndex.RightWing);
+	leftWing.rotation = quatFromEuler(degToRad(15), degToRad(.5), degToRad(15));
+	rightWing.rotation = quatFromEuler(degToRad(15), degToRad(-.5), degToRad(-15));
+	return {
+		variant,
+		bones
+	};
+}
+/** Set bone rotation */
+function setBoneRotation(skeleton, boneIndex, rotation) {
+	const bone = skeleton.bones.get(boneIndex);
+	if (bone) bone.rotation = rotation;
+}
+/** Set bone position offset (for animation) */
+function setBonePositionOffset(skeleton, boneIndex, offset) {
+	const bone = skeleton.bones.get(boneIndex);
+	if (bone) bone.positionOffset = offset;
+}
+/** Reset all bone rotations and position offsets */
+function resetSkeleton(skeleton) {
+	for (const bone of skeleton.bones.values()) {
+		bone.rotation = quatIdentity();
+		bone.positionOffset = [
+			0,
+			0,
+			0
+		];
+	}
+	const leftWing = skeleton.bones.get(BoneIndex.LeftWing);
+	const rightWing = skeleton.bones.get(BoneIndex.RightWing);
+	if (leftWing) leftWing.rotation = quatFromEuler(degToRad(15), degToRad(.5), degToRad(15));
+	if (rightWing) rightWing.rotation = quatFromEuler(degToRad(15), degToRad(-.5), degToRad(-15));
+}
+
+//#endregion
+export { createPlayerSkeleton, resetSkeleton, setBonePositionOffset, setBoneRotation };
+//# sourceMappingURL=PlayerModel.mjs.map

package/dist/model/PlayerModel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlayerModel.mjs","names":[],"sources":["../../src/model/PlayerModel.ts"],"sourcesContent":["/**\n * Player model skeleton definition\n * Based on Minecraft's player model structure\n */\n\nimport { quatIdentity, quatFromEuler, degToRad } from \"../core/math\";\nimport type { Quat, Vec3 } from \"../core/math\";\nimport { BoneIndex } from \"./types\";\nimport type { Bone, ModelVariant, PlayerSkeleton } from \"./types\";\nimport { BONE_OVERLAY_SCALE } from \"./constants\";\n\n/**\n * Minecraft player dimensions (in pixels, 1 pixel = 1 unit)\n * Head: 8x8x8\n * Body: 8x12x4\n * Arms: 4x12x4 (classic) or 3x12x4 (slim)\n * Legs: 4x12x4\n */\n\n/** Create a bone definition */\nfunction createBone(\n  index: BoneIndex,\n  name: string,\n  parentIndex: BoneIndex | null,\n  position: Vec3,\n  pivot: Vec3,\n  size: Vec3,\n): Bone {\n  return {\n    index,\n    name,\n    parentIndex,\n    position,\n    pivot,\n    rotation: quatIdentity(),\n    positionOffset: [0, 0, 0],\n    size,\n  };\n}\n\n/** Create an overlay bone that follows a parent bone with inflated size */\nfunction createOverlayBone(\n  index: BoneIndex,\n  name: string,\n  parentIndex: BoneIndex,\n  parentSize: Vec3,\n  scale = BONE_OVERLAY_SCALE,\n): Bone {\n  return createBone(\n    index,\n    name,\n    parentIndex,\n    [0, 0, 0],\n    [0, 0, 0],\n    [parentSize[0] + scale * 2, parentSize[1] + scale * 2, parentSize[2] + scale * 2],\n  );\n}\n\n/** Create the player skeleton */\nexport function createPlayerSkeleton(variant: ModelVariant = \"classic\"): PlayerSkeleton {\n  const armWidth = variant === \"slim\" ? 3 : 4;\n  const bones = new Map<BoneIndex, Bone>();\n\n  // Minecraft player model coordinates (Y up, origin at feet):\n  // - Legs: y = 0 to 12\n  // - Body: y = 12 to 24\n  // - Head: y = 24 to 32\n  // - Arms: y = 12 to 24 (attached at shoulders, y = 22)\n\n  // Root bone (at feet level, center)\n  bones.set(\n    BoneIndex.Root,\n    createBone(BoneIndex.Root, \"root\", null, [0, 0, 0], [0, 0, 0], [0, 0, 0]),\n  );\n\n  // Body (pivot at bottom of body, y=12)\n  bones.set(\n    BoneIndex.Body,\n    createBone(\n      BoneIndex.Body,\n      \"body\",\n      BoneIndex.Root,\n      [0, 24, 0], // Position body top at y=24\n      [0, 0, 0], // Pivot at body top (for head attachment)\n      [8, 12, 4], // Body size\n    ),\n  );\n\n  // Head (attached to body top, y=24)\n  bones.set(\n    BoneIndex.Head,\n    createBone(\n      BoneIndex.Head,\n      \"head\",\n      BoneIndex.Body,\n      [0, 0, 0], // At body top\n      [0, 0, 0], // Pivot at neck (head bottom)\n      [8, 8, 8], // Head size\n    ),\n  );\n\n  // Right Arm (attached at shoulder, x = -5 or -5.5 for slim)\n  bones.set(\n    BoneIndex.RightArm,\n    createBone(\n      BoneIndex.RightArm,\n      \"rightArm\",\n      BoneIndex.Body,\n      [-(4 + armWidth / 2), 0, 0], // Shoulder position (at body top)\n      [0, 0, 0], // Pivot at shoulder (arm top)\n      [armWidth, 12, 4], // Arm size\n    ),\n  );\n\n  // Left Arm (attached at shoulder)\n  bones.set(\n    BoneIndex.LeftArm,\n    createBone(\n      BoneIndex.LeftArm,\n      \"leftArm\",\n      BoneIndex.Body,\n      [4 + armWidth / 2, 0, 0], // Shoulder position (at body top)\n      [0, 0, 0], // Pivot at shoulder\n      [armWidth, 12, 4], // Arm size\n    ),\n  );\n\n  // Right Leg (attached to body at hip level)\n  bones.set(\n    BoneIndex.RightLeg,\n    createBone(\n      BoneIndex.RightLeg,\n      \"rightLeg\",\n      BoneIndex.Body,\n      [-2, -12, 0], // Hip position (relative to body top at y=24, so y=24-12=12)\n      [0, 0, 0], // Pivot at hip (leg top)\n      [4, 12, 4], // Leg size\n    ),\n  );\n\n  // Left Leg (attached to body at hip level)\n  bones.set(\n    BoneIndex.LeftLeg,\n    createBone(\n      BoneIndex.LeftLeg,\n      \"leftLeg\",\n      BoneIndex.Body,\n      [2, -12, 0], // Hip position (relative to body top)\n      [0, 0, 0], // Pivot at hip\n      [4, 12, 4], // Leg size\n    ),\n  );\n\n  // Overlay layers (slightly larger, same pivot)\n  bones.set(\n    BoneIndex.HeadOverlay,\n    createOverlayBone(BoneIndex.HeadOverlay, \"headOverlay\", BoneIndex.Head, [8, 8, 8]),\n  );\n  bones.set(\n    BoneIndex.BodyOverlay,\n    createOverlayBone(BoneIndex.BodyOverlay, \"bodyOverlay\", BoneIndex.Body, [8, 12, 4]),\n  );\n  bones.set(\n    BoneIndex.RightArmOverlay,\n    createOverlayBone(BoneIndex.RightArmOverlay, \"rightArmOverlay\", BoneIndex.RightArm, [\n      armWidth,\n      12,\n      4,\n    ]),\n  );\n  bones.set(\n    BoneIndex.LeftArmOverlay,\n    createOverlayBone(BoneIndex.LeftArmOverlay, \"leftArmOverlay\", BoneIndex.LeftArm, [\n      armWidth,\n      12,\n      4,\n    ]),\n  );\n  bones.set(\n    BoneIndex.RightLegOverlay,\n    createOverlayBone(BoneIndex.RightLegOverlay, \"rightLegOverlay\", BoneIndex.RightLeg, [4, 12, 4]),\n  );\n  bones.set(\n    BoneIndex.LeftLegOverlay,\n    createOverlayBone(BoneIndex.LeftLegOverlay, \"leftLegOverlay\", BoneIndex.LeftLeg, [4, 12, 4]),\n  );\n\n  // Cape (attached to body back)\n  // Cape hangs from the neck, pivot at the top attachment point\n  // Body back face is at z = -2 (body is 4 deep, centered at z=0)\n  // Cape should be flush against body back\n  bones.set(\n    BoneIndex.Cape,\n    createBone(\n      BoneIndex.Cape,\n      \"cape\",\n      BoneIndex.Body,\n      [0, 0, -2], // At body back surface (z = -2)\n      [0, 0, 0], // Pivot at bone origin (top of cape attachment)\n      [10, 16, 1], // Cape size: 10 wide, 16 tall, 1 deep\n    ),\n  );\n\n  // Elytra wings (attached to body back at the spine)\n  // Based on skinview3d: wings pivot from attachment point at spine\n  // Left wing pivot is 5 units to the left of center, extends outward\n  // Wing rotates around this pivot point for open/close animations\n  // Y=-2 to position wings slightly below shoulders (body top is at y=0)\n  bones.set(\n    BoneIndex.LeftWing,\n    createBone(\n      BoneIndex.LeftWing,\n      \"leftWing\",\n      BoneIndex.Body,\n      [5, -1, -2], // Pivot point: below shoulders, at body back\n      [0, 0, 0], // Pivot at bone origin\n      [10, 20, 2], // Wing size for UV mapping\n    ),\n  );\n\n  bones.set(\n    BoneIndex.RightWing,\n    createBone(\n      BoneIndex.RightWing,\n      \"rightWing\",\n      BoneIndex.Body,\n      [-5, -1, -2], // Pivot point: below shoulders, at body back (mirrored)\n      [0, 0, 0], // Pivot at bone origin (mirrored)\n      [10, 20, 2], // Wing size for UV mapping\n    ),\n  );\n\n  // Set default elytra rotation to match idle animation's closed position\n  const leftWing = bones.get(BoneIndex.LeftWing)!;\n  const rightWing = bones.get(BoneIndex.RightWing)!;\n  leftWing.rotation = quatFromEuler(degToRad(15), degToRad(0.5), degToRad(15));\n  rightWing.rotation = quatFromEuler(degToRad(15), degToRad(-0.5), degToRad(-15));\n\n  return { variant, bones };\n}\n\n/** Set bone rotation */\nexport function setBoneRotation(\n  skeleton: PlayerSkeleton,\n  boneIndex: BoneIndex,\n  rotation: Quat,\n): void {\n  const bone = skeleton.bones.get(boneIndex);\n  if (bone) {\n    bone.rotation = rotation;\n  }\n}\n\n/** Set bone position offset (for animation) */\nexport function setBonePositionOffset(\n  skeleton: PlayerSkeleton,\n  boneIndex: BoneIndex,\n  offset: Vec3,\n): void {\n  const bone = skeleton.bones.get(boneIndex);\n  if (bone) {\n    bone.positionOffset = offset;\n  }\n}\n\n/** Reset all bone rotations and position offsets */\nexport function resetSkeleton(skeleton: PlayerSkeleton): void {\n  for (const bone of skeleton.bones.values()) {\n    bone.rotation = quatIdentity();\n    bone.positionOffset = [0, 0, 0];\n  }\n\n  // Restore default elytra rotation (idle closed position)\n  const leftWing = skeleton.bones.get(BoneIndex.LeftWing);\n  const rightWing = skeleton.bones.get(BoneIndex.RightWing);\n  if (leftWing) {\n    leftWing.rotation = quatFromEuler(degToRad(15), degToRad(0.5), degToRad(15));\n  }\n  if (rightWing) {\n    rightWing.rotation = quatFromEuler(degToRad(15), degToRad(-0.5), degToRad(-15));\n  }\n}\n\n/** Clone a skeleton */\nexport function cloneSkeleton(skeleton: PlayerSkeleton): PlayerSkeleton {\n  const bones = new Map<BoneIndex, Bone>();\n  for (const [index, bone] of skeleton.bones) {\n    bones.set(index, {\n      ...bone,\n      position: [...bone.position] as Vec3,\n      pivot: [...bone.pivot] as Vec3,\n      rotation: [...bone.rotation] as Quat,\n      positionOffset: [...bone.positionOffset] as Vec3,\n      size: [...bone.size] as Vec3,\n    });\n  }\n  return { variant: skeleton.variant, bones };\n}\n"],"mappings":"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"}

package/dist/model/bone-utils.mjs

@@ -0,0 +1,3 @@
+import "../core/math/index.mjs";
+
+export {  };

package/dist/model/constants.mjs

@@ -0,0 +1,20 @@
+//#region src/model/constants.ts
+/**
+* Model constants
+*
+* Centralized constants for texture dimensions, UV processing, and geometry generation.
+*/
+/** Skin texture dimensions (64x64 format) */
+const SKIN_TEXTURE_WIDTH = 64;
+const SKIN_TEXTURE_HEIGHT = 64;
+/** Cape texture dimensions (64x32 format) */
+const CAPE_TEXTURE_WIDTH = 64;
+const CAPE_TEXTURE_HEIGHT = 32;
+/** UV inset to prevent texture edge bleeding */
+const UV_EDGE_INSET = .001;
+/** Bone overlay scale factor */
+const BONE_OVERLAY_SCALE = .5;
+
+//#endregion
+export { BONE_OVERLAY_SCALE, CAPE_TEXTURE_HEIGHT, CAPE_TEXTURE_WIDTH, SKIN_TEXTURE_HEIGHT, SKIN_TEXTURE_WIDTH, UV_EDGE_INSET };
+//# sourceMappingURL=constants.mjs.map

package/dist/model/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../src/model/constants.ts"],"sourcesContent":["/**\n * Model constants\n *\n * Centralized constants for texture dimensions, UV processing, and geometry generation.\n */\n\n/** Skin texture dimensions (64x64 format) */\nexport const SKIN_TEXTURE_WIDTH = 64;\nexport const SKIN_TEXTURE_HEIGHT = 64;\n\n/** Cape texture dimensions (64x32 format) */\nexport const CAPE_TEXTURE_WIDTH = 64;\nexport const CAPE_TEXTURE_HEIGHT = 32;\n\n/** UV inset to prevent texture edge bleeding */\nexport const UV_EDGE_INSET = 0.001;\n\n/** Bone overlay scale factor */\nexport const BONE_OVERLAY_SCALE = 0.5;\n\n/** Arm width for different model variants */\nexport const ARM_WIDTH = {\n  CLASSIC: 4,\n  SLIM: 3,\n} as const;\n"],"mappings":";;;;;;;AAOA,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;;AAGnC,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;;AAGnC,MAAa,gBAAgB;;AAG7B,MAAa,qBAAqB"}

package/dist/model/geometry/BoxGeometry.mjs

@@ -0,0 +1,316 @@
+import { VERTEX_STRIDE } from "../types.mjs";
+import { CAPE_TEXTURE_HEIGHT, CAPE_TEXTURE_WIDTH, SKIN_TEXTURE_HEIGHT, SKIN_TEXTURE_WIDTH, UV_EDGE_INSET } from "../constants.mjs";
+
+//#region src/model/geometry/BoxGeometry.ts
+/** Face indices for a cube */
+var Face = /* @__PURE__ */ function(Face) {
+	Face[Face["Front"] = 0] = "Front";
+	Face[Face["Back"] = 1] = "Back";
+	Face[Face["Left"] = 2] = "Left";
+	Face[Face["Right"] = 3] = "Right";
+	Face[Face["Top"] = 4] = "Top";
+	Face[Face["Bottom"] = 5] = "Bottom";
+	return Face;
+}(Face || {});
+/** Normal vectors for each face */
+const FACE_NORMALS = [
+	[
+		0,
+		0,
+		1
+	],
+	[
+		0,
+		0,
+		-1
+	],
+	[
+		-1,
+		0,
+		0
+	],
+	[
+		1,
+		0,
+		0
+	],
+	[
+		0,
+		1,
+		0
+	],
+	[
+		0,
+		-1,
+		0
+	]
+];
+/** UV inset constant (imported from constants) */
+const UV_INSET = UV_EDGE_INSET;
+/**
+* Core function for creating box geometry with various options
+*/
+function createBoxGeometryCore(size, uv, boneIndex, offset, options) {
+	const { inflate = 0, mirrorX = false, textureWidth = 64, textureHeight = 64, capeUVMode = false } = options;
+	const hw = size[0] / 2 + inflate;
+	const hh = size[1] / 2 + inflate;
+	const hd = size[2] / 2 + inflate;
+	const ox = offset[0];
+	const oy = offset[1];
+	const oz = offset[2];
+	const vertexCount = 24;
+	const indexCount = 36;
+	const vertices = new Float32Array(vertexCount * VERTEX_STRIDE);
+	const indices = new Uint16Array(indexCount);
+	let vertexOffset = 0;
+	let indexOffset = 0;
+	let baseVertex = 0;
+	const mx = mirrorX ? -1 : 1;
+	const addVertex = (x, y, z, u, v, nx, ny, nz) => {
+		vertices[vertexOffset++] = x * mx;
+		vertices[vertexOffset++] = y;
+		vertices[vertexOffset++] = z;
+		vertices[vertexOffset++] = u;
+		vertices[vertexOffset++] = v;
+		vertices[vertexOffset++] = nx * mx;
+		vertices[vertexOffset++] = ny;
+		vertices[vertexOffset++] = nz;
+		vertices[vertexOffset++] = boneIndex;
+		vertices[vertexOffset++] = 0;
+	};
+	const addFaceIndices = () => {
+		if (mirrorX) {
+			indices[indexOffset++] = baseVertex + 2;
+			indices[indexOffset++] = baseVertex + 1;
+			indices[indexOffset++] = baseVertex;
+			indices[indexOffset++] = baseVertex;
+			indices[indexOffset++] = baseVertex + 3;
+			indices[indexOffset++] = baseVertex + 2;
+		} else {
+			indices[indexOffset++] = baseVertex;
+			indices[indexOffset++] = baseVertex + 1;
+			indices[indexOffset++] = baseVertex + 2;
+			indices[indexOffset++] = baseVertex + 2;
+			indices[indexOffset++] = baseVertex + 3;
+			indices[indexOffset++] = baseVertex;
+		}
+		baseVertex += 4;
+	};
+	const normalizeUV = (faceUV) => {
+		let u1 = faceUV.u1 / textureWidth;
+		let u2 = faceUV.u2 / textureWidth;
+		let v1 = faceUV.v1 / textureHeight;
+		let v2 = faceUV.v2 / textureHeight;
+		if (u1 < u2) {
+			u1 += UV_INSET;
+			u2 -= UV_INSET;
+		} else {
+			u1 -= UV_INSET;
+			u2 += UV_INSET;
+		}
+		if (v1 < v2) {
+			v1 += UV_INSET;
+			v2 -= UV_INSET;
+		} else {
+			v1 -= UV_INSET;
+			v2 += UV_INSET;
+		}
+		return [
+			u1,
+			v1,
+			u2,
+			v2
+		];
+	};
+	if (capeUVMode) {
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.front);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Front];
+			addVertex(ox - hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u1, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz + hd, u2, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.back);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Back];
+			addVertex(ox + hw, oy - hh, oz - hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz - hd, u1, v2, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.left);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Left];
+			addVertex(ox - hw, oy - hh, oz - hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz + hd, u1, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.right);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Right];
+			addVertex(ox + hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz - hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u2, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.top);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Top];
+			addVertex(ox - hw, oy + hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.bottom);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Bottom];
+			addVertex(ox - hw, oy - hh, oz - hd, u1, v1, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addFaceIndices();
+		}
+	} else {
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.front);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Front];
+			addVertex(ox - hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u2, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz + hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.back);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Back];
+			addVertex(ox + hw, oy - hh, oz - hd, u1, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz - hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.right);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Left];
+			addVertex(ox - hw, oy - hh, oz - hd, u1, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz + hd, u2, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.left);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Right];
+			addVertex(ox + hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz - hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.top);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Top];
+			addVertex(ox - hw, oy + hh, oz + hd, u1, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox + hw, oy + hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox - hw, oy + hh, oz - hd, u1, v1, nx, ny, nz);
+			addFaceIndices();
+		}
+		{
+			const [u1, v1, u2, v2] = normalizeUV(uv.bottom);
+			const [nx, ny, nz] = FACE_NORMALS[Face.Bottom];
+			addVertex(ox - hw, oy - hh, oz - hd, u1, v1, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz - hd, u2, v1, nx, ny, nz);
+			addVertex(ox + hw, oy - hh, oz + hd, u2, v2, nx, ny, nz);
+			addVertex(ox - hw, oy - hh, oz + hd, u1, v2, nx, ny, nz);
+			addFaceIndices();
+		}
+	}
+	return {
+		vertices,
+		indices,
+		vertexCount,
+		indexCount
+	};
+}
+/**
+* Create box geometry with UV mapping for skin parts
+*
+* @param size - Box dimensions [width, height, depth]
+* @param uv - UV mapping for each face (in pixels, 64x64 texture)
+* @param boneIndex - Bone index for skeletal animation
+* @param offset - Position offset from bone origin
+* @param inflate - Inflation amount (for overlay layers)
+*/
+function createBoxGeometry(size, uv, boneIndex, offset = [
+	0,
+	0,
+	0
+], inflate = 0) {
+	return createBoxGeometryCore(size, uv, boneIndex, offset, {
+		inflate,
+		textureWidth: SKIN_TEXTURE_WIDTH,
+		textureHeight: SKIN_TEXTURE_HEIGHT,
+		capeUVMode: false
+	});
+}
+/**
+* Create box geometry for cape/elytra with 64x32 texture
+*
+* @param size - Box dimensions [width, height, depth]
+* @param uv - UV mapping for each face (in pixels, 64x32 texture)
+* @param boneIndex - Bone index for skeletal animation
+* @param offset - Position offset from bone origin
+* @param mirrorX - Mirror the geometry along X axis (for right elytra wing)
+*/
+function createCapeBoxGeometry(size, uv, boneIndex, offset = [
+	0,
+	0,
+	0
+], mirrorX = false) {
+	return createBoxGeometryCore(size, uv, boneIndex, offset, {
+		mirrorX,
+		textureWidth: CAPE_TEXTURE_WIDTH,
+		textureHeight: CAPE_TEXTURE_HEIGHT,
+		capeUVMode: true
+	});
+}
+/**
+* Merge multiple box geometries into one
+*/
+function mergeGeometries(geometries) {
+	let totalVertices = 0;
+	let totalIndices = 0;
+	for (const geo of geometries) {
+		totalVertices += geo.vertexCount;
+		totalIndices += geo.indexCount;
+	}
+	const vertices = new Float32Array(totalVertices * VERTEX_STRIDE);
+	const indices = new Uint16Array(totalIndices);
+	let vertexOffset = 0;
+	let indexOffset = 0;
+	let baseVertex = 0;
+	for (const geo of geometries) {
+		vertices.set(geo.vertices, vertexOffset);
+		vertexOffset += geo.vertices.length;
+		for (let i = 0; i < geo.indexCount; i++) indices[indexOffset++] = geo.indices[i] + baseVertex;
+		baseVertex += geo.vertexCount;
+	}
+	return {
+		vertices,
+		indices,
+		vertexCount: totalVertices,
+		indexCount: totalIndices
+	};
+}
+
+//#endregion
+export { createBoxGeometry, createCapeBoxGeometry, mergeGeometries };
+//# sourceMappingURL=BoxGeometry.mjs.map