minecraft-renderer 0.1.27 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/guiRenderer.ts

@@ -268,7 +268,6 @@ const generateAtlas = async (appViewer: AppViewer, images: Record<string, HTMLIm
 }
 
 export const generateGuiAtlas = async (appViewer: AppViewer) => {
-  console.trace('generateGuiAtlas')
   const { blockModelsResolved, itemsModelsResolved } = getNonFullBlocksModels(appViewer)
 
   // Generate blocks atlas

package/src/lib/moreBlockDataGenerated.json

@@ -718,5 +718,13 @@
         "barrier": true,
         "light": true,
         "moving_piston": true
+    },
+    "hasSemiTransparentTextuersRegex": {
+        "_stained_glass$": true,
+        "_stained_glass_pane$": true,
+        "^ice$": true,
+        "^tinted_glass$": true,
+        "^slime_block$": true,
+        "^honey_block$": true
     }
 }

package/src/lib/skyLight.ts

@@ -0,0 +1,125 @@
+//@ts-nocheck
+/**
+ * Calculates sky light level based on Minecraft time of day.
+ *
+ * Minecraft time reference:
+ * - 0 ticks = 6:00 AM (sunrise complete)
+ * - 6000 ticks = 12:00 PM (noon) - brightest
+ * - 12000 ticks = 6:00 PM (sunset begins)
+ * - 13000 ticks = 7:00 PM (dusk/night begins)
+ * - 18000 ticks = 12:00 AM (midnight) - darkest
+ * - 23000 ticks = 5:00 AM (dawn begins)
+ * - 24000 ticks = 6:00 AM (same as 0)
+ *
+ * Sky light ranges from 4 (night) to 15 (day).
+ */
+
+/**
+ * Calculate celestial angle from time of day (0-1 range representing sun position)
+ */
+export const getCelestialAngle = (timeOfDay: number): number => {
+  // Normalize time to 0-1 range
+  let angle = ((timeOfDay % 24_000) / 24_000) - 0.25
+
+  if (angle < 0) angle += 1
+  if (angle > 1) angle -= 1
+
+  // Vanilla Minecraft applies a smoothing curve
+  const smoothedAngle = angle + (1 - Math.cos(angle * Math.PI)) / 2
+  return smoothedAngle
+}
+
+/**
+ * Calculate sky light level (0-15) based on time of day in ticks.
+ * Matches Minecraft vanilla behavior.
+ *
+ * @param timeOfDay - Time in ticks (0-24000)
+ * @returns Sky light level (4-15, where 15 is brightest day, 4 is darkest night)
+ */
+export const calculateSkyLight = (timeOfDay: number): number => {
+  // Normalize time to 0-24000 range
+  const normalizedTime = ((timeOfDay % 24_000) + 24_000) % 24_000
+
+  // Calculate celestial angle (0-1, where 0.25 is noon, 0.75 is midnight)
+  const celestialAngle = getCelestialAngle(normalizedTime)
+
+  // Calculate brightness factor based on celestial angle
+  // cos gives us smooth day/night transition
+  const cos = Math.cos(celestialAngle * Math.PI * 2)
+
+  // Map cos (-1 to 1) to brightness (0 to 1)
+  // At noon (celestialAngle ~0.25): cos(0.5π) = 0, but we want max brightness
+  // At midnight (celestialAngle ~0.75): cos(1.5π) = 0, but we want min brightness
+
+  // Vanilla-like calculation:
+  // brightness goes from 0 (dark) to 1 (bright)
+  const brightness = cos * 0.5 + 0.5
+
+  // Apply threshold - night should be darker
+  // Vanilla has minimum sky light of 4 during night
+  const skyLight = Math.round(4 + brightness * 11)
+
+  return Math.max(4, Math.min(15, skyLight))
+}
+
+/**
+ * Simplified sky light calculation that more closely matches vanilla behavior.
+ * Uses piecewise linear interpolation based on known Minecraft light levels.
+ *
+ * @param timeOfDay - Time in ticks (0-24000)
+ * @returns Sky light level (4-15)
+ */
+export const calculateSkyLightSimple = (timeOfDay: number): number => {
+  // Normalize to 0-24000
+  const time = ((timeOfDay % 24_000) + 24_000) % 24_000
+
+  // Vanilla Minecraft approximate sky light levels:
+  // 0-12000 (6AM-6PM): Day, sky light = 15
+  // 12000-13000 (6PM-7PM): Sunset transition, 15 -> 4
+  // 13000-23000 (7PM-5AM): Night, sky light = 4
+  // 23000-24000 (5AM-6AM): Sunrise transition, 4 -> 15
+
+  if (time >= 0 && time < 12_000) {
+    // Day time - full brightness
+    return 15
+  } else if (time >= 12_000 && time < 13_000) {
+    // Sunset transition (6PM to 7PM)
+    const progress = (time - 12_000) / 1000
+    return Math.round(15 - progress * 11)
+  } else if (time >= 13_000 && time < 23_000) {
+    // Night time - minimum brightness
+    return 4
+  } else {
+    // Sunrise transition (5AM to 6AM)
+    const progress = (time - 23_000) / 1000
+    return Math.round(4 + progress * 11)
+  }
+}
+
+// Test/debug helper - run this to see values at different times
+export const debugSkyLight = () => {
+  const testTimes = [
+    { ticks: 0, label: '6:00 AM (sunrise)' },
+    { ticks: 6000, label: '12:00 PM (noon)' },
+    { ticks: 12_000, label: '6:00 PM (sunset starts)' },
+    { ticks: 12_500, label: '6:30 PM (sunset mid)' },
+    { ticks: 13_000, label: '7:00 PM (night begins)' },
+    { ticks: 18_000, label: '12:00 AM (midnight)' },
+    { ticks: 19_000, label: '1:00 AM' },
+    { ticks: 23_000, label: '5:00 AM (dawn begins)' },
+    { ticks: 23_500, label: '5:30 AM (dawn mid)' },
+  ]
+
+  console.log('Sky Light Debug:')
+  console.log('================')
+  for (const { ticks, label } of testTimes) {
+    const smooth = calculateSkyLight(ticks)
+    const simple = calculateSkyLightSimple(ticks)
+    console.log(`${ticks.toString().padStart(5)} ticks (${label}): smooth=${smooth}, simple=${simple}`)
+  }
+}
+
+// Export for global access in console
+if (typeof window !== 'undefined') {
+  (window as any).debugSkyLight = debugSkyLight
+}

package/src/lib/worldrendererCommon.ts

@@ -17,6 +17,7 @@ import { getPlayerStateUtils } from '../graphicsBackend/playerState'
 type PlayerStateUtils = ReturnType<typeof getPlayerStateUtils>
 import { MesherLogReader } from './mesherlogReader'
 import { setSkinsConfig } from './utils/skins'
+import { calculateSkyLightSimple } from './skyLight'
 import { WorldViewWorker } from '../worldView'
 import { generateSpiralMatrix } from './spiral'
 import { PlayerStateReactive } from '../playerState/playerState'
@@ -540,19 +541,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   getMesherConfig(): MesherConfig {
-    let skyLight = 15
     const timeOfDay = this.timeOfTheDay
-    if (timeOfDay < 0 || timeOfDay > 24_000) {
-      //
-    } else if (timeOfDay <= 6000 || timeOfDay >= 18_000) {
-      skyLight = 15
-    } else if (timeOfDay > 6000 && timeOfDay < 12_000) {
-      skyLight = 15 - ((timeOfDay - 6000) / 6000) * 15
-    } else if (timeOfDay >= 12_000 && timeOfDay < 18_000) {
-      skyLight = ((timeOfDay - 12_000) / 6000) * 15
-    }
-
-    skyLight = Math.floor(skyLight)
+    const skyLight = (timeOfDay < 0 || timeOfDay > 24_000) ? 15 : calculateSkyLightSimple(timeOfDay)
     return {
       version: this.version,
       enableLighting: this.worldRendererConfig.enableLighting,

package/src/mesher/models.ts

@@ -1,6 +1,7 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 import worldBlockProvider, { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
 import legacyJson from '../lib/preflatMap.json'
 import { BlockType } from '../playground/shared'
 import { World, BlockModelPartsResolved, WorldBlock as Block, WorldBlock, worldColumnKey } from './world'
@@ -16,6 +17,7 @@ let blockProvider: WorldBlockProvider
 
 const tints: any = {}
 let needTiles = false
+let semiTransparentBlocks: string[] = []
 
 let tintsData
 try {
@@ -700,7 +702,7 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
 
             for (const element of model.elements ?? []) {
               const ao = model.ao ?? block.boundingBox !== 'empty'
-              if (block.transparent) {
+              if (block.transparent && semiTransparentBlocks.includes(block.name)) {
                 const pos = cursor.clone()
                 delayedRender.push(() => {
                   renderElement(world, pos, element, ao, attr, globalMatrix, globalShift, block, biome)
@@ -794,7 +796,7 @@ function arrayNeedsUint32(array) {
 
 }
 
-export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTiles = false, useUnknownBlockModel = true, version = 'latest') => {
+export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTiles = false, useUnknownBlockModel = true, version = 'latest', mcData = (globalThis as any).mcData) => {
   blockProvider = worldBlockProvider(blockstatesModels, blocksAtlas, version)
   globalThis.blockProvider = blockProvider
   if (useUnknownBlockModel) {
@@ -802,4 +804,28 @@ export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTil
   }
 
   needTiles = _needTiles
+
+  // Cache semi-transparent blocks based on regex patterns from moreBlockDataGenerated.json
+  const regexPatterns = Object.keys(moreBlockDataGeneratedJson.hasSemiTransparentTextuersRegex || {})
+  semiTransparentBlocks = []
+
+  // Get all block names from blockstatesModels
+  if (!Array.isArray(mcData.blocks)) throw new Error('mcData.blocks is not an array')
+  const allBlockNames = mcData.blocks.map(block => block.name)
+
+  // Filter blocks that match any of the regex patterns
+  for (const blockName of allBlockNames) {
+    for (const pattern of regexPatterns) {
+      try {
+        const regex = new RegExp(pattern)
+        if (regex.test(blockName)) {
+          semiTransparentBlocks.push(blockName)
+          break // Only add once per block
+        }
+      } catch (err) {
+        // Invalid regex pattern, skip
+        console.warn('Invalid regex pattern in hasSemiTransparentTextuersRegex:', pattern)
+      }
+    }
+  }
 }

package/src/mesher/test/mesherTester.ts

@@ -39,7 +39,7 @@ export const setup = (version, initialBlocks: Array<[number[], string]>, options
     }
   }
 
-  setBlockStatesData(blockStatesModels, blocksAtlasesJson, !options?.noDebugTiles, false, version)
+  setBlockStatesData(blockStatesModels, blocksAtlasesJson, !options?.noDebugTiles, false, version, { blocks: mcData.blocksArray })
   const reload = () => {
     mesherWorld.removeColumn(0, 0)
     mesherWorld.addColumn(0, 0, chunk1.toJson())

package/src/sign-renderer/index.ts

@@ -137,7 +137,10 @@ export const renderComponent = (
   const textWidths: number[] = []
 
   const renderText = (component: Message, parentFormatting?: Formatting | undefined) => {
-    const { text } = component
+    if (component.text !== null && component.text !== undefined && typeof component.text !== 'string') {
+      console.warn('renderText received non-string text value:', typeof component.text, component.text)
+    }
+    const text = component.text === null || component.text === undefined ? undefined : String(component.text)
     const formatting = {
       color: component.color ?? parentFormatting?.color,
       underlined: component.underlined ?? parentFormatting?.underlined,

package/src/three/bannerRenderer.ts

@@ -144,10 +144,11 @@ export const renderBanner = (
 
   ctx.imageSmoothingEnabled = false
 
-  // Always render base color first (even if no patterns)
-  const baseColorHex = BANNER_COLORS[baseColor] || BANNER_COLORS[15]
-  ctx.fillStyle = baseColorHex
-  ctx.fillRect(0, 0, BANNER_WIDTH * scale, BANNER_HEIGHT * scale)
+  // Base color rendering disabled
+  // // Always render base color first (even if no patterns)
+  // const baseColorHex = BANNER_COLORS[baseColor] || BANNER_COLORS[15]
+  // ctx.fillStyle = baseColorHex
+  // ctx.fillRect(0, 0, BANNER_WIDTH * scale, BANNER_HEIGHT * scale)
 
   // Render patterns on top of base color (if any)
   if (blockEntity?.Patterns && blockEntity.Patterns.length > 0) {

package/src/three/cinimaticScript.ts

@@ -97,8 +97,8 @@ export class CinimaticScriptRunner {
   }
 
   runExampleScripts(index: number) {
-    const { cameraObject } = this.worldRenderer
-    const playerPos = new Vec3(cameraObject.position.x, cameraObject.position.y, cameraObject.position.z)
+    const cameraWorldPos = this.worldRenderer.getCameraPosition()
+    const playerPos = new Vec3(cameraWorldPos.x, cameraWorldPos.y, cameraWorldPos.z)
 
     // Circular flyby around current position
     const circular = CinimaticScriptRunner.createCircularFlyby(playerPos, 30, 20, 15_000)

package/src/three/entities.ts

@@ -423,6 +423,9 @@ export class Entities {
 
     // Update position and rotation
     if (playerData.position) {
+      if (!this.worldRenderer.sceneOrigin.getWorldPosition(this.playerEntity)) {
+        this.worldRenderer.sceneOrigin.track(this.playerEntity)
+      }
       this.playerEntity.position.set(playerData.position.x, playerData.position.y, playerData.position.z)
     }
     if (playerData.yaw !== undefined) {
@@ -434,7 +437,7 @@ export class Entities {
 
   clear() {
     for (const mesh of Object.values(this.entities)) {
-      this.worldRenderer.scene.remove(mesh)
+      this.worldRenderer.sceneOrigin.removeAndUntrack(mesh)
       disposeObject(mesh)
     }
     this.entities = {}
@@ -446,7 +449,7 @@ export class Entities {
 
     // Clean up player entity
     if (this.playerEntity) {
-      this.worldRenderer.scene.remove(this.playerEntity)
+      this.worldRenderer.sceneOrigin.removeAndUntrack(this.playerEntity)
       disposeObject(this.playerEntity)
       this.playerEntity = null
     }
@@ -534,22 +537,29 @@ export class Entities {
 
         if (thirdPersonNow) {
           const yOffset = this.worldRenderer.playerStateReactive.eyeHeight
-          const pos = this.worldRenderer.cameraObject.position.clone().add(new THREE.Vector3(0, -yOffset, 0))
-          entity.position.set(pos.x, pos.y, pos.z)
+          // Set world position — proxy auto-converts to scene coords
+          entity.position.set(
+            this.worldRenderer.cameraWorldPos.x,
+            this.worldRenderer.cameraWorldPos.y - yOffset,
+            this.worldRenderer.cameraWorldPos.z
+          )
 
           const p: any = (this.worldRenderer.playerStateReactive as any).position
           if (p && typeof p.x === 'number') {
             this.updateAutoWalkFlags(entityKey, entity, dtRaw, new THREE.Vector3(p.x, p.y, p.z))
           } else {
-            this.updateAutoWalkFlags(entityKey, entity, dtRaw, entity.position)
+            const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
+            this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
           }
 
           this.updateThirdPersonHeadAndBody(entity, dt)
         } else {
-          this.updateAutoWalkFlags(entityKey, entity, dtRaw, entity.position)
+          const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
+          this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
         }
       } else {
-        this.updateAutoWalkFlags(entityKey, entity, dtRaw, entity.position)
+        const wp = this.worldRenderer.sceneOrigin.getWorldPosition(entity)
+        this.updateAutoWalkFlags(entityKey, entity, dtRaw, wp ? new THREE.Vector3(wp.x, wp.y, wp.z) : entity.position)
       }
 
       const { playerObject } = entity
@@ -790,6 +800,7 @@ export class Entities {
       skinTexture.needsUpdate = true
       playerObject.skin.map = skinTexture as any
       playerObject.skin.modelType = inferModelType(skinCanvas)
+      playerObject.skin['isCustom'] = skinUrl !== stevePngUrl
 
       let earsCanvas: HTMLCanvasElement | undefined
       if (!playerCustomSkinImage) {
@@ -1031,12 +1042,13 @@ export class Entities {
 
     if (entity.delete) {
       if (!e) return
+      e.userData._posTween?.stop()
       if (e.additionalCleanup) e.additionalCleanup()
       e.traverse(c => {
         if (c['additionalCleanup']) c['additionalCleanup']()
       })
       this.onRemoveEntity(entity)
-      this.worldRenderer.scene.remove(e)
+      this.worldRenderer.sceneOrigin.removeAndUntrack(e)
       disposeObject(e)
       // todo dispose textures as well ?
       delete this.entities[entity.id]
@@ -1109,6 +1121,7 @@ export class Entities {
       mesh.name = 'mesh'
       // set initial position so there are no weird jumps update after
       const pos = entity.pos ?? entity.position
+      this.worldRenderer.sceneOrigin.track(group)
       group.position.set(pos.x, pos.y, pos.z)
 
       // todo use width and height instead
@@ -1326,7 +1339,20 @@ export class Entities {
     if (!e) return
     const ANIMATION_DURATION = justAdded ? 0 : TWEEN_DURATION
     if (entity.position) {
-      new TWEEN.Tween(e.position).to({ x: entity.position.x, y: entity.position.y, z: entity.position.z }, ANIMATION_DURATION).start()
+      // Initialize tween target from current world position
+      const currentWorld = this.worldRenderer.sceneOrigin.getWorldPosition(e) ?? { x: entity.position.x, y: entity.position.y, z: entity.position.z }
+      if (!e.userData._tweenTarget) {
+        e.userData._tweenTarget = { x: currentWorld.x, y: currentWorld.y, z: currentWorld.z }
+      }
+      // Stop previous position tween to prevent accumulation
+      e.userData._posTween?.stop()
+      // Tween a separate target object, apply via proxy on each update
+      e.userData._posTween = new TWEEN.Tween(e.userData._tweenTarget)
+        .to({ x: entity.position.x, y: entity.position.y, z: entity.position.z }, ANIMATION_DURATION)
+        .onUpdate(() => {
+          e.position.set(e.userData._tweenTarget.x, e.userData._tweenTarget.y, e.userData._tweenTarget.z)
+        })
+        .start()
     }
     if (entity.yaw) {
       const da = (entity.yaw - e.rotation.y) % (Math.PI * 2)
@@ -1366,8 +1392,13 @@ export class Entities {
     if (!mesh.visible) return
 
     const MAX_DISTANCE_SKIN_LOAD = 128
-    const cameraPos = this.worldRenderer.cameraObject.position
-    const distance = mesh.position.distanceTo(cameraPos)
+    const cameraPos = this.worldRenderer.getCameraPosition()
+    // Use world positions for accurate distance calculation
+    const wp = this.worldRenderer.sceneOrigin.getWorldPosition(mesh)
+    const entityWorldPos = wp
+      ? new THREE.Vector3(wp.x, wp.y, wp.z)
+      : mesh.position.clone().add(new THREE.Vector3(this.worldRenderer.sceneOrigin.x, this.worldRenderer.sceneOrigin.y, this.worldRenderer.sceneOrigin.z))
+    const distance = entityWorldPos.distanceTo(cameraPos)
     if (distance < MAX_DISTANCE_SKIN_LOAD && distance < (this.worldRenderer.viewDistance * 16)) {
       if (this.loadedSkinEntityIds.has(String(entityId))) return
       void this.updatePlayerSkin(entityId, mesh.playerObject.realUsername, mesh.playerObject.realPlayerUuid, true, true)

package/src/three/entity/EntityMesh.ts

@@ -331,7 +331,7 @@ export function getMesh(
   geometry.setAttribute('skinWeight', new THREE.Float32BufferAttribute(geoData.skinWeights, 4))
   geometry.setIndex(geoData.indices)
 
-  const material = new THREE.MeshLambertMaterial({ transparent: true, alphaTest: 0.1 })
+  const material = new THREE.MeshLambertMaterial({ transparent: true, alphaTest: 0.1, side: THREE.DoubleSide })
   const mesh = new THREE.SkinnedMesh(geometry, material)
   mesh.add(...rootBones)
   mesh.bind(skeleton)

package/src/three/entity/entities.json

@@ -125,11 +125,14 @@
     "render_controllers": ["controller.render.arrow"]
   },
   "bat": {
+    "_comment": "Wing tip mirror flags are swapped vs vanilla Bedrock model: our addCube() mirror implementation flips UVs in the opposite direction, so rightWingTip needs mirror=true and leftWingTip needs mirror=false to render correctly.",
     "identifier": "minecraft:bat",
     "materials": {"default": "bat"},
-    "textures": {"default": "textures/entity/bat"},
+    "textures": {"default": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAALHSURBVHja7VrBSiQxFJybHvci6G1gF2TBwyoKelnWy55kWYS9ePDmD+in+KcevLb7GgpqipeeTkzPpGdewSNJmx6nKtXJS3oWiwTOv33pbs6Ou9vr731YHddQ5/ZiAHa/9cXnjLln62DyLALIL48P+4AIQ+RZAP2cnO909/PH4uvRQcdh1zSqwCMPIiDPIqwT8uHufMVJuDfnOxnhq9OT7vHPZR9WZxEgSjUBUi7IcQBG++XpphfB6rgvVwCQ//f7og8WAeL8F6Kr6oD7X8s+PPuOmQNYAAsIUOIAkDeSLIK1LeCMagIweZQ8iRkBlJuYl5gwSlxjZ2R9KM/2XBphsyxEQGhfOCEVNQXQ0UZdo2i21+edR57DmxjZFRpTCaD2/7QAXsAFcEKq3zYEGHJBtgCeC97f3vtnG0uY1e1aavQ3/QgMuaBoDtCsDyWv3yqSlxhpTClAygXZArAILIaS8ezOo52TIJVA1/sqAswRnhCfEoAnuqGkZwpbZxJfyflTQuysAN7GxxNiZ62fEoCFMBGqpcK8h8ckqIkRoiU3VPkHIM/2R4rMaTLK0pGr9oVrw9v7Iy/QDLFEAH5umxTAW9utreTHOuD1+e/KaQ4mrGrb1ykE0L07HODFmKMsJs1b2GYfAc0MdYPEThiTvIA8DjWayNxSs3pJePPDOvJNCKDL27r22L95AlRJXaewuh57cVuPx7Acen1VlNkIoKR0++udCer84PXn42wj660EW38BooS99rqTn1R/FkCTnibyAH3l5bW9GOqjx+Wa8TWVCXpn/NzW63oIote1bH6HlSKUK0BKkFkIgDSX01+taz9+vTV0X/MC6Hu+1OFmSb9tHp6MRopIrQgBAjMDtr2bfOvb3KTIP2vZy9HnvH6vXJD6ZdheOYAJl/yOZ/YCMOFYygKBQCAQCAQCgUAgEAgEAoFAIBDYKXwAXSs8dJ1Ggb4AAAAASUVORK5CYII="},
     "geometry": {
       "default": {
+        "texturewidth": 64,
+        "textureheight": 64,
         "visible_bounds_width": 1,
         "visible_bounds_height": 1,
         "visible_bounds_offset": [0, 0.5, 0],
@@ -174,6 +177,7 @@
           },
           {
             "name": "rightWingTip",
+            "mirror": true,
             "pivot": [-12, 23, 1.5],
             "cubes": [
               {"origin": [-20, 10, 1.5], "size": [8, 12, 1], "uv": [24, 16]}
@@ -191,7 +195,6 @@
           },
           {
             "name": "leftWingTip",
-            "mirror": true,
             "pivot": [12, 23, 1.5],
             "cubes": [
               {"origin": [12, 10, 1.5], "size": [8, 12, 1], "uv": [24, 16]}
@@ -3541,6 +3544,109 @@
     "render_controllers": ["controller.render.salmon"],
     "spawn_egg": {"texture": "spawn_egg", "texture_index": 47}
   },
+  "sheep": {
+    "identifier": "minecraft:sheep",
+    "materials": {"default": "sheep"},
+    "textures": {"default": "textures/entity/sheep/sheep", "wool": "textures/entity/sheep/sheep_fur"},
+    "geometry": {
+      "default": {
+        "visible_bounds_width": 2,
+        "visible_bounds_height": 1.75,
+        "visible_bounds_offset": [0, 0.5, 0],
+        "texturewidth": 64,
+        "textureheight": 32,
+        "bones": [
+          {
+            "name": "body",
+            "pivot": [0, 19, 2],
+            "bind_pose_rotation": [90, 0, 0],
+            "cubes": [
+              {"origin": [-4, 13, -5], "size": [8, 16, 6], "uv": [28, 8]}
+            ]
+          },
+          {
+            "name": "head",
+            "pivot": [0, 18, -8],
+            "cubes": [
+              {"origin": [-3, 16, -14], "size": [6, 6, 8], "uv": [0, 0]}
+            ]
+          },
+          {
+            "name": "leg0",
+            "parent": "body",
+            "pivot": [-3, 12, 7],
+            "cubes": [{"origin": [-5, 0, 5], "size": [4, 12, 4], "uv": [0, 16]}]
+          },
+          {
+            "name": "leg1",
+            "parent": "body",
+            "pivot": [3, 12, 7],
+            "cubes": [{"origin": [1, 0, 5], "size": [4, 12, 4], "uv": [0, 16]}]
+          },
+          {
+            "name": "leg2",
+            "parent": "body",
+            "pivot": [-3, 12, -5],
+            "cubes": [{"origin": [-5, 0, -7], "size": [4, 12, 4], "uv": [0, 16]}]
+          },
+          {
+            "name": "leg3",
+            "parent": "body",
+            "pivot": [3, 12, -5],
+            "cubes": [{"origin": [1, 0, -7], "size": [4, 12, 4], "uv": [0, 16]}]
+          }
+        ]
+      },
+      "wool": {
+        "visible_bounds_width": 2,
+        "visible_bounds_height": 1.75,
+        "visible_bounds_offset": [0, 0.5, 0],
+        "texturewidth": 64,
+        "textureheight": 64,
+        "bones": [
+          {
+            "name": "head",
+            "pivot": [0, 18, -8],
+            "cubes": [
+              {"origin": [-3, 16, -12], "size": [6, 6, 6], "uv": [0, 32], "inflate": 0.6}
+            ]
+          },
+          {
+            "name": "body",
+            "pivot": [0, 19, 2],
+            "bind_pose_rotation": [90, 0, 0],
+            "cubes": [
+              {"origin": [-4, 13, -5], "size": [8, 16, 6], "uv": [28, 40], "inflate": 1.75}
+            ]
+          },
+          {
+            "name": "leg0",
+            "parent": "body",
+            "pivot": [-3, 12, 7],
+            "cubes": [{"origin": [-5, 6, 5], "size": [4, 6, 4], "uv": [0, 48], "inflate": 0.5}]
+          },
+          {
+            "name": "leg1",
+            "parent": "body",
+            "pivot": [3, 12, 7],
+            "cubes": [{"origin": [1, 6, 5], "size": [4, 6, 4], "uv": [0, 48], "inflate": 0.5}]
+          },
+          {
+            "name": "leg2",
+            "parent": "body",
+            "pivot": [-3, 12, -5],
+            "cubes": [{"origin": [-5, 6, -7], "size": [4, 6, 4], "uv": [0, 48], "inflate": 0.5}]
+          },
+          {
+            "name": "leg3",
+            "parent": "body",
+            "pivot": [3, 12, -5],
+            "cubes": [{"origin": [1, 6, -7], "size": [4, 6, 4], "uv": [0, 48], "inflate": 0.5}]
+          }
+        ]
+      }
+    }
+  },
   "shulker_bullet": {
     "identifier": "minecraft:shulker_bullet",
     "materials": {"default": "shulker_bullet"},

package/src/three/entity/exportedModels.js

@@ -22,7 +22,6 @@ export { default as parrot } from './models/parrot.obj'
 export { default as piglin } from './models/piglin.obj'
 export { default as pillager } from './models/pillager.obj'
 export { default as rabbit } from './models/rabbit.obj'
-export { default as sheep } from './models/sheep.obj'
 export { default as arrow } from './models/arrow.obj'
 export { default as shulker } from './models/shulker.obj'
 export { default as sniffer } from './models/sniffer.obj'