kiwiengine 0.7.0 → 1.0.0

package/src/dom/dom-particle.ts

@@ -19,20 +19,11 @@ export type DomParticleSystemOptions = {
   orientToVelocity: boolean
 
   blendMode?: BLEND_MODES // ex) 'screen', 'multiply'
-
-  // [성능 최적화] 오브젝트 풀 크기 설정 (기본값: 100)
-  poolSize?: number
 } & DomGameObjectOptions
 
 interface Particle {
   el: HTMLDivElement
 
-  // [성능 최적화] 활성 상태 플래그 및 위치/투명도 캐시
-  active: boolean
-  x: number
-  y: number
-  opacity: number
-
   age: number
   lifespan: number
 
@@ -62,10 +53,6 @@ export class DomParticleSystem extends DomGameObject {
   #loadTexturePromise: Promise<void>
   #particles: Particle[] = []
 
-  // [성능 최적화] DOM 엘리먼트 풀 - 재사용으로 DOM 조작 및 GC 부담 감소
-  #elementPool: HTMLDivElement[] = []
-  #poolSize: number
-
   constructor(options: DomParticleSystemOptions) {
     super(options)
     this.el.style.pointerEvents = 'none'
@@ -80,7 +67,6 @@ export class DomParticleSystem extends DomGameObject {
     this.#fadeRate = options.fadeRate
     this.#orientToVelocity = options.orientToVelocity
     this.#blendMode = options.blendMode
-    this.#poolSize = options.poolSize ?? 100
 
     this.#loadTexturePromise = this.#loadTexture()
   }
@@ -94,22 +80,19 @@ export class DomParticleSystem extends DomGameObject {
     }
   }
 
-  // [성능 최적화] 풀에서 엘리먼트 가져오거나 새로 생성
-  #acquireElement(x: number, y: number, scale: number, angle: number): HTMLDivElement {
-    let el = this.#elementPool.pop()
+  async burst({ x, y }: { x: number; y: number }) {
+    if (!this.#texture) await this.#loadTexturePromise
 
-    if (el) {
-      // 풀에서 가져온 엘리먼트 재설정
-      setStyle(el, {
-        left: `${x}px`,
-        top: `${y}px`,
-        transform: `translate(-50%, -50%) scale(${scale})${this.#orientToVelocity ? ` rotate(${angle}rad)` : ''}`,
-        opacity: `${this.#startAlpha ?? 1}`,
-        display: 'block',
-      })
-    } else {
-      // 풀이 비어있으면 새로 생성
-      el = document.createElement('div')
+    const count = random(this.#count.min, this.#count.max)
+    for (let i = 0; i < count; i++) {
+      const lifespan = random(this.#lifespan.min, this.#lifespan.max)
+      const angle = random(this.#angle.min, this.#angle.max)
+      const sin = Math.sin(angle)
+      const cos = Math.cos(angle)
+      const velocity = random(this.#velocity.min, this.#velocity.max)
+      const scale = random(this.#scale.min, this.#scale.max)
+
+      const el = document.createElement('div')
       setStyle(el, {
         position: 'absolute',
         left: `${x}px`,
@@ -123,48 +106,17 @@ export class DomParticleSystem extends DomGameObject {
         opacity: `${this.#startAlpha ?? 1}`,
         mixBlendMode: this.#blendMode ?? 'normal',
       })
-      this.el.appendChild(el)
-    }
-
-    return el
-  }
-
-  // [성능 최적화] 엘리먼트를 풀로 반환 (DOM에서 제거 대신)
-  #releaseElement(el: HTMLDivElement) {
-    if (this.#elementPool.length < this.#poolSize) {
-      el.style.display = 'none'
-      this.#elementPool.push(el)
-    } else {
-      el.remove()
-    }
-  }
-
-  async burst({ x, y }: { x: number; y: number }) {
-    if (!this.#texture) await this.#loadTexturePromise
-
-    const count = random(this.#count.min, this.#count.max)
-    for (let i = 0; i < count; i++) {
-      const lifespan = random(this.#lifespan.min, this.#lifespan.max)
-      const angle = random(this.#angle.min, this.#angle.max)
-      const sin = Math.sin(angle)
-      const cos = Math.cos(angle)
-      const velocity = random(this.#velocity.min, this.#velocity.max)
-      const scale = random(this.#scale.min, this.#scale.max)
-
-      const el = this.#acquireElement(x, y, scale, angle)
 
       this.#particles.push({
         el,
-        active: true,
-        x,
-        y,
-        opacity: this.#startAlpha ?? 1,
         age: 0,
         lifespan,
         velocityX: velocity * cos,
         velocityY: velocity * sin,
         fadeRate: this.#fadeRate,
       })
+
+      this.el.appendChild(el)
     }
   }
 
@@ -172,46 +124,27 @@ export class DomParticleSystem extends DomGameObject {
     super.update(dt)
 
     const ps = this.#particles
-
-    // [성능 최적화] swap-and-pop 패턴으로 O(n) splice 비용 제거
-    let writeIdx = 0
-    for (let readIdx = 0; readIdx < ps.length; readIdx++) {
-      const p = ps[readIdx]
+    for (let i = 0; i < ps.length; i++) {
+      const p = ps[i]
+      const e = p.el
 
       p.age += dt
-
       if (p.age > p.lifespan) {
-        // [성능 최적화] DOM에서 제거 대신 풀로 반환
-        this.#releaseElement(p.el)
-        p.active = false
+        e.remove()
+        ps.splice(i, 1)
+        i--
         continue
       }
 
-      // [성능 최적화] parseFloat 대신 캐시된 값 사용
-      p.x += p.velocityX * dt
-      p.y += p.velocityY * dt
-      p.opacity += p.fadeRate * dt
-
-      setStyle(p.el, { left: `${p.x}px`, top: `${p.y}px`, opacity: `${p.opacity}` })
+      const x = parseFloat(e.style.left) + p.velocityX * dt
+      const y = parseFloat(e.style.top) + p.velocityY * dt
+      const opacity = parseFloat(e.style.opacity) + p.fadeRate * dt
 
-      // 활성 파티클을 앞으로 이동
-      if (writeIdx !== readIdx) {
-        ps[writeIdx] = p
-      }
-      writeIdx++
+      setStyle(e, { left: `${x}px`, top: `${y}px`, opacity: `${opacity}` })
     }
-
-    // 비활성 파티클 제거 (한 번에 배열 크기 조정)
-    ps.length = writeIdx
   }
 
   override remove() {
-    // 풀에 있는 엘리먼트도 정리
-    for (const el of this.#elementPool) {
-      el.remove()
-    }
-    this.#elementPool.length = 0
-
     domTextureLoader.release(this.#textureSrc)
     super.remove()
   }

package/src/node/core/game-object.ts

@@ -2,18 +2,10 @@ import { EventMap } from '@webtaku/event-emitter'
 import { Container as PixiContainer } from 'pixi.js'
 import { TransformableNode, TransformableNodeOptions } from './transformable'
 
-export type GameObjectOptions = {
-  // [성능 최적화] sortableChildren 선택적 활성화
-  // 기본값: useYSort가 true이거나 drawOrder를 사용하는 경우에만 true
-  // 모든 컨테이너에서 sortableChildren을 켜면 정렬 비용이 발생함
-  sortableChildren?: boolean
-} & TransformableNodeOptions
+export type GameObjectOptions = {} & TransformableNodeOptions
 
 export class GameObject<E extends EventMap = {}> extends TransformableNode<PixiContainer, E> {
   constructor(options?: GameObjectOptions) {
-    // [성능 최적화] sortableChildren이 필요한 경우에만 활성화
-    // useYSort 사용 시 또는 명시적으로 요청한 경우에만 정렬 활성화
-    const needsSorting = options?.sortableChildren ?? options?.useYSort ?? false
-    super(new PixiContainer({ sortableChildren: needsSorting }), options ?? {})
+    super(new PixiContainer({ sortableChildren: true }), options ?? {})
   }
 }

package/src/node/core/renderable.ts

@@ -53,15 +53,16 @@ export abstract class RenderableNode<C extends PixiContainer, E extends EventMap
     super.remove()
   }
 
-  // [성능 최적화] 기존 2-pass → 1-pass로 통합
-  // 기존: _updateWorldTransform() + _resetWorldTransformDirty() 를 별도 호출
-  // 개선: 한 번의 순회에서 트랜스폼 업데이트와 dirty 리셋을 동시 처리
   _updateWorldTransform() {
     for (const child of this.children) {
       if (isRenderableNode(child)) child._updateWorldTransform()
     }
+  }
 
-    // [성능 최적화] dirty 리셋을 별도 pass 대신 여기서 바로 처리
+  _resetWorldTransformDirty() {
+    for (const child of this.children) {
+      if (isRenderableNode(child)) child._resetWorldTransformDirty()
+    }
     this.worldTransform.resetDirty()
     this.worldAlpha.resetDirty()
   }

package/src/node/core/transformable.ts

@@ -27,12 +27,6 @@ export abstract class TransformableNode<C extends PixiContainer, E extends Event
   #layer?: string
   #useYSort = false
 
-  // [성능 최적화] useYSort용 이전 y값 캐시 - y가 변할 때만 drawOrder 업데이트
-  #prevY = NaN
-
-  // [성능 최적화] 이전 alpha 캐시 - 변경 시에만 Pixi에 반영
-  #prevAlpha = NaN
-
   constructor(pixiContainer: C, options: TransformableNodeOptions) {
     super(pixiContainer)
 
@@ -72,54 +66,22 @@ export abstract class TransformableNode<C extends PixiContainer, E extends Event
 
     const pc = this._pixiContainer
     const renderer = this.renderer
-    const wt = this.worldTransform
 
     // 레이어 상에 있는 경우, 독립적으로 업데이트
     if (this.#layer && renderer) {
-      // [성능 최적화] dirty 체크 - 값이 변경된 경우에만 Pixi 속성 업데이트
-      // Pixi 내부에서도 dirty 체크를 하지만, 함수 호출 자체를 줄이는 것이 더 효율적
-      if (wt.x.dirty || wt.y.dirty) {
-        pc.position.set(wt.x.v, wt.y.v)
-      }
-      if (wt.scaleX.dirty || wt.scaleY.dirty) {
-        pc.scale.set(wt.scaleX.v, wt.scaleY.v)
-      }
-      if (wt.rotation.dirty) {
-        pc.rotation = wt.rotation.v
-      }
-      if (this.worldAlpha.dirty) {
-        pc.alpha = this.worldAlpha.v
-      }
+      const wt = this.worldTransform
+      pc.position.set(wt.x.v, wt.y.v)
+      pc.scale.set(wt.scaleX.v, wt.scaleY.v)
+      pc.rotation = wt.rotation.v
+      pc.alpha = this.worldAlpha.v
     } else {
       const lt = this.localTransform
-
-      // [성능 최적화] 로컬 트랜스폼도 dirty 체크 적용
-      // DOM 쪽(dom-game-object.ts)과 동일한 패턴
-      if (wt.x.dirty || wt.y.dirty) {
-        pc.position.set(lt.x, lt.y)
-      }
-
-      // [성능 최적화] useYSort: y가 실제로 변경된 경우에만 drawOrder 업데이트
-      // 기존: 매 프레임 zIndex 설정 → 부모 컨테이너 정렬 비용 발생
-      // 개선: y 변경 시에만 zIndex 업데이트
-      if (this.#useYSort && lt.y !== this.#prevY) {
-        this.drawOrder = lt.y
-        this.#prevY = lt.y
-      }
-
-      if (wt.scaleX.dirty || wt.scaleY.dirty) {
-        pc.pivot.set(lt.pivotX, lt.pivotY)
-        pc.scale.set(lt.scaleX, lt.scaleY)
-      }
-      if (wt.rotation.dirty) {
-        pc.rotation = lt.rotation
-      }
-
-      // [성능 최적화] alpha 변경 시에만 업데이트
-      if (this.alpha !== this.#prevAlpha) {
-        pc.alpha = this.alpha
-        this.#prevAlpha = this.alpha
-      }
+      pc.position.set(lt.x, lt.y)
+      if (this.#useYSort) this.drawOrder = lt.y
+      pc.pivot.set(lt.pivotX, lt.pivotY)
+      pc.scale.set(lt.scaleX, lt.scaleY)
+      pc.rotation = lt.rotation
+      pc.alpha = this.alpha
     }
 
     super._updateWorldTransform()

package/src/node/ext/animated-sprite.ts

@@ -22,9 +22,6 @@ export class AnimatedSpriteNode<E extends EventMap = {}> extends GameObject<E &
   #sprite?: PixiAnimatedSprite
   #baseFps = 60
 
-  // [성능 최적화] 이전 worldTimeScale 캐시 - 변경 시에만 animationSpeed 업데이트
-  #prevWorldTimeScale = NaN
-
   constructor(options: AnimatedSpriteNodeOptions) {
     super(options)
     this.#src = options.src
@@ -65,7 +62,6 @@ export class AnimatedSpriteNode<E extends EventMap = {}> extends GameObject<E &
     s.loop = a.loop
     this.#baseFps = a.fps
     s.animationSpeed = (a.fps / 60) * this.worldTimeScale
-    this.#prevWorldTimeScale = this.worldTimeScale
     s.play()
     s.onLoop = () => (this as any).emit('animationend', this.#animation)
     s.onComplete = () => (this as any).emit('animationend', this.#animation)
@@ -105,13 +101,8 @@ export class AnimatedSpriteNode<E extends EventMap = {}> extends GameObject<E &
 
   protected override update(dt: number) {
     super.update(dt)
-
-    // [성능 최적화] worldTimeScale이 변경된 경우에만 animationSpeed 업데이트
-    // 기존: 매 프레임 animationSpeed 재설정
-    // 개선: 캐시된 값과 비교하여 변경 시에만 업데이트
-    if (this.#sprite && this.worldTimeScale !== this.#prevWorldTimeScale) {
+    if (this.#sprite) {
       this.#sprite.animationSpeed = (this.#baseFps / 60) * this.worldTimeScale
-      this.#prevWorldTimeScale = this.worldTimeScale
     }
   }
 

package/src/node/ext/bitmap-text.ts

@@ -18,13 +18,6 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
   #font?: BitmapFont
   #sprites: PixiSprite[] = []
 
-  // [성능 최적화] 글리프 텍스처 캐시 - charCode → PixiTexture 매핑
-  // 동일 폰트에서 같은 문자에 대해 텍스처를 재생성하지 않음
-  #glyphTextureCache = new Map<number, PixiTexture>()
-
-  // [성능 최적화] 스프라이트 풀 - 재사용으로 GC 부담 감소
-  #spritePool: PixiSprite[] = []
-
   constructor(options: BitmapTextNodeOptions) {
     super(options)
     this.#fnt = options.fnt
@@ -33,48 +26,9 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
     this.#load()
   }
 
-  // [성능 최적화] 글리프 텍스처 가져오기 (캐시 활용)
-  #getGlyphTexture(charCode: number): PixiTexture | undefined {
-    if (!this.#font) return undefined
-
-    let texture = this.#glyphTextureCache.get(charCode)
-    if (texture) return texture
-
-    const c = this.#font.chars[charCode]
-    if (!c) return undefined
-
-    const frame = new PixiRectangle(c.x, c.y, c.width, c.height)
-    texture = new PixiTexture({ source: this.#font.texture.source, frame })
-    this.#glyphTextureCache.set(charCode, texture)
-
-    return texture
-  }
-
-  // [성능 최적화] 풀에서 스프라이트 가져오거나 새로 생성
-  #acquireSprite(texture: PixiTexture): PixiSprite {
-    let sprite = this.#spritePool.pop()
-
-    if (sprite) {
-      sprite.texture = texture
-      sprite.visible = true
-    } else {
-      sprite = new PixiSprite({ texture, zIndex: -999999 })
-    }
-
-    return sprite
-  }
-
-  // [성능 최적화] 스프라이트를 풀로 반환
-  #releaseSprite(sprite: PixiSprite) {
-    sprite.visible = false
-    this._pixiContainer.removeChild(sprite)
-    this.#spritePool.push(sprite)
-  }
-
   #updateText() {
-    // [성능 최적화] 기존 스프라이트를 풀로 반환 (destroy 대신)
     for (const sprite of this.#sprites) {
-      this.#releaseSprite(sprite)
+      sprite.destroy()
     }
     this.#sprites = []
 
@@ -96,12 +50,9 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
       const c = this.#font.chars[charCode]
       if (!c) continue
 
-      // [성능 최적화] 캐시된 텍스처 사용
-      const texture = this.#getGlyphTexture(charCode)
-      if (!texture) continue
-
-      // [성능 최적화] 풀에서 스프라이트 재사용
-      const sprite = this.#acquireSprite(texture)
+      const frame = new PixiRectangle(c.x, c.y, c.width, c.height)
+      const texture = new PixiTexture({ source: this.#font.texture.source, frame })
+      const sprite = new PixiSprite({ texture, zIndex: -999999 })
 
       const x0 = xPos + c.xoffset
       const y0 = yPos + c.yoffset
@@ -150,9 +101,6 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
       this.#font = await bitmapFontLoader.load(this.#fnt, this.#src)
     }
 
-    // 폰트가 바뀌면 글리프 캐시 초기화
-    this.#glyphTextureCache.clear()
-
     this.#updateText()
   }
 
@@ -166,8 +114,6 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
   }
 
   set text(text: string | undefined) {
-    // [성능 최적화] 동일 텍스트면 스킵
-    if (this.#text === text) return
     this.#text = text
     this.#updateText()
   }
@@ -177,18 +123,6 @@ export class BitmapTextNode<E extends EventMap = {}> extends GameObject<E> {
   }
 
   override remove() {
-    // 풀에 있는 스프라이트도 정리
-    for (const sprite of this.#spritePool) {
-      sprite.destroy()
-    }
-    this.#spritePool.length = 0
-
-    // 글리프 텍스처 캐시 정리
-    for (const texture of this.#glyphTextureCache.values()) {
-      texture.destroy()
-    }
-    this.#glyphTextureCache.clear()
-
     bitmapFontLoader.release(this.#fnt)
     super.remove()
   }

package/src/node/ext/circle.ts

@@ -14,8 +14,7 @@ export class CircleNode extends TransformableNode<Graphics, EventMap> {
   #stroke?: StrokeInput
 
   constructor(options: CircleNodeOptions) {
-    // [성능 최적화] Graphics는 자식 노드를 가지지 않으므로 sortableChildren 불필요
-    super(new Graphics(), options)
+    super(new Graphics({ sortableChildren: true }), options)
 
     this.#radius = options.radius
     this.#fill = options.fill

package/src/node/ext/particle.ts

@@ -18,18 +18,11 @@ export type ParticleSystemOptions = {
   orientToVelocity: boolean
 
   blendMode?: BLEND_MODES // ex) 'screen', 'multiply'
-
-  // [성능 최적화] 오브젝트 풀 크기 설정 (기본값: 100)
-  // 풀 크기를 늘리면 메모리를 더 사용하지만 GC 스파이크를 줄일 수 있음
-  poolSize?: number
 } & GameObjectOptions
 
 interface Particle {
   sprite: PixiSprite
 
-  // [성능 최적화] 활성 상태 플래그 - 풀링에서 재사용 여부 판단
-  active: boolean
-
   age: number
   lifespan: number
 
@@ -59,10 +52,6 @@ export class ParticleSystem extends GameObject {
   #loadTexturePromise: Promise<void>
   #particles: Particle[] = []
 
-  // [성능 최적화] 오브젝트 풀 - 스프라이트 재사용으로 GC 부담 감소
-  #spritePool: PixiSprite[] = []
-  #poolSize: number
-
   constructor(options: ParticleSystemOptions) {
     super(options)
 
@@ -76,7 +65,6 @@ export class ParticleSystem extends GameObject {
     this.#fadeRate = options.fadeRate
     this.#orientToVelocity = options.orientToVelocity
     this.#blendMode = options.blendMode
-    this.#poolSize = options.poolSize ?? 100
 
     this.#loadTexturePromise = this.#loadTexture()
   }
@@ -90,46 +78,6 @@ export class ParticleSystem extends GameObject {
     }
   }
 
-  // [성능 최적화] 풀에서 스프라이트 가져오거나 새로 생성
-  #acquireSprite(x: number, y: number, scale: number, angle: number): PixiSprite {
-    let sprite = this.#spritePool.pop()
-
-    if (sprite) {
-      // 풀에서 가져온 스프라이트 재설정
-      sprite.x = x
-      sprite.y = y
-      sprite.scale.set(scale, scale)
-      sprite.alpha = this.#startAlpha ?? 1
-      sprite.rotation = this.#orientToVelocity ? angle : 0
-      sprite.visible = true
-    } else {
-      // 풀이 비어있으면 새로 생성
-      sprite = new PixiSprite({
-        x, y,
-        texture: this.#texture,
-        anchor: { x: 0.5, y: 0.5 },
-        scale: { x: scale, y: scale },
-        alpha: this.#startAlpha,
-        blendMode: this.#blendMode,
-        rotation: this.#orientToVelocity ? angle : undefined,
-      })
-      this._pixiContainer.addChild(sprite)
-    }
-
-    return sprite
-  }
-
-  // [성능 최적화] 스프라이트를 풀로 반환 (destroy 대신)
-  #releaseSprite(sprite: PixiSprite) {
-    if (this.#spritePool.length < this.#poolSize) {
-      sprite.visible = false
-      this.#spritePool.push(sprite)
-    } else {
-      // 풀이 가득 차면 destroy
-      sprite.destroy()
-    }
-  }
-
   async burst({ x, y }: { x: number; y: number }) {
     if (!this.#texture) await this.#loadTexturePromise
 
@@ -142,17 +90,26 @@ export class ParticleSystem extends GameObject {
       const velocity = random(this.#velocity.min, this.#velocity.max)
       const scale = random(this.#scale.min, this.#scale.max)
 
-      const sprite = this.#acquireSprite(x, y, scale, angle)
+      const sprite = new PixiSprite({
+        x, y,
+        texture: this.#texture,
+        anchor: { x: 0.5, y: 0.5 },
+        scale: { x: scale, y: scale },
+        alpha: this.#startAlpha,
+        blendMode: this.#blendMode,
+        rotation: this.#orientToVelocity ? angle : undefined,
+      })
 
       this.#particles.push({
         sprite,
-        active: true,
         age: 0,
         lifespan,
         velocityX: velocity * cos,
         velocityY: velocity * sin,
         fadeRate: this.#fadeRate,
       })
+
+      this._pixiContainer.addChild(sprite)
     }
   }
 
@@ -160,46 +117,25 @@ export class ParticleSystem extends GameObject {
     super.update(dt)
 
     const ps = this.#particles
-
-    // [성능 최적화] swap-and-pop 패턴으로 O(n) splice 비용 제거
-    // 기존: splice(i, 1)은 배열 요소를 이동시켜 O(n) 비용 발생
-    // 개선: 마지막 요소와 교체 후 pop()으로 O(1) 제거
-    let writeIdx = 0
-    for (let readIdx = 0; readIdx < ps.length; readIdx++) {
-      const p = ps[readIdx]
+    for (let i = 0; i < ps.length; i++) {
+      const p = ps[i]
       const g = p.sprite
 
       p.age += dt
-
       if (p.age > p.lifespan) {
-        // [성능 최적화] destroy 대신 풀로 반환
-        this.#releaseSprite(g)
-        p.active = false
+        g.destroy({ children: true })
+        ps.splice(i, 1)
+        i--
         continue
       }
 
       g.x += p.velocityX * dt
       g.y += p.velocityY * dt
       g.alpha += p.fadeRate * dt
-
-      // 활성 파티클을 앞으로 이동
-      if (writeIdx !== readIdx) {
-        ps[writeIdx] = p
-      }
-      writeIdx++
     }
-
-    // 비활성 파티클 제거 (한 번에 배열 크기 조정)
-    ps.length = writeIdx
   }
 
   override remove() {
-    // 풀에 있는 스프라이트도 정리
-    for (const sprite of this.#spritePool) {
-      sprite.destroy()
-    }
-    this.#spritePool.length = 0
-
     textureLoader.release(this.#textureSrc)
     super.remove()
   }

package/src/node/ext/rectangle.ts

@@ -16,8 +16,7 @@ export class RectangleNode extends TransformableNode<Graphics, EventMap> {
   #stroke?: StrokeInput
 
   constructor(options: RectangleNodeOptions) {
-    // [성능 최적화] Graphics는 자식 노드를 가지지 않으므로 sortableChildren 불필요
-    super(new Graphics(), options)
+    super(new Graphics({ sortableChildren: true }), options)
 
     this.#width = options.width
     this.#height = options.height

package/src/renderer/camera.ts

@@ -13,18 +13,12 @@ export class Camera extends EventEmitter<{
   get scale() { return this.#scale }
 
   setPosition(x: number, y: number) {
-    // [성능 최적화] 값이 변경된 경우에만 이벤트 emit
-    // 기존: 매번 positionChanged 이벤트 발생 → 불필요한 월드 트랜스폼 업데이트
-    // 개선: 값 비교 후 변경 시에만 emit
-    if (this.#x === x && this.#y === y) return
     this.#x = x
     this.#y = y
     this.emit('positionChanged')
   }
 
   setScale(scale: number) {
-    // [성능 최적화] 값이 변경된 경우에만 이벤트 emit
-    if (this.#scale === scale) return
     this.#scale = scale
     this.emit('scaleChanged')
   }

package/src/renderer/renderer.ts

@@ -162,18 +162,11 @@ export class Renderer extends RenderableNode<PixiContainer, {
   }
 
   #render(dt: number) {
-    // [성능 최적화] 렌더러가 준비되지 않은 경우 불필요한 업데이트 스킵
-    if (!this.#pixiRenderer) return
-
     const scaledDt = dt * this.timeScale
     this.update(scaledDt)
-
-    // [성능 최적화] 2-pass → 1-pass로 통합
-    // 기존: _updateWorldTransform() + _resetWorldTransformDirty() 별도 호출
-    // 개선: _updateWorldTransform() 내부에서 dirty 리셋까지 처리
     this._updateWorldTransform()
-
-    this.#pixiRenderer.render(this._pixiContainer)
+    this._resetWorldTransformDirty()
+    this.#pixiRenderer?.render(this._pixiContainer)
     this.fpsDisplay?.update()
 
     this._isSizeDirty = false