import * as BABYLON from '@babylonjs/core';
import { RawTexture2DArray, Scene, Camera, Mesh, Ray, Vector3, PickingInfo, Effect, Skeleton } from '@babylonjs/core';
import { b as Shado, a as ShadoStructSchema, I as InitializeConfig, A as ASCExtension } from './types-oCidOW3T.js';
import { BABYLON as BABYLON$1 } from './babylon/index.js';
import { a as DQClipInfo, V as VATBuilder, D as DQBuildOpts, S as SerializedDQVAT } from './VATBuilder-DkNitwpU.js';

declare class NameplateData extends Shado {
    static schema: ShadoStructSchema;
    private _pool;
    private _lut?;
    private _streams?;
    constructor(engine: any, fontAsset: any);
    addNamesToPool(names: string[]): number[];
    addName(name: string): number;
    nameCount(): number;
    poolGet(i: number): string;
    rebuildStreams(children: Array<{
        nameIndex: number;
    }>): void;
    glyphCount(): number;
}

declare class ShadoActor extends Shado {
    translation: Float32Array;
    color: Float32Array;
    visibleIndex: number;
    nameIndex: number;
    nameWorldPerEM: number;
    nameLiftWorld: number;
    nameplateColor: Float32Array;
    animationBuffer: Float32Array;
    visibleFlag: number;
    padding1: number;
    padding2: number;
    padding3: number;
    private readonly _worldPerEM;
    private readonly _yLiftWorld;
    constructor(engine: any);
    initialize(): void;
    playRandomAnimation(animationRanges: DQClipInfo[]): void;
    private _rand;
    private _randColor;
    private _randomTranslation;
}
declare class TestClass extends ShadoActor {
    testValue: Float32Array;
    testMethod(): void;
}

type RectUV = {
    u0: number;
    v0: number;
    u1: number;
    v1: number;
};
type PixelRect = {
    x: number;
    y: number;
    w: number;
    h: number;
};
type EntryInfo = {
    layer: number;
    rect: RectUV;
    px?: PixelRect;
};
type ArrayAtlas = {
    texture: RawTexture2DArray;
    layerCount: number;
    pageSize: number;
    entries: Record<string, EntryInfo>;
};

declare const SHADO_ENTITY_VISIBLE: number;
declare const SHADO_ENTITY_SELECTED: number;
declare const SHADO_ENTITY_HIGHLIGHTED: number;
declare const SHADO_ENTITY2D_MESH_INDEX_MOTION_COMPONENT = 3;
type ShadoUvRect = readonly [number, number, number, number];
type ShadoRgba = readonly [number, number, number, number];
interface ShadoEntity2DInput {
    id?: string;
    x: number;
    y: number;
    z?: number;
    width: number;
    depth?: number;
    height?: number;
    rotationRad?: number;
    rotationDeg?: number;
    opacity?: number;
    visible?: boolean;
    selected?: boolean;
    highlighted?: boolean;
    textureLayer?: number;
    uvRect?: ShadoUvRect;
    color?: ShadoRgba;
    sortKey?: number;
    entityIdHash?: number;
    transitionSpeed?: number;
    meshIndex?: number;
    meshTypeId?: number;
}
interface ShadoEntity2DDestinationInput {
    x: number;
    y: number;
    z?: number;
    width?: number;
    depth?: number;
    transition?: boolean;
    transitionSpeed?: number;
}
declare function hashEntityId(id: string | undefined): number;
declare function entityFlags(input: ShadoEntity2DInput): number;
declare class ShadoEntity2D extends Shado {
    positionSize: Float32Array;
    render: Float32Array;
    destinationSize: Float32Array;
    motion: Float32Array;
    uvRect: Float32Array;
    color: Float32Array;
    renderState: Float32Array;
    setFrom(input: ShadoEntity2DInput): this;
    setDestination(input: ShadoEntity2DDestinationInput): this;
    get isVisible(): boolean;
    setVisible(visible: boolean): void;
}

type ShadoAtlasRect = {
    u0: number;
    v0: number;
    u1: number;
    v1: number;
};
type ShadoAtlasEntry = {
    layer: number;
    rect: ShadoAtlasRect;
};
interface ShadoTextureAtlas {
    texture: RawTexture2DArray;
    entries: Record<string, ShadoAtlasEntry>;
    get(key: string): ShadoAtlasEntry;
    dispose(): void;
}
type ShadoAtlasColor = readonly [number, number, number, number];
declare function createSolidColorAtlas(scene: Scene, colors: Record<string, ShadoAtlasColor>, size?: number): ShadoTextureAtlas;

interface ShadoDynamicEntityInput extends Omit<ShadoEntity2DInput, 'textureLayer' | 'uvRect'> {
    id: string;
    textureKey?: string;
}
interface ShadoDynamicEntityDestinationInput extends ShadoEntity2DDestinationInput {
    id: string;
}
interface ShadoDynamicEntityExpirationInput {
    id: string;
    removeAfterFrame?: number;
    removeAfterSimulationTime?: number;
}
type ShadoDynamicEntityGeometryMode = 'box' | 'plane' | 'spriteSlab' | 'mesh';
declare class ShadoDynamicEntityContainer extends Shado {
    drawCount: number;
    entityCount: number;
    flags: number;
    padding0: number;
    drawIds: Float32Array;
    private readonly records;
    private readonly indexById;
    private readonly movingIndices;
    private atlas?;
    private geometryMode;
    private billboard;
    private reducer?;
    private reducerArenaSignature;
    private deltaScratchPtr;
    private deltaScratchByteCapacity;
    static initialize(engine: any, config?: InitializeConfig): Promise<boolean>;
    constructor(engine: any, atlas?: ShadoTextureAtlas);
    setAtlas(atlas: ShadoTextureAtlas): void;
    configureRenderMode(options: {
        geometry?: ShadoDynamicEntityGeometryMode;
        billboard?: boolean;
    }): void;
    getShaderNamesForRenderMode(options?: {
        geometry?: ShadoDynamicEntityGeometryMode;
        billboard?: boolean;
    }, rewrite?: boolean): {
        vertex: string;
        fragment: string;
    };
    reserve(count: number): void;
    clearEntities(): void;
    upsert(input: ShadoDynamicEntityInput): number;
    upsertMany(inputs: readonly ShadoDynamicEntityInput[], syncDrawList?: boolean): void;
    add(input: ShadoDynamicEntityInput): number;
    remove(id: string): boolean;
    setEntity(index: number, input: ShadoDynamicEntityInput): void;
    setEntityDestination(input: ShadoDynamicEntityDestinationInput): boolean;
    setEntityDestinations(inputs: readonly ShadoDynamicEntityDestinationInput[]): number;
    setEntityMeshIndex(id: string, meshIndex: number): boolean;
    setEntityMeshIndices(meshIndexById: ReadonlyMap<string, number>, defaultMeshIndex?: number): number;
    applyReducerDeltaBytes(deltaBytes: Uint8Array): number;
    tickTransitions(deltaSeconds: number): number;
    setEntityExpiration(input: ShadoDynamicEntityExpirationInput): boolean;
    setEntityExpirations(inputs: readonly ShadoDynamicEntityExpirationInput[]): number;
    sweepExpired(frameId: number, simulationTime: number): number;
    getEntity(index: number): ShadoEntity2D | undefined;
    getEntityIndex(id: string): number | undefined;
    get ids(): readonly string[];
    syncDrawList(options?: {
        sort?: boolean;
    }): void;
    private writeEntity;
    private ensureSharedReducer;
    private applySharedReducerDelta;
    private encodeSharedReducerDelta;
    private destinationRecord;
    private generateGLSLPairForRenderMode;
    generateGLSLPair(): {
        vs: string;
        fs: string;
    };
}

type ShadoPickingSchedule = 'microtask' | 'next-frame';
interface ShadoAsyncPickingBaseOptions<TResult> {
    enabled?: boolean;
    button?: number;
    camera?: Camera;
    includeInvisible?: boolean;
    schedule?: ShadoPickingSchedule;
    pointerEventTypes?: number;
    onPick?: (result: TResult, event: PointerEvent) => void | Promise<void>;
    onMiss?: (event: PointerEvent) => void | Promise<void>;
}
interface ShadoInstancePickResult<T extends ShadoActor = ShadoActor> {
    kind: 'instance';
    engine: 'webgpu' | 'webgl';
    source: 'cpu-ray';
    index: number;
    instance: T;
    mesh: Mesh;
    ray: Ray;
    distance: number;
    pickedPoint: Vector3;
    pickingInfo: PickingInfo;
}
interface ShadoDynamicEntityPickResult {
    kind: 'dynamic-entity';
    engine: 'webgpu' | 'webgl';
    source: 'cpu-ray';
    id: string | undefined;
    index: number;
    entity: ShadoEntity2D;
    mesh: Mesh;
    ray: Ray;
    distance: number;
    pickedPoint: Vector3;
    pickingInfo: PickingInfo;
}
interface ShadoInstanceAsyncPickingOptions<T extends ShadoActor = ShadoActor> extends ShadoAsyncPickingBaseOptions<ShadoInstancePickResult<T>> {
    radius?: number;
    predicate?: (instance: T, index: number) => boolean;
}
interface ShadoDynamicEntityAsyncPickingOptions extends ShadoAsyncPickingBaseOptions<ShadoDynamicEntityPickResult> {
    padding?: number;
    predicate?: (entity: ShadoEntity2D, index: number, id: string | undefined) => boolean;
}
type ShadoPickingHandle = {
    dispose(): void;
};
declare function normalizePickingOptions<T extends ShadoAsyncPickingBaseOptions<any>>(options: boolean | T | undefined): T | undefined;
declare function pickShadoInstanceAtPointer<T extends ShadoActor>(scene: Scene, mesh: Mesh, container: ShadoInstanceContainer<T>, pointerX: number, pointerY: number, options?: ShadoInstanceAsyncPickingOptions<T>): Promise<ShadoInstancePickResult<T> | null>;
declare function pickShadoInstanceWithRay<T extends ShadoActor>(mesh: Mesh, container: ShadoInstanceContainer<T>, ray: Ray, options?: ShadoInstanceAsyncPickingOptions<T>): ShadoInstancePickResult<T> | null;
declare function pickShadoDynamicEntityAtPointer(scene: Scene, mesh: Mesh, container: ShadoDynamicEntityContainer, pointerX: number, pointerY: number, options?: ShadoDynamicEntityAsyncPickingOptions): Promise<ShadoDynamicEntityPickResult | null>;
declare function pickShadoDynamicEntityWithRay(mesh: Mesh, container: ShadoDynamicEntityContainer, ray: Ray, options?: ShadoDynamicEntityAsyncPickingOptions): ShadoDynamicEntityPickResult | null;
declare function installShadoInstanceClickPicking<T extends ShadoActor>(scene: Scene, mesh: Mesh, container: ShadoInstanceContainer<T>, options: ShadoInstanceAsyncPickingOptions<T>): ShadoPickingHandle;
declare function installShadoDynamicEntityClickPicking(scene: Scene, mesh: Mesh, container: ShadoDynamicEntityContainer, options: ShadoDynamicEntityAsyncPickingOptions): ShadoPickingHandle;

interface ShadoMaterialOptions<TActor extends ShadoActor = ShadoActor> {
    defines?: string[];
    logOnCompile?: boolean;
    picking?: boolean | ShadoInstanceAsyncPickingOptions<TActor>;
    useVat?: boolean;
}
declare class ShadoMaterial<T extends Shado> extends BABYLON$1.ShaderMaterial {
    private _timeSec;
    private _timeScale;
    private _paused;
    private shadoScene;
    private shadoMesh;
    private shadoSource;
    private _pickingHandle?;
    private _effect;
    private _vat?;
    get effect(): Effect | null;
    set effect(e: Effect | null);
    set vatDQ(v: VATBuilder | undefined);
    get vatDQ(): VATBuilder | undefined;
    constructor(scene: Scene, mesh: Mesh, atlas: ArrayAtlas, shado: T, opts?: ShadoMaterialOptions<any>);
    setPaused(p: boolean): void;
    setTimeScale(s: number): void;
    setTimeSeconds(t: number): void;
    setAsyncPicking<TActor extends ShadoActor>(options: boolean | ShadoInstanceAsyncPickingOptions<TActor>): void;
    pickAsync<TActor extends ShadoActor = ShadoActor>(pointerX?: number, pointerY?: number, options?: ShadoInstanceAsyncPickingOptions<TActor>): Promise<ShadoInstancePickResult<TActor> | null>;
    pickWithRay<TActor extends ShadoActor = ShadoActor>(ray: Ray, options?: ShadoInstanceAsyncPickingOptions<TActor>): ShadoInstancePickResult<TActor> | null;
}

type ShadoInstanceContainerOptions = {
    vat?: 'auto' | 'bake' | 'none';
    animationRanges?: Array<{
        from: number;
        to: number;
    }>;
    migrateTextures?: 'share' | 'move' | 'clone' | 'none';
    replaceMaterial?: boolean;
    disposeOriginalMaterial?: boolean;
    defines?: string[];
    logOnCompile?: boolean;
    merge?: boolean;
    vatOptions?: DQBuildOpts;
    prebakedVat?: SerializedDQVAT;
    picking?: boolean | ShadoInstanceAsyncPickingOptions<any>;
};
type InstanceNameSource = readonly string[] | ((index: number) => string);
declare class ShadoInstanceContainer<T extends ShadoActor> extends Shado {
    visibleCount: number;
    instancesPtr: number;
    instancesCount: number;
    cameraFrustum: Float32Array;
    private static _instanceName;
    instances: T[];
    private _clipRanges;
    private _clipIndexByName;
    private _clipDurations;
    private _bindings;
    private _children;
    private _useVatMaterial;
    vat: VATBuilder | undefined;
    get children(): T[];
    get instanceCount(): number;
    getVisibleCount(): number;
    set nameplates(nameplates: NameplateData);
    private _nameplates;
    static initialize(engine: any, config?: InitializeConfig): Promise<boolean>;
    constructor(engine: any);
    dispose(): void;
    getClipId(name: string): number | undefined;
    getClipDurations(): number[];
    setInstanceClip(i: number, clipNameOrId: string | number, speed?: number, phase?: number): void;
    attachMeshes(scene: Scene, meshes: Mesh[], skeleton: Skeleton | null | undefined, opts?: ShadoInstanceContainerOptions): Promise<ShadoMaterial<any>>;
    detachMesh(mesh: Mesh): void;
    static ascExtension: ASCExtension;
    updateFrustumFromCamera(camera: Camera): void;
    frustumCull(camera: Camera, baseRadius: number, maxDistance?: number): void;
    frustumCullCPU(camera: Camera, baseRadius: number, maxDistance?: number): void;
    getClipRanges(): Map<string, number>;
    setChildName(childIndex: number, name: string): void;
    addNamesToPool(names: string[]): number[];
    addInstance(suppressRebuild?: boolean, name?: string): T;
    addInstances(n: number, names?: InstanceNameSource): T[];
    removeRandomInstance(): void;
    generateGLSLPair(): {
        vs: string;
        fs: string;
    };
    generateWGSLPair(): {
        vs: string;
        fs: string;
    };
    shuffleInstances(animationRanges: any[]): void;
}

type MSDFNameplateFontAsset = {
    textures: BABYLON.BaseTexture[];
    _font?: {
        common?: {
            scaleW?: number;
            scaleH?: number;
        };
        distanceField?: {
            distanceRange?: number;
        };
    };
};
type MSDFNameplateLayerOptions = {
    debug?: boolean;
    debugMode?: 'none' | 'solid' | 'atlas';
    debugColor?: [number, number, number, number];
    alphaCutoff?: number;
    distanceRange?: number;
    /**
     * Whether MSDF nameplates should be depth-tested against the 3D scene.
     * Defaults to true so actors occlude labels while labels still draw after opaque geometry.
     */
    depthTest?: boolean;
    meshName?: string;
    renderingGroupId?: number;
    thickness?: number;
};
type ShadoBufferOwner = {
    commit(): void;
    bind(effect: BABYLON.Effect): void;
    bindMaterial?(material: BABYLON.ShaderMaterial): void;
    commitAndBind(effect: BABYLON.Effect): void;
    getSchema(): {
        name: string;
        fields?: ReadonlyArray<{
            name: string;
        }>;
        structArrays?: Record<string, {
            schema: {
                name: string;
            };
        }>;
    };
};
type MSDFTextShaderOptions = {
    shaderName?: string;
    actorStructName?: string;
    containerStructName?: string;
    nameplateStructName?: string;
    useActorBillboardFlag?: boolean;
};
declare const MSDF_TEXT_VERTEX_GLSL_TEMPLATE = "\nprecision highp float;\n\nattribute vec2 corner;\n\nuniform mat4 worldViewProjection;\nuniform mat4 view;\nuniform float uThickness;\n\n#include<ShadoActor>\n#include<ShadoActorOffsets>\n#include<ShadoInstanceContainerStorage>\n#include<NameplateDataStorage>\n\nvarying vec2 vUV;\nvarying float vThickness;\nvarying vec4 vNameColor;\n\nvec3 shadoMsdfCamRight() { return vec3(view[0][0], view[1][0], view[2][0]); }\nvec3 shadoMsdfCamUp() { return vec3(view[0][1], view[1][1], view[2][1]); }\n\nvoid main() {\n  int glyphIndex = gl_InstanceID;\n  if (glyphIndex < 0 || glyphIndex >= NameplateData_glyphGid_count()) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    vNameColor = vec4(0.0);\n    vUV = vec2(0.0);\n    vThickness = 0.0;\n    return;\n  }\n\n  int gid = int(NameplateData_glyphGid_get(glyphIndex));\n  vec2 ofsEM = NameplateData_glyphOfs2_get(glyphIndex);\n  int owner = int(NameplateData_glyphOwner_get(glyphIndex));\n  if (gid < 0 || gid >= NameplateData_glyphUv4_count() || owner < 0 || owner >= uShadoInstanceContainer_instancesCount) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    vNameColor = vec4(0.0);\n    vUV = vec2(0.0);\n    vThickness = 0.0;\n    return;\n  }\n\n  int ownerBase = uShadoInstanceContainer_instancesBase + owner * uShadoInstanceContainer_instancesStride;\n  int ownerVisible = int(ShadoInstanceContainer_fetch(ownerBase + ShadoActor_visibleFlag_OFF));\n  if (ownerVisible == 0) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    vNameColor = vec4(0.0);\n    vUV = vec2(0.0);\n    vThickness = 0.0;\n    return;\n  }\n\n  vec4 translation = ShadoInstanceContainer_fetch4(ownerBase + ShadoActor_translation_OFF);\n  float worldPerEM = ShadoInstanceContainer_fetch(ownerBase + ShadoActor_nameWorldPerEM_OFF);\n  float nameLiftWorld = ShadoInstanceContainer_fetch(ownerBase + ShadoActor_nameLiftWorld_OFF);\n  /*SHADO_MSDF_BILLBOARD_FLAG_GLSL*/\n  vNameColor = ShadoInstanceContainer_fetch4(ownerBase + ShadoActor_nameplateColor_OFF);\n\n  vec4 planeEM = NameplateData_glyphPlane4_get(gid);\n  vec4 uv = NameplateData_glyphUv4_get(gid);\n\n  bool invalid =\n    abs(translation.x) > 10000.0 || abs(translation.y) > 10000.0 || abs(translation.z) > 10000.0 ||\n    translation.w <= 0.0 || translation.w > 1000.0 ||\n    worldPerEM <= 0.0 || worldPerEM > 10.0 ||\n    abs(nameLiftWorld) > 1000.0 ||\n    abs(ofsEM.x) > 128.0 || abs(ofsEM.y) > 128.0 ||\n    abs(planeEM.x) > 8.0 || abs(planeEM.y) > 8.0 || abs(planeEM.z) > 8.0 || abs(planeEM.w) > 8.0 ||\n    uv.z <= 0.0 || uv.w <= 0.0 || uv.x < -0.001 || uv.y < -0.001 || uv.x + uv.z > 1.001 || uv.y + uv.w > 1.001 ||\n    vNameColor.a <= 0.0;\n  if (invalid) {\n    gl_Position = vec4(2.0, 2.0, 0.0, 1.0);\n    vNameColor = vec4(0.0);\n    vUV = vec2(0.0);\n    vThickness = 0.0;\n    return;\n  }\n\n  float worldScale = clamp(worldPerEM * translation.w, 0.001, 2.0);\n  vec2 planePos = mix(planeEM.xy, planeEM.zw, corner) * worldScale;\n  float billboardMix = step(0.5, billboardFlag);\n  vec3 labelRight = mix(vec3(1.0, 0.0, 0.0), shadoMsdfCamRight(), billboardMix);\n  vec3 labelUp = mix(vec3(0.0, 0.0, 1.0), shadoMsdfCamUp(), billboardMix);\n\n  vec3 worldPos = translation.xyz\n    + labelRight * (ofsEM.x * worldScale + planePos.x)\n    + labelUp * (translation.w + nameLiftWorld * translation.w + planePos.y + ofsEM.y * worldScale);\n\n  vUV = vec2(uv.x + corner.x * uv.z, uv.y + (1.0 - corner.y) * uv.w);\n  vThickness = uThickness;\n  gl_Position = worldViewProjection * vec4(worldPos, 1.0);\n}\n";
declare const MSDF_TEXT_FRAGMENT_GLSL_TEMPLATE = "\nprecision highp float;\n\nuniform sampler2D uFontAtlas;\nuniform vec2 uFontAtlasSize;\nuniform float uDistanceRange;\nuniform float uAlphaCutoff;\nuniform int uDebugMode;\nuniform vec4 uDebugColor;\n\nvarying vec2 vUV;\nvarying float vThickness;\nvarying vec4 vNameColor;\n\nfloat shadoMsdfMedian(float r, float g, float b) {\n  return max(min(r, g), min(max(r, g), b));\n}\n\nvoid main() {\n  if (uDebugMode == 1) {\n    gl_FragColor = vec4(uDebugColor.rgb, uDebugColor.a);\n    return;\n  }\n\n  vec4 atlasSample = texture2D(uFontAtlas, vUV);\n  vec3 msdf = atlasSample.rgb;\n  if (uDebugMode == 2) {\n    gl_FragColor = vec4(msdf, 1.0);\n    return;\n  }\n\n  float sd = shadoMsdfMedian(msdf.r, msdf.g, msdf.b) - 0.5 + vThickness;\n  float alpha = clamp(sd / max(fwidth(sd), 0.0001) + 0.5, 0.0, 1.0) * atlasSample.a;\n  if (alpha <= uAlphaCutoff) discard;\n  gl_FragColor = vec4(vNameColor.rgb, alpha * vNameColor.a);\n}\n";
declare const MSDF_TEXT_VERTEX_WGSL_TEMPLATE = "\nattribute position : vec3f;\nattribute corner : vec2f;\nvarying vUV : vec2f;\nvarying vThickness : f32;\nvarying vNameColor : vec4f;\nuniform view: mat4x4f;\nuniform worldViewProjection: mat4x4f;\n\n#include<sceneUboDeclaration>\n#include<ShadoActor>\n#include<ShadoActorOffsets>\n#include<ShadoInstanceContainerStorage>\n#include<NameplateDataStorage>\n\nfn shadoMsdfCamRight(view: mat4x4f) -> vec3f { return vec3f(view[0].x, view[1].x, view[2].x); }\nfn shadoMsdfCamUp(view: mat4x4f) -> vec3f { return vec3f(view[0].y, view[1].y, view[2].y); }\n\n@vertex\nfn main(input: VertexInputs) -> FragmentInputs {\n  let glyphIndex = i32(vertexInputs.instanceIndex);\n  if (glyphIndex < 0 || glyphIndex >= NameplateData_glyphGid_count()) {\n    vertexOutputs.position = vec4f(2.0, 2.0, 0.0, 1.0);\n    vertexOutputs.vNameColor = vec4f(0.0);\n    vertexOutputs.vUV = vec2f(0.0);\n    vertexOutputs.vThickness = 0.0;\n    return vertexOutputs;\n  }\n\n  let gid = i32(NameplateData_glyphGid_get(glyphIndex));\n  let ofsEM = NameplateData_glyphOfs2_get(glyphIndex);\n  let owner = i32(NameplateData_glyphOwner_get(glyphIndex));\n  if (gid < 0 || gid >= NameplateData_glyphUv4_count() || owner < 0 || owner >= uShadoInstanceContainer_instancesCount()) {\n    vertexOutputs.position = vec4f(2.0, 2.0, 0.0, 1.0);\n    vertexOutputs.vNameColor = vec4f(0.0);\n    vertexOutputs.vUV = vec2f(0.0);\n    vertexOutputs.vThickness = 0.0;\n    return vertexOutputs;\n  }\n\n  let ownerBase = uShadoInstanceContainer_instancesBase() + owner * uShadoInstanceContainer_instancesStride();\n  let ownerVisible = i32(ShadoInstanceContainer_fetch(ownerBase + ShadoActor_visibleFlag_OFF));\n  if (ownerVisible == 0) {\n    vertexOutputs.position = vec4f(2.0, 2.0, 0.0, 1.0);\n    vertexOutputs.vNameColor = vec4f(0.0);\n    vertexOutputs.vUV = vec2f(0.0);\n    vertexOutputs.vThickness = 0.0;\n    return vertexOutputs;\n  }\n\n  let translation = ShadoInstanceContainer_fetch4(ownerBase + ShadoActor_translation_OFF);\n  let worldPerEM = ShadoInstanceContainer_fetch(ownerBase + ShadoActor_nameWorldPerEM_OFF);\n  let nameLiftWorld = ShadoInstanceContainer_fetch(ownerBase + ShadoActor_nameLiftWorld_OFF);\n  /*SHADO_MSDF_BILLBOARD_FLAG_WGSL*/\n  vertexOutputs.vNameColor = ShadoInstanceContainer_fetch4(ownerBase + ShadoActor_nameplateColor_OFF);\n\n  let planeEM = NameplateData_glyphPlane4_get(gid);\n  let uv = NameplateData_glyphUv4_get(gid);\n\n  if (\n    abs(translation.x) > 10000.0 || abs(translation.y) > 10000.0 || abs(translation.z) > 10000.0 ||\n    translation.w <= 0.0 || translation.w > 1000.0 ||\n    worldPerEM <= 0.0 || worldPerEM > 10.0 ||\n    abs(nameLiftWorld) > 1000.0 ||\n    abs(ofsEM.x) > 128.0 || abs(ofsEM.y) > 128.0 ||\n    abs(planeEM.x) > 8.0 || abs(planeEM.y) > 8.0 || abs(planeEM.z) > 8.0 || abs(planeEM.w) > 8.0 ||\n    uv.z <= 0.0 || uv.w <= 0.0 || uv.x < -0.001 || uv.y < -0.001 || uv.x + uv.z > 1.001 || uv.y + uv.w > 1.001 ||\n    vertexOutputs.vNameColor.a <= 0.0\n  ) {\n    vertexOutputs.position = vec4f(2.0, 2.0, 0.0, 1.0);\n    vertexOutputs.vNameColor = vec4f(0.0);\n    vertexOutputs.vUV = vec2f(0.0);\n    vertexOutputs.vThickness = 0.0;\n    return vertexOutputs;\n  }\n\n  let worldScale = clamp(worldPerEM * translation.w, 0.001, 2.0);\n  let planePos = mix(planeEM.xy, planeEM.zw, vertexInputs.corner) * worldScale;\n  let billboardMix = step(0.5, billboardFlag);\n  let labelRight = mix(vec3f(1.0, 0.0, 0.0), shadoMsdfCamRight(uniforms.view), billboardMix);\n  let labelUp = mix(vec3f(0.0, 0.0, 1.0), shadoMsdfCamUp(uniforms.view), billboardMix);\n\n  let worldPos = translation.xyz\n    + labelRight * (ofsEM.x * worldScale + planePos.x)\n    + labelUp * (translation.w + nameLiftWorld * translation.w + planePos.y + ofsEM.y * worldScale);\n\n  vertexOutputs.vUV = vec2f(uv.x + vertexInputs.corner.x * uv.z, uv.y + (1.0 - vertexInputs.corner.y) * uv.w);\n  vertexOutputs.vThickness = 0.0;\n  vertexOutputs.position = uniforms.worldViewProjection * vec4f(worldPos, 1.0);\n}\n";
declare const MSDF_TEXT_FRAGMENT_WGSL_TEMPLATE = "\nvar uFontAtlasSampler : sampler;\nvar uFontAtlas : texture_2d<f32>;\nuniform uFontAtlasSize: vec2f;\nuniform uDistanceRange: f32;\nuniform uAlphaCutoff: f32;\nuniform uDebugMode: i32;\nuniform uDebugColor: vec4f;\n\nfn shadoMsdfMedian(a: f32, b: f32, c: f32) -> f32 {\n  return max(min(a, b), min(max(a, b), c));\n}\n\n@fragment\nfn main(input: FragmentInputs) -> FragmentOutputs {\n  if (uniforms.uDebugMode == 1) {\n    fragmentOutputs.color = uniforms.uDebugColor;\n    return fragmentOutputs;\n  }\n\n  let atlasSample = textureSample(uFontAtlas, uFontAtlasSampler, fragmentInputs.vUV);\n  let msdf = atlasSample.rgb;\n  if (uniforms.uDebugMode == 2) {\n    fragmentOutputs.color = vec4f(msdf, 1.0);\n    return fragmentOutputs;\n  }\n\n  let sd = shadoMsdfMedian(msdf.r, msdf.g, msdf.b) - 0.5 + fragmentInputs.vThickness;\n  let alpha = clamp(sd / max(fwidth(sd), 0.0001) + 0.5, 0.0, 1.0) * atlasSample.a;\n  if (alpha <= uniforms.uAlphaCutoff) { discard; }\n  fragmentOutputs.color = vec4f(fragmentInputs.vNameColor.rgb, alpha * fragmentInputs.vNameColor.a);\n}\n";
declare const MSDF_TEXT_VERTEX_GLSL: string;
declare const MSDF_TEXT_FRAGMENT_GLSL = "\nprecision highp float;\n\nuniform sampler2D uFontAtlas;\nuniform vec2 uFontAtlasSize;\nuniform float uDistanceRange;\nuniform float uAlphaCutoff;\nuniform int uDebugMode;\nuniform vec4 uDebugColor;\n\nvarying vec2 vUV;\nvarying float vThickness;\nvarying vec4 vNameColor;\n\nfloat shadoMsdfMedian(float r, float g, float b) {\n  return max(min(r, g), min(max(r, g), b));\n}\n\nvoid main() {\n  if (uDebugMode == 1) {\n    gl_FragColor = vec4(uDebugColor.rgb, uDebugColor.a);\n    return;\n  }\n\n  vec4 atlasSample = texture2D(uFontAtlas, vUV);\n  vec3 msdf = atlasSample.rgb;\n  if (uDebugMode == 2) {\n    gl_FragColor = vec4(msdf, 1.0);\n    return;\n  }\n\n  float sd = shadoMsdfMedian(msdf.r, msdf.g, msdf.b) - 0.5 + vThickness;\n  float alpha = clamp(sd / max(fwidth(sd), 0.0001) + 0.5, 0.0, 1.0) * atlasSample.a;\n  if (alpha <= uAlphaCutoff) discard;\n  gl_FragColor = vec4(vNameColor.rgb, alpha * vNameColor.a);\n}\n";
declare const MSDF_TEXT_VERTEX_WGSL: string;
declare const MSDF_TEXT_FRAGMENT_WGSL = "\nvar uFontAtlasSampler : sampler;\nvar uFontAtlas : texture_2d<f32>;\nuniform uFontAtlasSize: vec2f;\nuniform uDistanceRange: f32;\nuniform uAlphaCutoff: f32;\nuniform uDebugMode: i32;\nuniform uDebugColor: vec4f;\n\nfn shadoMsdfMedian(a: f32, b: f32, c: f32) -> f32 {\n  return max(min(a, b), min(max(a, b), c));\n}\n\n@fragment\nfn main(input: FragmentInputs) -> FragmentOutputs {\n  if (uniforms.uDebugMode == 1) {\n    fragmentOutputs.color = uniforms.uDebugColor;\n    return fragmentOutputs;\n  }\n\n  let atlasSample = textureSample(uFontAtlas, uFontAtlasSampler, fragmentInputs.vUV);\n  let msdf = atlasSample.rgb;\n  if (uniforms.uDebugMode == 2) {\n    fragmentOutputs.color = vec4f(msdf, 1.0);\n    return fragmentOutputs;\n  }\n\n  let sd = shadoMsdfMedian(msdf.r, msdf.g, msdf.b) - 0.5 + fragmentInputs.vThickness;\n  let alpha = clamp(sd / max(fwidth(sd), 0.0001) + 0.5, 0.0, 1.0) * atlasSample.a;\n  if (alpha <= uniforms.uAlphaCutoff) { discard; }\n  fragmentOutputs.color = vec4f(fragmentInputs.vNameColor.rgb, alpha * fragmentInputs.vNameColor.a);\n}\n";
declare function makeMSDFTextShaders(options?: MSDFTextShaderOptions): {
    vertexGLSL: string;
    fragmentGLSL: string;
    vertexWGSL: string;
    fragmentWGSL: string;
};
declare function registerMSDFTextShaders(BABYLON: typeof BABYLON, shaderNameOrOptions?: string | MSDFTextShaderOptions): {
    vertex: string;
    fragment: string;
};
declare function createMSDFNameplateLayer(scene: BABYLON.Scene, actors: ShadoInstanceContainer<any> & ShadoBufferOwner, nameplates: NameplateData & ShadoBufferOwner, fontAsset: MSDFNameplateFontAsset, options?: MSDFNameplateLayerOptions): BABYLON.Mesh;
declare const createMsdfNameplateLayer: typeof createMSDFNameplateLayer;

export { MSDF_TEXT_FRAGMENT_WGSL as $, type ShadoAsyncPickingBaseOptions as A, type ShadoInstancePickResult as B, type ShadoDynamicEntityPickResult as C, type ShadoInstanceAsyncPickingOptions as D, type ShadoDynamicEntityAsyncPickingOptions as E, type ShadoPickingHandle as F, normalizePickingOptions as G, pickShadoInstanceAtPointer as H, type InstanceNameSource as I, pickShadoInstanceWithRay as J, pickShadoDynamicEntityAtPointer as K, pickShadoDynamicEntityWithRay as L, installShadoInstanceClickPicking as M, NameplateData as N, installShadoDynamicEntityClickPicking as O, type MSDFNameplateFontAsset as P, type MSDFNameplateLayerOptions as Q, type MSDFTextShaderOptions as R, ShadoActor as S, TestClass as T, MSDF_TEXT_VERTEX_GLSL_TEMPLATE as U, MSDF_TEXT_FRAGMENT_GLSL_TEMPLATE as V, MSDF_TEXT_VERTEX_WGSL_TEMPLATE as W, MSDF_TEXT_FRAGMENT_WGSL_TEMPLATE as X, MSDF_TEXT_VERTEX_GLSL as Y, MSDF_TEXT_FRAGMENT_GLSL as Z, MSDF_TEXT_VERTEX_WGSL as _, type ShadoInstanceContainerOptions as a, makeMSDFTextShaders as a0, registerMSDFTextShaders as a1, createMSDFNameplateLayer as a2, createMsdfNameplateLayer as a3, ShadoInstanceContainer as b, type ShadoMaterialOptions as c, ShadoMaterial as d, SHADO_ENTITY_VISIBLE as e, SHADO_ENTITY_SELECTED as f, SHADO_ENTITY_HIGHLIGHTED as g, SHADO_ENTITY2D_MESH_INDEX_MOTION_COMPONENT as h, type ShadoUvRect as i, type ShadoRgba as j, type ShadoEntity2DInput as k, type ShadoEntity2DDestinationInput as l, hashEntityId as m, entityFlags as n, ShadoEntity2D as o, type ShadoAtlasRect as p, type ShadoAtlasEntry as q, type ShadoTextureAtlas as r, type ShadoAtlasColor as s, createSolidColorAtlas as t, type ShadoDynamicEntityInput as u, type ShadoDynamicEntityDestinationInput as v, type ShadoDynamicEntityExpirationInput as w, type ShadoDynamicEntityGeometryMode as x, ShadoDynamicEntityContainer as y, type ShadoPickingSchedule as z };