minecraft-renderer 0.1.0

package/src/playground/scenes/frequentUpdates.ts

@@ -0,0 +1,148 @@
+//@ts-nocheck
+import { Vec3 } from 'vec3'
+import { BasePlaygroundScene } from '../baseScene'
+
+export default class extends BasePlaygroundScene {
+  viewDistance = 5
+  continuousRender = true
+
+  override initGui (): void {
+    this.params = {
+      testActive: false,
+      testUpdatesPerSecond: 10,
+      testInitialUpdate: false,
+      stopGeometryUpdate: false,
+      manualTest: () => {
+        this.updateBlock()
+      },
+      testNeighborUpdates: () => {
+        this.testNeighborUpdates()
+      }
+    }
+
+    super.initGui()
+  }
+
+  lastUpdatedOffset = 0
+  lastUpdatedId = 2
+  updateBlock () {
+    const x = this.lastUpdatedOffset % 16
+    const z = Math.floor(this.lastUpdatedOffset / 16)
+    const y = 90
+    worldView!.setBlockStateId(new Vec3(x, y, z), this.lastUpdatedId++)
+    this.lastUpdatedOffset++
+    if (this.lastUpdatedOffset > 16 * 16) this.lastUpdatedOffset = 0
+    if (this.lastUpdatedId > 500) this.lastUpdatedId = 1
+  }
+
+  testNeighborUpdates () {
+    viewer.world.setBlockStateId(new Vec3(15, 95, 15), 1)
+    viewer.world.setBlockStateId(new Vec3(0, 95, 15), 1)
+    viewer.world.setBlockStateId(new Vec3(15, 95, 0), 1)
+    viewer.world.setBlockStateId(new Vec3(0, 95, 0), 1)
+
+    viewer.world.setBlockStateId(new Vec3(16, 95, 15), 1)
+    viewer.world.setBlockStateId(new Vec3(-1, 95, 15), 1)
+    viewer.world.setBlockStateId(new Vec3(15, 95, -1), 1)
+    viewer.world.setBlockStateId(new Vec3(-1, 95, 0), 1)
+    setTimeout(() => {
+      viewer.world.setBlockStateId(new Vec3(16, 96, 16), 1)
+      viewer.world.setBlockStateId(new Vec3(-1, 96, 16), 1)
+      viewer.world.setBlockStateId(new Vec3(16, 96, -1), 1)
+      viewer.world.setBlockStateId(new Vec3(-1, 96, -1), 1)
+    }, 3000)
+  }
+
+  setupTimer () {
+    // this.stopRender = true
+
+    let lastTime = 0
+    const tick = () => {
+      viewer.world.debugStopGeometryUpdate = this.params.stopGeometryUpdate
+      const updateEach = 1000 / this.params.testUpdatesPerSecond
+      requestAnimationFrame(tick)
+      if (!this.params.testActive) return
+      const updateCount = Math.floor(performance.now() - lastTime) / updateEach
+      for (let i = 0; i < updateCount; i++) {
+        this.updateBlock()
+      }
+      lastTime = performance.now()
+    }
+
+    requestAnimationFrame(tick)
+
+    // const limit = 1000
+    // const limit = 100
+    // const limit = 1
+    // const updatedChunks = new Set<string>()
+    // const updatedBlocks = new Set<string>()
+    // let lastSecond = 0
+    // setInterval(() => {
+    //   const second = Math.floor(performance.now() / 1000)
+    //   if (lastSecond !== second) {
+    //     lastSecond = second
+    //     updatedChunks.clear()
+    //     updatedBlocks.clear()
+    //   }
+    //   const isEven = second % 2 === 0
+    //   if (updatedBlocks.size > limit) {
+    //     return
+    //   }
+    //   const changeBlock = (x, z) => {
+    //     const chunkKey = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
+    //     const key = `${x},${z}`
+    //     if (updatedBlocks.has(chunkKey)) return
+
+    //     updatedChunks.add(chunkKey)
+    //     worldView!.world.setBlock(this.targetPos.offset(x, 0, z), this.Block.fromStateId(isEven ? 2 : 3, 0))
+    //     updatedBlocks.add(key)
+    //   }
+    //   const { squareSize } = this.params
+    //   const xStart = -squareSize
+    //   const zStart = -squareSize
+    //   const xEnd = squareSize
+    //   const zEnd = squareSize
+    //   for (let x = xStart; x <= xEnd; x += 16) {
+    //     for (let z = zStart; z <= zEnd; z += 16) {
+    //       const key = `${x},${z}`
+    //       if (updatedChunks.has(key)) continue
+    //       changeBlock(x, z)
+    //       return
+    //     }
+    //   }
+    // for (let x = xStart; x <= xEnd; x += 16) {
+    //   for (let z = zStart; z <= zEnd; z += 16) {
+    //     const key = `${x},${z}`
+    //     if (updatedChunks.has(key)) continue
+    //     changeBlock(x, z)
+    //     return
+    //   }
+    // }
+    // }, 1)
+  }
+
+  setupWorld () {
+    this.worldConfig.showChunkBorders = true
+
+    const maxSquareRadius = this.viewDistance * 16
+    // const fullBlocks = loadedData.blocksArray.map(x => x.name)
+    const squareSize = maxSquareRadius
+    for (let x = -squareSize; x <= squareSize; x++) {
+      for (let z = -squareSize; z <= squareSize; z++) {
+        const i = Math.abs(x + z) * squareSize
+        worldView!.world.setBlock(this.targetPos.offset(x, 0, z), this.Block.fromStateId(1, 0))
+      }
+    }
+    let done = false
+    viewer.world.renderUpdateEmitter.on('update', () => {
+      if (!viewer.world.allChunksFinished || done) return
+      done = true
+      this.setupTimer()
+    })
+    setTimeout(() => {
+      if (this.params.testInitialUpdate) {
+        this.updateBlock()
+      }
+    })
+  }
+}

package/src/playground/scenes/geometryExport.ts

@@ -0,0 +1,142 @@
+import * as THREE from 'three'
+import { BasePlaygroundScene } from '../baseScene'
+import {
+  downloadWorldGeometry,
+  loadWorldGeometryFromUrl,
+  type ExportedWorldGeometry
+} from '../../three/worldGeometryExport'
+
+type GeometryExportBackendMethods = {
+  loadGeometryExport?: (exportData: ExportedWorldGeometry) => Promise<number>
+}
+
+/**
+ * Scene for exporting/importing world geometry
+ *
+ * Usage:
+ * - Load normally: builds world from blocks, can export geometry
+ * - Load with ?geometryUrl=URL: loads pre-exported geometry from file (or default world-geometry.json)
+ */
+export default class extends BasePlaygroundScene {
+  params = {
+    exportGeometry: () => this.exportGeometry(),
+    exportWithTexture: () => this.exportGeometry(true),
+  }
+
+  // Loaded geometry data (when loading from URL)
+  private loadedGeometry: ExportedWorldGeometry | null = null
+  private readonly geometryUrl: string | null
+
+  constructor() {
+    const qs = new URLSearchParams(window.location.search)
+    const geometryUrl = qs.get('geometryUrl') ?? 'world-geometry.json'
+
+    // If loading from URL, skip normal world setup (viewDistance 0 means no chunks loaded)
+    super({
+      viewDistance: geometryUrl ? 0 : 1,
+      continuousRender: false,
+      enableCameraOrbitControl: false,
+    })
+
+    this.geometryUrl = geometryUrl
+  }
+
+  // Override initData to load geometry after base initialization completes
+  override async initData() {
+    await super.initData()
+
+    // Now camera and worldRenderer are ready - load geometry if URL provided
+    if (this.geometryUrl) {
+      await this.loadFromUrl(this.geometryUrl)
+    }
+  }
+
+  setupWorld() {
+    if (this.geometryUrl) {
+      return
+    }
+    // Default world setup - add some blocks for testing
+    this.addWorldBlock(0, 0, 0, 'stone')
+    this.addWorldBlock(1, 0, 0, 'grass_block')
+    this.addWorldBlock(0, 0, 1, 'dirt')
+    this.addWorldBlock(1, 0, 1, 'cobblestone')
+    this.addWorldBlock(0, 1, 0, 'oak_log')
+    this.addWorldBlock(1, 1, 0, 'oak_planks')
+  }
+
+  private async loadFromUrl(url: string) {
+    try {
+      console.log('Loading geometry from:', url)
+      this.loadedGeometry = await loadWorldGeometryFromUrl(url)
+
+      // Restore camera position and rotation
+      const { camera: camData } = this.loadedGeometry
+      this.camera.position.set(camData.position.x, camData.position.y, camData.position.z)
+
+      // Apply rotation using lookAt direction
+      const { pitch, yaw } = camData.rotation
+      const forward = new THREE.Vector3(
+        -Math.sin(yaw) * Math.cos(pitch),
+        Math.sin(pitch),
+        -Math.cos(yaw) * Math.cos(pitch)
+      )
+      this.camera.lookAt(
+        camData.position.x + forward.x,
+        camData.position.y + forward.y,
+        camData.position.z + forward.z
+      )
+      this.controls?.update()
+      this.syncCameraToBackend()
+
+      const backendMethods = this.appViewer.backend?.backendMethods as GeometryExportBackendMethods | undefined
+      if (!backendMethods?.loadGeometryExport) {
+        console.warn('Three.js backend does not expose loadGeometryExport')
+        return
+      }
+
+      const geometryData = this.loadedGeometry
+      if (!geometryData) {
+        console.warn('No geometry data available after load')
+        return
+      }
+
+      const importedCount = await backendMethods.loadGeometryExport(geometryData)
+      console.log(`Loaded ${importedCount} sections from geometry file`)
+      this.requestRender()
+
+    } catch (err) {
+      console.error('Failed to load geometry:', err)
+    }
+  }
+
+  private exportGeometry(includeTexture = false) {
+    const { worldRenderer } = this
+    if (!worldRenderer) {
+      console.error('WorldRenderer not available')
+      return
+    }
+
+    // Get camera position and rotation
+    const cameraPosition = {
+      x: this.camera.position.x,
+      y: this.camera.position.y,
+      z: this.camera.position.z
+    }
+
+    // Extract yaw/pitch from camera quaternion
+    const forward = new THREE.Vector3(0, 0, -1)
+    forward.applyQuaternion(this.camera.quaternion)
+    const cameraRotation = {
+      yaw: Math.atan2(-forward.x, -forward.z),
+      pitch: Math.asin(forward.y)
+    }
+
+    // Generate filename with timestamp
+    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-')
+    const filename = `world-geometry-${timestamp}.json`
+
+    downloadWorldGeometry(worldRenderer, cameraPosition, cameraRotation, filename, includeTexture)
+    console.log('Geometry exported to:', filename)
+  }
+
+}

package/src/playground/scenes/index.ts

@@ -0,0 +1,12 @@
+// export { default as rotation } from './rotation'
+export { default as main } from './main'
+export { default as railsCobweb } from './railsCobweb'
+// export { default as floorRandom } from './floorRandom'
+// export { default as lightingStarfield } from './lightingStarfield'
+// export { default as transparencyIssue } from './transparencyIssue'
+// export { default as rotationIssue } from './rotationIssue'
+// export { default as entities } from './entities'
+// export { default as frequentUpdates } from './frequentUpdates'
+// export { default as slabsOptimization } from './slabsOptimization'
+// export { default as allEntities } from './allEntities'
+// export { default as geometryExport } from './geometryExport'

package/src/playground/scenes/lightingStarfield.ts

@@ -0,0 +1,40 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import { Vec3 } from 'vec3'
+import { BasePlaygroundScene } from '../baseScene'
+import { WorldRendererThree } from '../../viewer/three/worldrendererThree'
+
+export default class extends BasePlaygroundScene {
+  continuousRender = true
+
+  override setupWorld (): void {
+    viewer.world.mesherConfig.enableLighting = true
+    viewer.world.mesherConfig.skyLight = 0
+    this.addWorldBlock(0, 0, 0, 'stone')
+    this.addWorldBlock(0, 0, 1, 'stone')
+    this.addWorldBlock(1, 0, 0, 'stone')
+    this.addWorldBlock(1, 0, 1, 'stone')
+    // chess like
+    worldView?.world.setBlockLight(this.targetPos.offset(0, 1, 0), 15)
+    worldView?.world.setBlockLight(this.targetPos.offset(0, 1, 1), 0)
+    worldView?.world.setBlockLight(this.targetPos.offset(1, 1, 0), 0)
+    worldView?.world.setBlockLight(this.targetPos.offset(1, 1, 1), 15)
+  }
+
+  override renderFinish (): void {
+    viewer.scene.background = new THREE.Color(0x00_00_00)
+    // starfield and test entities
+    ;(viewer.world as WorldRendererThree).starField.enabled = true
+    ;(viewer.world as WorldRendererThree).starField.addToScene()
+    viewer.entities.update({
+      id: 0,
+      name: 'player',
+      pos: this.targetPos.clone()
+    } as any, {})
+    viewer.entities.update({
+      id: 1,
+      name: 'creeper',
+      pos: this.targetPos.offset(1, 0, 0)
+    } as any, {})
+  }
+}

package/src/playground/scenes/main.ts

@@ -0,0 +1,313 @@
+// eslint-disable-next-line import/no-named-as-default
+import GUI, { Controller } from 'lil-gui'
+import * as THREE from 'three'
+import { BasePlaygroundScene } from '../baseScene'
+import { TWEEN_DURATION } from '@/three/entities'
+import { EntityMesh } from '@/three/entity/EntityMesh'
+
+const includedVersions = globalThis.includedVersions
+
+class MainScene extends BasePlaygroundScene {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(...args) {
+    super(...args)
+  }
+
+  override initGui(): void {
+    // initial values
+    this.params = {
+      skipQs: '',
+      block: '',
+      metadata: 0,
+      supportBlock: false,
+      entity: '',
+      removeEntity() {
+        this.entity = ''
+      },
+      entityRotate: false,
+      camera: '',
+      playSound() { },
+      blockIsomorphicRenderBundle() { },
+      modelVariant: 0
+    }
+    this.metadataGui = this.gui.add(this.params, 'metadata')
+    this.paramOptions = {
+      version: {
+        options: includedVersions,
+        hide: false
+      },
+      block: {
+        options: this.mcData.blocksArray.map(b => b.name).sort((a, b) => a.localeCompare(b))
+      },
+      entity: {
+        options: this.mcData.entitiesArray.map(b => b.name).sort((a, b) => a.localeCompare(b))
+      },
+      camera: {
+        hide: true,
+      }
+    }
+    super.initGui()
+  }
+
+  blockProps = {}
+  metadataFolder: GUI | undefined
+  metadataGui: Controller | undefined
+
+  override onParamUpdate = {
+    version() {
+      // if (initialUpdate) return
+      // viewer.world.texturesVersion = params.version
+      // viewer.world.updateTexturesData()
+      // todo warning
+    },
+    block: () => {
+      this.blockProps = {}
+      this.metadataFolder?.destroy()
+      const block = this.mcData.blocksByName[this.params.block]
+      if (!block) return
+      console.log('block', block.name)
+      const props = new this.Block(block.id, 0, 0).getProperties()
+      const { states } = this.mcData.blocksByStateId[this.getBlock()?.minStateId] ?? {}
+      this.metadataFolder = this.gui.addFolder('metadata')
+      if (states) {
+        for (const state of states) {
+          let defaultValue: string | number | boolean
+          if (state.values) { // int, enum
+            defaultValue = state.values[0] as string | number | boolean
+          } else {
+            switch (state.type) {
+              case 'bool':
+                defaultValue = false
+                break
+              case 'int':
+                defaultValue = 0
+                break
+              case 'direction':
+                defaultValue = 'north'
+                break
+
+              default:
+                continue
+            }
+          }
+          this.blockProps[state.name] = defaultValue
+          if (state.values) {
+            this.metadataFolder.add(this.blockProps, state.name, state.values)
+          } else {
+            this.metadataFolder.add(this.blockProps, state.name)
+          }
+        }
+      } else {
+        for (const [name, value] of Object.entries(props)) {
+          this.blockProps[name] = value
+          this.metadataFolder.add(this.blockProps, name)
+        }
+      }
+      console.log('props', this.blockProps)
+      this.metadataFolder.open()
+    },
+    entity: () => {
+      this.continuousRender = this.params.entity === 'player'
+      this.entityUpdateShared()
+      if (!this.params.entity) return
+      if (this.params.entity === 'player') {
+        this.worldRenderer.entities.updatePlayerSkin('id', this.worldRenderer.entities.entities.id.username, undefined, true, true)
+        this.worldRenderer.entities.playAnimation('id', 'running')
+      }
+      // let prev = false
+      // setInterval(() => {
+      //   viewer.entities.playAnimation('id', prev ? 'running' : 'idle')
+      //   prev = !prev
+      // }, 1000)
+
+      EntityMesh.getStaticData(this.params.entity)
+      // entityRotationFolder.destroy()
+      // entityRotationFolder = gui.addFolder('entity metadata')
+      // entityRotationFolder.add(params, 'entityRotate')
+      // entityRotationFolder.open()
+    },
+    supportBlock: () => {
+      this.worldView!.setBlockStateId(this.targetPos.offset(0, -1, 0), this.params.supportBlock ? 1 : 0)
+    },
+    modelVariant: () => {
+      this.worldRenderer.worldRendererConfig.debugModelVariant = this.params.modelVariant === 0 ? undefined : [this.params.modelVariant]
+    }
+  }
+
+  entityUpdateShared() {
+    this.worldRenderer.entities.clear()
+    if (!this.params.entity) return
+    this.worldView!.emit('entity', {
+      id: 'id', name: this.params.entity, pos: this.targetPos.offset(0.5, 1, 0.5), width: 1, height: 1, username: localStorage.testUsername, yaw: Math.PI, pitch: 0
+    })
+    const enableSkeletonDebug = (obj) => {
+      const { children, isSkeletonHelper } = obj
+      if (!Array.isArray(children)) return
+      if (isSkeletonHelper) {
+        obj.visible = true
+        return
+      }
+      for (const child of children) {
+        if (typeof child === 'object') enableSkeletonDebug(child)
+      }
+    }
+    enableSkeletonDebug(this.worldRenderer.entities.entities['id'])
+    setTimeout(() => {
+      this.render()
+    }, TWEEN_DURATION)
+  }
+
+  getBlock() {
+    return this.mcData.blocksByName[this.params.block || 'air']
+  }
+
+  // applyChanges (metadataUpdate = false, skipQs = false) {
+  override onParamsUpdate(paramName: string, object: any) {
+    const metadataUpdate = paramName === 'metadata'
+
+    const blockId = this.getBlock()?.id
+    let block: import('prismarine-block').Block
+    if (metadataUpdate) {
+      block = new this.Block(blockId, 0, this.params.metadata)
+      Object.assign(this.blockProps, block.getProperties())
+      for (const _child of this.metadataFolder!.children) {
+        const child = _child as import('lil-gui').Controller
+        child.updateDisplay()
+      }
+    } else {
+      try {
+        block = this.Block.fromProperties(blockId ?? -1, this.blockProps, 0)
+      } catch (err) {
+        console.error(err)
+        block = this.Block.fromStateId(0, 0)
+      }
+    }
+
+    this.worldView!.setBlockStateId(this.targetPos, block.stateId ?? 0)
+    console.log('up stateId', block.stateId)
+    this.params.metadata = block.metadata
+    this.metadataGui?.updateDisplay()
+  }
+
+  override renderFinish() {
+    for (const update of Object.values(this.onParamUpdate)) {
+      // update(true)
+      update()
+    }
+    this.onParamsUpdate('', {})
+    this.gui.openAnimated()
+  }
+
+  blockIsomorphicRenderBundle() {
+    const { renderer } = this.worldRenderer
+
+    const canvas = renderer.domElement
+    const onlyCurrent = !confirm('Ok - render all blocks, Cancel - render only current one')
+    const sizeRaw = prompt('Size', '512')
+    if (!sizeRaw) return
+    const size = parseInt(sizeRaw, 10)
+    // const size = 512
+
+    canvas.width = size
+    canvas.height = size
+    renderer.setSize(size, size)
+
+    // Temporarily replace PerspectiveCamera with OrthographicCamera for block rendering
+    this.worldRenderer.camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 10) as any
+    this.worldRenderer.scene.background = null
+
+    const rad = THREE.MathUtils.degToRad(-120)
+    this.worldRenderer.directionalLight.position.set(
+      Math.cos(rad),
+      Math.sin(rad),
+      0.2
+    ).normalize()
+    this.worldRenderer.directionalLight.intensity = 1
+
+    const cameraPos = this.targetPos.offset(2, 2, 2)
+    const pitch = THREE.MathUtils.degToRad(-30)
+    const yaw = THREE.MathUtils.degToRad(45)
+    this.worldRenderer.camera.rotation.set(pitch, yaw, 0, 'ZYX')
+    // this.worldRenderer!.camera.lookAt(center.x + 0.5, center.y + 0.5, center.z + 0.5)
+    this.worldRenderer.camera.position.set(cameraPos.x + 1, cameraPos.y + 0.5, cameraPos.z + 1)
+
+    const allBlocks = this.mcData.blocksArray.map(b => b.name)
+    // const allBlocks = ['stone', 'warped_slab']
+
+    let blockCount = 1
+    let blockName = allBlocks[0]
+
+    const updateBlock = () => {
+      // viewer.setBlockStateId(targetPos, mcData.blocksByName[blockName].minStateId)
+      this.params.block = blockName
+      // todo cleanup (introduce getDefaultState)
+      // TODO
+      // onUpdate.block()
+      // applyChanges(false, true)
+    }
+    void this.worldRenderer.waitForChunksToRender().then(async () => {
+      // wait for next macro task
+      await new Promise(resolve => {
+        setTimeout(resolve, 0)
+      })
+      if (onlyCurrent) {
+        this.render()
+        onWorldUpdate()
+      } else {
+        // will be called on every render update
+        this.worldRenderer.renderUpdateEmitter.addListener('update', onWorldUpdate)
+        updateBlock()
+      }
+    })
+
+    //@ts-ignore
+    const zip = new JSZip()
+    zip.file('description.txt', 'Generated with mcraft.fun/playground')
+
+    const end = async () => {
+      // download zip file
+
+      const a = document.createElement('a')
+      const blob = await zip.generateAsync({ type: 'blob' })
+      const dataUrlZip = URL.createObjectURL(blob)
+      a.href = dataUrlZip
+      a.download = 'blocks_render.zip'
+      a.click()
+      URL.revokeObjectURL(dataUrlZip)
+      console.log('end')
+
+      this.worldRenderer.renderUpdateEmitter.removeListener('update', onWorldUpdate)
+    }
+
+    async function onWorldUpdate() {
+      // await new Promise(resolve => {
+      //   setTimeout(resolve, 50)
+      // })
+      const dataUrl = canvas.toDataURL('image/png')
+
+      zip.file(`${blockName}.png`, dataUrl.split(',')[1], { base64: true })
+
+      if (onlyCurrent) {
+        end()
+      } else {
+        nextBlock()
+      }
+    }
+    const nextBlock = async () => {
+      blockName = allBlocks[blockCount++]
+      console.log(allBlocks.length, '/', blockCount, blockName)
+      if (blockCount % 5 === 0) {
+        await new Promise(resolve => {
+          setTimeout(resolve, 100)
+        })
+      }
+      if (blockName) {
+        updateBlock()
+      } else {
+        end()
+      }
+    }
+  }
+}
+
+export default MainScene

package/src/playground/scenes/railsCobweb.ts

@@ -0,0 +1,14 @@
+import { BasePlaygroundScene } from '../baseScene'
+
+export default class RailsCobwebScene extends BasePlaygroundScene {
+  setupWorld () {
+    this.addWorldBlock(0, 0, 0, 'cobweb')
+    this.addWorldBlock(0, -1, 0, 'cobweb')
+    this.addWorldBlock(1, -1, 0, 'cobweb')
+    this.addWorldBlock(1, 0, 0, 'cobweb')
+
+    this.addWorldBlock(0, 0, 1, 'powered_rail', { shape: 'north_south', waterlogged: false })
+    this.addWorldBlock(0, 0, 2, 'powered_rail', { shape: 'ascending_south', waterlogged: false })
+    this.addWorldBlock(0, 1, 3, 'powered_rail', { shape: 'north_south', waterlogged: false })
+  }
+}

package/src/playground/scenes/rotationIssue.ts

@@ -0,0 +1,7 @@
+import { BasePlaygroundScene } from '../baseScene'
+
+export default class RotationIssueScene extends BasePlaygroundScene {
+  setupWorld () {
+    // todo
+  }
+}

package/src/playground/scenes/slabsOptimization.ts

@@ -0,0 +1,16 @@
+import { BasePlaygroundScene } from '../baseScene'
+
+export default class extends BasePlaygroundScene {
+  expectedNumberOfFaces = 30
+  enableCameraOrbitControl = false
+
+  setupWorld () {
+    this.addWorldBlock(0, 1, 0, 'stone_slab')
+    this.addWorldBlock(0, 0, 0, 'stone')
+    this.addWorldBlock(0, -1, 0, 'stone_slab', { type: 'top', waterlogged: false })
+    this.addWorldBlock(0, -1, -1, 'stone_slab', { type: 'top', waterlogged: false })
+    this.addWorldBlock(0, -1, 1, 'stone_slab', { type: 'top', waterlogged: false })
+    this.addWorldBlock(-1, -1, 0, 'stone_slab', { type: 'top', waterlogged: false })
+    this.addWorldBlock(1, -1, 0, 'stone_slab', { type: 'top', waterlogged: false })
+  }
+}