kiwiengine 0.7.0 → 1.0.1

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