emeraldengine 2.0.0

package/dist/types/imports/BitmapText.d.ts

@@ -0,0 +1,79 @@
+import Color from "./Color";
+import GameObject from "./components/GameObject";
+import InstancedTexture from "./InstancedTexture";
+import { Vector3 } from "./Physics";
+/**
+ * BitmapText class for rendering text using a bitmap font texture
+ * @param {string} text - The text to display
+ * @param {string} texturePath - Path to the bitmap font texture
+ * @param {string} letters - String containing all available characters in the font
+ * @param {number} letterSpacing - Spacing between letters
+ * @param {number} frameWidth - Width of each character frame
+ * @param {number} frameHeight - Height of each character frame
+ * @param {number} framesPerRow - Number of character frames per row in the texture
+ * @param {number} totalFrames - Total number of character frames
+ * @param {boolean} pixelArt - Whether to use pixel-perfect rendering
+ * @param {number} fontSize - Size of the rendered text
+ * @param {Color} color - Color tint for the text
+ * @param {Vector3} position - Position of the text
+ * @param {number} rotation - Rotation of the text
+ * @param {boolean} useLighting - Whether the text should react to lighting (default: false)
+ */
+declare class BitmapText {
+    text: string;
+    texturePath: string;
+    fontSize: number;
+    color: Color;
+    position: Vector3;
+    rotation: number;
+    letters: string;
+    letterSpacing: number;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerRow: number;
+    totalFrames: number;
+    pixelArt: boolean;
+    useLighting: boolean;
+    gameObject: GameObject;
+    letterDictionary: Record<string, number>;
+    texture: InstancedTexture;
+    constructor(text: string, texturePath: string, letters: string, letterSpacing: number, frameWidth: number, frameHeight: number, framesPerRow: number, totalFrames: number, pixelArt: boolean, fontSize: number, color: Color, position: Vector3, rotation: number, useLighting?: boolean);
+    /**
+     * @method setColor
+     * @description Updates the color of the bitmap text
+     * @param {Color} color - The color to set
+     */
+    setColor(color: Color): void;
+    /**
+     * @method setUseLighting
+     * @description Controls whether the text reacts to lighting
+     * @param {boolean} useLighting - Whether the text should react to lighting
+     */
+    setUseLighting(useLighting: boolean): void;
+    /**
+     * @method setText
+     * @description Updates the text of the bitmap text
+     * @param {string} text - The text to set
+     */
+    setText(text: string): void;
+    /**
+     * @method setPosition
+     * @description Updates the position of the bitmap text
+     * @param {Vector3} position - The position to set
+     */
+    setPosition(position: Vector3): void;
+    /**
+     * @method setFontSize
+     * @description Updates the font size of the bitmap text
+     * @param {number} fontSize - The font size to set
+     */
+    setFontSize(fontSize: number): void;
+    /**
+     * @method setLetterSpacing
+     * @description Updates the letter spacing of the bitmap text
+     * @param {number} letterSpacing - The letter spacing to set
+     */
+    setLetterSpacing(letterSpacing: number): void;
+}
+export default BitmapText;
+//# sourceMappingURL=BitmapText.d.ts.map

package/dist/types/imports/Color.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @class Color
+ * @description Represents a color
+ * @param {number} r - The red value
+ * @param {number} g - The green value
+ * @param {number} b - The blue value
+ * @param {number} a - The alpha value
+ */
+declare class Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+}
+export default Color;
+//# sourceMappingURL=Color.d.ts.map

package/dist/types/imports/Drawable.d.ts

@@ -0,0 +1,157 @@
+import Color from "./Color";
+import { mat4 } from "gl-matrix";
+import GameObject from "./components/GameObject";
+/**
+ * @class Drawable
+ * @description A class that represents a drawable object
+ * @param {WebGLRenderingContext} gl - The WebGL rendering context
+ * @param {Object} programInfo - The program information
+ * @param {WebGLBuffer} verticesBuffer - The vertices buffer
+ * @param {WebGLBuffer} texCoordBuffer - The texture coordinate buffer
+ * @param {Array} vertices - The vertices of the object
+ * @param {boolean} useTexture - Whether to use a texture
+ * @param {string} texturePath - The path to the texture
+ * @param {number} frameWidth - The width of the frame
+ * @param {number} frameHeight - The height of the frame
+ * @param {number} framesPerRow - The number of frames per row
+ * @param {number} totalFrames - The total number of frames
+ * @param {number} animationSpeed - The speed of the animation
+ * @param {boolean} autoplay - Whether to autoplay the animation
+ * @param {boolean} pixelart - Whether to use pixel art
+ * @param {boolean} useLighting - Whether to use lighting
+ */
+declare class Drawable {
+    gl: WebGL2RenderingContext;
+    programInfo: any;
+    id: string;
+    verticesBuffer: WebGLBuffer;
+    texCoordBuffer: WebGLBuffer;
+    vertices: number[];
+    color: Color;
+    texturePath: string;
+    texture: WebGLTexture | null;
+    useTexture: boolean;
+    frameWidth: number;
+    frameHeight: number;
+    framesPerRow: number;
+    totalFrames: number;
+    currentFrame: number;
+    animationSpeed: number;
+    lastFrameTime: number;
+    textureWidth: number;
+    textureHeight: number;
+    isPlaying: boolean;
+    playOnce: boolean;
+    originalTexture: WebGLTexture | null;
+    mirrored: boolean;
+    animationType: string;
+    currentAnimationArray: number[];
+    currentAnimationIndex: number;
+    shouldRevertAfterPlayingOnce: boolean;
+    revertAnimation: number[];
+    parentObject: any;
+    isActive: boolean;
+    isWireframe: boolean;
+    callbackFunction: () => void;
+    pixelart: boolean;
+    useLighting: boolean;
+    constructor(gl: WebGL2RenderingContext, programInfo: any, verticesBuffer: WebGLBuffer, texCoordBuffer: WebGLBuffer, vertices: number[], useTexture: boolean, texturePath: string, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoplay?: boolean, pixelart?: boolean, useLighting?: boolean);
+    /**
+     * @method setIsWireframe
+     * @description Sets the wireframe mode
+     * @param {boolean} bool - Whether to enable wireframe mode
+     */
+    setIsWireframe(bool: boolean): void;
+    /**
+     * @method setUseLighting
+     * @description Sets the lighting mode
+     * @param {boolean} useLighting - Whether to enable lighting reaction
+     */
+    setUseLighting(useLighting: boolean): void;
+    /**
+     * @method setIsActive
+     * @description Sets the active state
+     * @param {boolean} bool - Whether to enable the active state
+     */
+    setIsActive(bool: boolean): void;
+    /**
+     * @method setParent
+     * @description Sets the parent object
+     * @param {Object} parent - The parent object
+     */
+    setParent(parent: GameObject): void;
+    /**
+     * @method getParent
+     * @description Gets the parent object
+     * @returns {Object} - The parent object
+     */
+    getParent(): GameObject | null;
+    /**
+     * @method setColor
+     * @description Sets the color of the object
+     * @param {Color} color - The color to set
+     */
+    setColor(color: Color): void;
+    /**
+     * @method initTexture
+     * @description Initializes the texture
+     */
+    initTexture(): Promise<void>;
+    /**
+     * @method updateAnimation
+     * @description Updates the animation
+     * @param {number} currentTime - The current time
+     */
+    updateAnimation(currentTime: number): void;
+    /**
+     * @method getAnimation
+     * @description Gets the animation
+     * @returns {Array} - The animation
+     */
+    getAnimation(): number[] | string | null;
+    /**
+     * @method playAnimation
+     * @description Plays an animation
+     * @param {Array} animation - The animation to play
+     * @param {number} animationSpeed - The speed of the animation
+     */
+    playAnimation(animation: number[], animationSpeed?: number): void;
+    /**
+     * @method setFrame
+     * @description Sets the frame
+     * @param {number} frame - The frame to set
+     */
+    setFrame(frame: number): void;
+    /**
+     * @method playAnimationOnce
+     * @description Plays an animation once
+     * @param {Array} animation - The animation to play
+     * @param {Array} defaultAnimation - The default animation
+     * @param {number} animationSpeed - The speed of the animation
+     * @param {function} callbackFunction - The callback function
+     */
+    playAnimationOnce(animation: number[], defaultAnimation?: number[] | null, animationSpeed?: number, callbackFunction?: (() => void) | null): void;
+    /**
+     * @method stopAnimation
+     * @description Stops the animation
+     */
+    stopAnimation(): void;
+    /**
+     * @method draw
+     * @description Draws the object
+     * @param {mat4} globalViewMatrix - The global view matrix
+     * @param {WebGLUniformLocation} uniformLocation - The uniform location
+     * @param {number} currentTime - The current time
+     * @param {Object} objectTransform - The object transform
+     */
+    draw(globalViewMatrix: mat4, uniformLocation: WebGLUniformLocation, currentTime: number, objectTransform: any): void;
+    /**
+     * @method loadImage
+     * @description Loads an image
+     * @param {string} path - The path to the image
+     * @returns {Promise} - The promise
+     */
+    loadImage: (path: string) => Promise<unknown>;
+}
+export default Drawable;
+//# sourceMappingURL=Drawable.d.ts.map

package/dist/types/imports/Emerald.d.ts

@@ -0,0 +1,73 @@
+import Color from "./Color";
+import { Vector3 } from "./Physics";
+import PointLight from "./lights/PointLight";
+import DirectionalLight from "./lights/DirectionalLight";
+import Scene from "./Scene";
+/**
+ * @class Emerald
+ * @description A class that represents the Emerald engine
+ * @param {HTMLCanvasElement} canvas - The canvas element
+ */
+declare class Emerald {
+    shaderProgram: WebGLProgram;
+    gl: WebGL2RenderingContext;
+    programInfo: any;
+    camera: any;
+    ambientLight: Vector3;
+    pointLights: PointLight[];
+    directionalLights: DirectionalLight[];
+    debugLogged: boolean;
+    backgroundColor: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    constructor(canvas: HTMLCanvasElement);
+    /**
+     * @method setAmbientLight
+     * @description Sets the ambient light for the scene
+     * @param {Vector3} vector3 - The ambient light color as a Vector3 instance
+     */
+    setAmbientLight(vector3: Vector3): void;
+    /**
+     * @method resize
+     * @description Resizes the canvas
+     * @param {number} width - The width of the canvas
+     * @param {number} height - The height of the canvas
+     */
+    resize(width: number, height: number): void;
+    /**
+     * @method addPointLight
+     * @description Adds a point light to the scene
+     * @param {PointLight} pointLight - The point light to add
+     */
+    addPointLight(pointLight: PointLight): void;
+    /**
+     * @method addDirectionalLight
+     * @description Adds a directional light to the scene
+     * @param {DirectionalLight} directionalLight - The directional light to add
+     */
+    addDirectionalLight(directionalLight: DirectionalLight): void;
+    /**
+     * @method removeDirectionalLight
+     * @description Removes a directional light from the scene
+     * @param {DirectionalLight} directionalLight - The directional light to remove
+     */
+    removeDirectionalLight(directionalLight: DirectionalLight): void;
+    /**
+     * @method setBackgroundColor
+     * @description Sets the background color of the scene
+     * @param {Color} color - The background color
+     */
+    setBackgroundColor(color: Color): void;
+    /**
+     * @method drawScene
+     * @description Draws the scene
+     * @param {Scene} scene - The scene to draw
+     * @param {number} deltaTime - The delta time
+     */
+    drawScene(scene: Scene, deltaTime: number): void;
+}
+export default Emerald;
+//# sourceMappingURL=Emerald.d.ts.map

package/dist/types/imports/FPSCounter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @class FPSCounter
+ * @description Represents a FPS counter
+ */
+declare class FPSCounter {
+    lastFrameTime: number;
+    frameCount: number;
+    fps: number;
+    fpsElement: HTMLDivElement;
+    accumulatedTime: number;
+    constructor();
+    /**
+     * @method update
+     * @description Updates the FPS counter
+     */
+    update(): void;
+}
+export default FPSCounter;
+//# sourceMappingURL=FPSCounter.d.ts.map

package/dist/types/imports/GLUtils.d.ts

@@ -0,0 +1,6 @@
+declare function initShaderProgram(gl: WebGL2RenderingContext, vShader: string, fShader: string): WebGLProgram | null;
+declare function loadShader(gl: WebGL2RenderingContext, type: number, source: string): WebGLShader | null;
+declare const initVertexBuffer: (gl: WebGL2RenderingContext, vertices: number[]) => WebGLBuffer | null;
+declare function initInstancedBuffer(gl: WebGL2RenderingContext, data: Float32Array, itemSize: number): WebGLBuffer | null;
+export { initShaderProgram, loadShader, initVertexBuffer, initInstancedBuffer };
+//# sourceMappingURL=GLUtils.d.ts.map

package/dist/types/imports/Instance.d.ts

@@ -0,0 +1,87 @@
+import InstancedTexture from "./InstancedTexture";
+import { Vector2, Vector3 } from "./Physics";
+import Transform from "./Transform";
+/**
+ * @class Instance
+ * @description Represents an instance
+ * @param {string} name - The name of the instance
+ * @param {Vector3} position - The position of the instance
+ * @param {Vector2} scale - The scale of the instance
+ * @param {number} rotation - The rotation of the instance
+ * @param {number} frame - The frame of the instance
+ */
+declare class Instance {
+    name: string;
+    transform: Transform;
+    id: string;
+    parent: InstancedTexture | null;
+    frame: number;
+    isAnimating: boolean;
+    animationFrames: number[];
+    currentAnimationIndex: number;
+    animationSpeed: number;
+    lastFrameTime: number;
+    playOnce: boolean;
+    originalFrame: number;
+    components: any[];
+    constructor(name: string, position?: Vector3, scale?: Vector2, rotation?: number, frame?: number);
+    /**
+     * @method setParent
+     * @description Sets the parent of the instance
+     * @param {Instance} parent - The parent of the instance
+     */
+    setParent(parent: InstancedTexture): void;
+    /**
+     * @method playAnimation
+     * @description Plays an animation with an array of frames
+     * @param {Array} frames - The frames to play
+     * @param {number} speed - The speed of the animation
+     */
+    playAnimation(frames: number[], speed?: number): void;
+    /**
+     * @method playAnimationOnce
+     * @description Plays an animation with an array of frames once then stops
+     * @param {Array} frames - The frames to play
+     * @param {number} speed - The speed of the animation
+     */
+    playAnimationOnce(frames: number[], speed?: number): void;
+    /**
+     * @method stopAnimation
+     * @description Stops the animation and optionally reverts to the original frame
+     * @param {boolean} revertToOriginal - Whether to revert to the original frame
+     */
+    stopAnimation(revertToOriginal?: boolean): void;
+    /**
+     * @method setFrame
+     * @description Sets a specific frame
+     * @param {number} frame - The frame to set
+     */
+    setFrame(frame: number): void;
+    /**
+     * @method updateAnimation
+     * @description Updates the animation
+     * @param {number} currentTime - The current time
+     */
+    updateAnimation(currentTime: number): boolean;
+    /**
+     * @method addComponent
+     * @description Adds a component to the instance
+     * @param {Component} componentInstance - The component to add
+     */
+    addComponent(componentInstance: any): void;
+    /**
+     * @method removeComponent
+     * @description Removes a component from the instance
+     * @param {Component} component - The component to remove
+     */
+    removeComponent(component: any): void;
+    /**
+     * @method getComponent
+     * @description Gets a component from the instance
+     * @param {Component} componentType - The type of the component to get
+     * @returns {Component} - The component
+     */
+    getComponent(componentType: any): any;
+}
+export default Instance;
+//# sourceMappingURL=Instance.d.ts.map

package/dist/types/imports/InstancedTexture.d.ts

@@ -0,0 +1,230 @@
+import Instance from "./Instance";
+import Drawable from "./Drawable";
+import { Vector3 } from "./Physics";
+/**
+ * @class InstancedTexture
+ * @description Represents an instanced texture component
+ * @param {string} texturePath - The path to the texture
+ * @param {number} instanceCount - The number of instances
+ * @param {number} frameWidth - The width of the frame
+ * @param {number} frameHeight - The height of the frame
+ * @param {number} framesPerRow - The number of frames per row
+ * @param {number} totalFrames - The total number of frames
+ * @param {number} animationSpeed - The speed of the animation
+ * @param {boolean} autoPlay - Whether to auto play the animation
+ * @param {boolean} pixelart - Whether to use pixel art
+ * @param {boolean} useLighting - Whether to use lighting
+ */
+declare class InstancedTexture extends Drawable {
+    instanceCount: number;
+    instances: Instance[];
+    instanceMatrices: Float32Array;
+    instanceTexCoords: Float32Array;
+    instanceMatrixBuffer: WebGLBuffer;
+    instanceTexCoordBuffer: WebGLBuffer;
+    instanceClickListeners: Map<string, Set<Function>>;
+    instanceHoverListeners: Map<string, {
+        enter: Set<Function>;
+        leave: Set<Function>;
+    }>;
+    constructor(texturePath?: string, instanceCount?: number, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
+    /**
+     * @method addInstance
+     * @description Adds an instance to the instanced texture
+     * @param {Instance} instance - The instance to add
+     */
+    addInstance(instance: Instance): void;
+    /**
+     * @method removeInstance
+     * @description Removes an instance from the instanced texture
+     * @param {string} instanceID - The ID of the instance to remove
+     */
+    removeInstance(instanceID: string): void;
+    /**
+     * @method clearInstances
+     * @description Clears all instances from the instanced texture
+     */
+    clearInstances(): void;
+    /**
+     * @method updateInstanceCount
+     * @description Updates the instance count of the instanced texture
+     * @param {number} newCount - The new instance count
+     */
+    updateInstanceCount(newCount: number): void;
+    /**
+     * @method updateInstanceMatrix
+     * @description Updates the transformation matrix for a specific instance
+     * @param {number} index - The index of the instance to update
+     */
+    updateInstanceMatrix(index: number): void;
+    /**
+     * @method updateAllInstanceMatrices
+     * @description Updates all instance matrices
+     */
+    updateAllInstanceMatrices(): void;
+    /**
+     * @method updateInstanceTexCoords
+     * @description Updates the texture coordinates for a specific instance
+     * @param {number} index - The index of the instance to update
+     */
+    updateInstanceTexCoords(index: number): void;
+    /**
+     * @method updateAllInstanceTexCoords
+     * @description Updates all instance texture coordinates
+     */
+    updateAllInstanceTexCoords(): void;
+    /**
+     * @method getInstanceWithId
+     * @description Gets an instance by its ID
+     * @param {string} id - The ID of the instance to get
+     * @returns {Instance} - The instance
+     */
+    getInstanceWithId(id: string): Instance | undefined;
+    /**
+     * @method update
+     * @description Updates the instanced texture
+     * @param {number} currentTime - The current time
+     */
+    update(currentTime: number): void;
+    /**
+     * @method animateInstance
+     * @description Starts animation on a specific instance
+     * @param {string} instanceId - The ID of the instance to animate
+     * @param {Array} frames - The frames to animate
+     * @param {number} speed - The speed of the animation
+     */
+    animateInstance(instanceId: string, frames: number[], speed?: number): void;
+    /**
+     * @method stopInstanceAnimation
+     * @description Stops animation on a specific instance
+     * @param {string} instanceId - The ID of the instance to stop animation
+     * @param {boolean} revertToOriginal - Whether to revert to the original frame
+     */
+    stopInstanceAnimation(instanceId: string, revertToOriginal?: boolean): void;
+    /**
+     * @method addClickEventToAllInstances
+     * @description Adds a click event to all instances
+     * @param {function} func - The function to call when the instance is clicked
+     */
+    addClickEventToAllInstances(func: Function): void;
+    /**
+     * @method addHoverEventToAllInstances
+     * @description Adds a hover event to all instances
+     * @param {function} enterFunc - The function to call when the instance is hovered
+     * @param {function} leaveFunc - The function to call when the instance is no longer hovered
+     */
+    addHoverEventToAllInstances(enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method removeClickEventFromAllInstances
+     * @description Removes a click event from all instances
+     * @param {function} func - The function to remove
+     */
+    removeClickEventFromAllInstances(func: Function): void;
+    /**
+     * @method removeHoverEventFromAllInstances
+     * @description Removes a hover event from all instances
+     * @param {function} enterFunc - The function to remove
+     * @param {function} leaveFunc - The function to remove
+     */
+    removeHoverEventFromAllInstances(enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method getFrameTexCoords
+     * @description Calculates the texture coordinates for a specific frame
+     * @param {number} frame - The frame to calculate the texture coordinates for
+     * @returns {Array} - The texture coordinates
+     */
+    getFrameTexCoords(frame: number): number[];
+    /**
+     * @method draw
+     * @description Draws the instanced texture
+     */
+    draw(): void;
+    /**
+     * @method setInstanceFrame
+     * @description Updates the frame of a specific instance
+     * @param {string} instanceId - The ID of the instance to update
+     * @param {number} frame - The frame to set
+     */
+    setInstanceFrame(instanceId: string, frame: number): void;
+    /**
+     * @method isPointInInstance
+     * @description Checks if a point is inside a specific instance
+     * @param {number} x - The x coordinate of the point
+     * @param {number} y - The y coordinate of the point
+     * @param {Instance} instance - The instance to check
+     * @returns {boolean} - Whether the point is inside the instance
+     */
+    isPointInInstance(x: number, y: number, instance: Instance): boolean;
+    /**
+     * @method getInstanceAtPosition
+     * @description Gets an instance at a specific position
+     * @param {Vector3} position - The position to check
+     * @param {number} tolerance - The tolerance for the position
+     * @returns {Instance} - The instance at the position
+     */
+    getInstanceAtPosition(position: Vector3, tolerance?: number): Instance | undefined;
+    /**
+     * @method getInstanceByFrame
+     * @description Gets an instance by its frame index
+     * @param {number} frameIndex - The frame index to get
+     * @returns {Instance} - The instance at the frame index
+     */
+    getInstanceByFrame(frameIndex: number): Instance | undefined;
+    /**
+     * @method getInstanceAtPoint
+     * @description Gets an instance at a specific point
+     * @param {number} x - The x coordinate of the point
+     * @param {number} y - The y coordinate of the point
+     * @returns {Instance} - The instance at the point
+     */
+    getInstanceAtPoint(x: number, y: number): Instance | undefined;
+    /**
+     * @method addInstanceClickEvent
+     * @description Adds a click event listener to a specific instance
+     * @param {string} instanceId - The ID of the instance to add the click event listener to
+     * @param {function} func - The function to call when the instance is clicked
+     */
+    addInstanceClickEvent(instanceId: string, func: Function): void;
+    /**
+     * @method removeInstanceClickEvent
+     * @description Removes a click event listener from a specific instance
+     * @param {string} instanceId - The ID of the instance to remove the click event listener from
+     * @param {function} func - The function to remove
+     */
+    removeInstanceClickEvent(instanceId: string, func: Function): void;
+    /**
+     * @method addInstanceHoverEvent
+     * @description Adds a hover event listener to a specific instance
+     * @param {string} instanceId - The ID of the instance to add the hover event listener to
+     * @param {function} enterFunc - The function to call when the instance is hovered
+     * @param {function} leaveFunc - The function to call when the instance is no longer hovered
+     */
+    addInstanceHoverEvent(instanceId: string, enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method removeInstanceHoverEvent
+     * @description Removes a hover event listener from a specific instance
+     * @param {string} instanceId - The ID of the instance to remove the hover event listener from
+     * @param {function} enterFunc - The function to remove
+     * @param {function} leaveFunc - The function to remove
+     */
+    removeInstanceHoverEvent(instanceId: string, enterFunc: Function, leaveFunc: Function): void;
+    /**
+     * @method handleInstanceClick
+     * @description Handles a click event for a specific instance
+     * @param {Event} event - The event to handle
+     * @param {number} x - The x coordinate of the click
+     * @param {number} y - The y coordinate of the click
+     */
+    handleInstanceClick(event: Event, x: number, y: number): boolean;
+    /**
+     * @method handleInstanceHover
+     * @description Handles a hover event for a specific instance
+     * @param {Event} event - The event to handle
+     * @param {number} x - The x coordinate of the hover
+     * @param {number} y - The y coordinate of the hover
+     * @param {Instance} lastHoveredInstance - The last hovered instance
+     */
+    handleInstanceHover(event: Event, x: number, y: number, lastHoveredInstance: Instance | undefined): Instance | undefined;
+}
+export default InstancedTexture;
+//# sourceMappingURL=InstancedTexture.d.ts.map