//#region src/pipeline/sortLayers.d.ts
/**
 * Named, typed sort layers — the opinionated façade over three.js's
 * `renderOrder` for batching-aware draw ordering.
 *
 * A sortLayer is one of three orthogonal ordering concerns:
 *
 *   - `sprite.sortLayer` — inter-batch order (which batch draws first)
 *   - `sprite.zIndex`    — intra-batch order (instance order within a batch)
 *   - `sprite.layers`    — three's camera-visibility bitmask (NOT a sort key)
 *
 * The name deliberately avoids colliding with three's `Object3D.layers`
 * (plural, bitmask) — same reason Unity 2D calls theirs `SortingLayer`.
 *
 * @example
 * ```typescript
 * import { SortLayers } from 'three-flatland'
 *
 * sprite.sortLayer = SortLayers.ENTITIES  // numeric
 * sprite.sortLayer = 'entities'           // named, type-checked
 * ```
 */
/** Configuration carried by a declared sort layer. */
interface SortLayerConfig {
  /** Numeric order compiled down to three's `renderOrder` on batches. */
  renderOrder: number;
}
/** Marker type for the sort layers the library ships out of the box. */
type BuiltInSortLayer = SortLayerConfig;
/**
 * Typed registry of sort-layer names (TanStack-style augmentation).
 *
 * User code extends this interface to get typed `sprite.sortLayer`
 * assignment and JSX props:
 *
 * ```typescript
 * declare module 'three-flatland' {
 *   interface SortLayerRegistry {
 *     radarBlip: SortLayerConfig
 *   }
 * }
 * flatland.declareSortLayer('radarBlip', { renderOrder: 42 })
 * sprite.sortLayer = 'radarBlip'  // ✓ typed
 * sprite.sortLayer = 'radarBlop'  // ✗ TS error
 * ```
 */
interface SortLayerRegistry {
  /** Sprites that never declare a sortLayer land here (renderOrder 0). */
  default: BuiltInSortLayer;
  /** Background elements (sky, distant scenery) */
  background: BuiltInSortLayer;
  /** Ground/floor tiles */
  ground: BuiltInSortLayer;
  /** Shadow sprites (render below entities) */
  shadows: BuiltInSortLayer;
  /** Game entities (players, enemies, items) */
  entities: BuiltInSortLayer;
  /** Visual effects (particles, spell effects) */
  effects: BuiltInSortLayer;
  /** Foreground elements (overlays, weather) */
  foreground: BuiltInSortLayer;
  /** UI elements (always on top) */
  ui: BuiltInSortLayer;
}
/** A registered sort-layer name (augmentable via `SortLayerRegistry`). */
type SortLayerName = Extract<keyof SortLayerRegistry, string>;
/**
 * Anything assignable to `sprite.sortLayer`: a registered name (typed,
 * autocompleted) or a raw numeric order (escape hatch for dynamic
 * layering schemes).
 */
type SortLayerValue = SortLayerName | (number & {});
/**
 * Default numeric sort layers for 2D scenes.
 *
 * These provide semantic values for common 2D game scenarios. Each maps
 * 1:1 to a named entry in {@link SortLayerRegistry} (`SortLayers.ENTITIES`
 * === `'entities'`'s renderOrder).
 */
declare const SortLayers: {
  /** Background elements (sky, distant scenery) */
  readonly BACKGROUND: 0;
  /** Ground/floor tiles */
  readonly GROUND: 1;
  /** Shadow sprites (render below entities) */
  readonly SHADOWS: 2;
  /** Game entities (players, enemies, items) */
  readonly ENTITIES: 3;
  /** Visual effects (particles, spell effects) */
  readonly EFFECTS: 4;
  /** Foreground elements (overlays, weather) */
  readonly FOREGROUND: 5;
  /** UI elements (always on top) */
  readonly UI: 6;
};
/**
 * Declare (or redeclare) a named sort layer.
 *
 * Pair with a `SortLayerRegistry` interface augmentation for typed use.
 */
declare function declareSortLayer(name: SortLayerName, config: SortLayerConfig): SortLayerConfig;
/** Look up a declared sort layer's config. */
declare function getSortLayer(name: SortLayerName): SortLayerConfig | undefined;
/**
 * Resolve a sortLayer value (name or number) to its numeric order.
 *
 * Unknown names resolve to `'default'` (0) with a dev warning — a typo'd
 * name is already a TS error, so this only fires for untyped callers.
 */
declare function resolveSortLayer(value: SortLayerValue): number;
/**
 * Encode a sort key from sortLayer, material ID, and zIndex.
 *
 * Format: (sortLayer & 0xFF) << 24 | (batchId & 0xFFF) << 12 | (zIndex & 0xFFF)
 *
 * This allows efficient sorting with a single numeric comparison.
 *
 * @param sortLayer - Sort layer value (0-255)
 * @param batchId - Material ID (0-4095)
 * @param zIndex - Z-index within layer (0-4095, or negative values mapped to positive range)
 * @returns Encoded sort key
 */
declare function encodeSortKey(sortLayer: number, batchId: number, zIndex: number): number;
/**
 * Decode a sort key back to its components.
 *
 * @param sortKey - Encoded sort key
 * @returns Object with sortLayer, batchId, and zIndex
 */
declare function decodeSortKey(sortKey: number): {
  sortLayer: number;
  batchId: number;
  zIndex: number;
};
//#endregion
export { BuiltInSortLayer, SortLayerConfig, SortLayerName, SortLayerRegistry, SortLayerValue, SortLayers, declareSortLayer, decodeSortKey, encodeSortKey, getSortLayer, resolveSortLayer };
//# sourceMappingURL=sortLayers.d.ts.map