@divinevoxel/vlox 0.0.0

package/Textures/TextureAnimations.js

@@ -0,0 +1,135 @@
+export const TextureAnimationCreator = {
+    createAnimations(texture) {
+        for (const [key, segment] of texture.segments) {
+            const animaitonUniform = [];
+            let i = 0;
+            for (const anim of segment.animationsMap) {
+                animaitonUniform[anim[0]] = anim[0];
+                let keyCounts = [];
+                const animTime = segment.animationTimes[i];
+                if (animTime.length == 1) {
+                    for (let k = 0; k < anim.length; k++) {
+                        keyCounts.push(animTime[0]);
+                    }
+                }
+                else {
+                    keyCounts = segment.animationTimes[i];
+                }
+                segment.animations.push({
+                    uniformIndex: anim[0],
+                    keys: anim,
+                    currentFrame: 0,
+                    currentCount: 0,
+                    keyCounts: keyCounts,
+                });
+                i++;
+            }
+            for (let i = 0; i < segment.totalTextures; i++) {
+                if (!animaitonUniform[i]) {
+                    animaitonUniform[i] = 0;
+                }
+            }
+            texture.shader.addConstants([
+                {
+                    id: "textureMasks",
+                    body: {
+                        GLSL: /* glsl  */ `
+const uint textureIndexMask = uint(0xffff);
+const uint mainTexutreIndex =uint(0);
+const uint secondaryTextureIndex = uint(0xf + 0x1);
+`,
+                    },
+                },
+            ]);
+            segment.animationUniforID =
+                `${texture.id}_${key}_texture_animations`.replace("#", "");
+            segment.varyingID = `${texture.id}_${key}_texture_index`.replace("#", "");
+            const functionName = `get_${texture.id}_${key}_texture_animation_frame`.replace("#", "");
+            texture.shader.addUniform([
+                [segment.animationUniforID, "float", animaitonUniform.length],
+            ]);
+            if (segment.mode == "sampler") {
+                texture.shader.addFunction(functionName, "vertex", {
+                    inputs: [["index", "int"]],
+                    output: "float",
+                    arguments: {},
+                    body: {
+                        GLSL: () => /* glsl  */ `    
+        float animatedIndex = ${segment.animationUniforID}[index];
+        if(animatedIndex == 0.){
+            return float(index);
+        }
+        if(animatedIndex != 0.){
+          return float(animatedIndex);
+        }
+        return float(index);`,
+                    },
+                });
+                texture.shader.addVarying([
+                    {
+                        id: segment.varyingID,
+                        type: "vec3",
+                        body: {
+                            GLSL: () => /* glsl  */ `
+        ${segment.varyingID}.x = uv.x;
+        ${segment.varyingID}.y = uv.y;
+        ${segment.varyingID}.z = ${functionName}( int( uint( ${segment.attributeID}.x)  & textureIndexMask)  );
+       `,
+                        },
+                    },
+                ]);
+            }
+            if (segment.mode == "overlay") {
+                texture.shader.addFunction(functionName, "vertex", {
+                    inputs: [],
+                    output: "vec4",
+                    arguments: {
+                        attributeID: segment.attributeID,
+                    },
+                    body: {
+                        GLSL: (args) => /* glsl  */ `
+        vec4 frames = vec4(0., 0., 0., 0.);
+        int texture1Index =  int(((textureIndexMask << secondaryTextureIndex) & uint(${args.attributeID}.x)) >> secondaryTextureIndex);
+        if( ${segment.animationUniforID}[texture1Index] != 0.) {
+            frames.x =  ${segment.animationUniforID}[texture1Index];
+        } else {
+            frames.x = float(texture1Index);
+        }
+
+        int texture2Index =  int(((textureIndexMask << mainTexutreIndex) & uint(${args.attributeID}.y)) >> mainTexutreIndex);
+        if( ${segment.animationUniforID}[texture2Index] != 0.) {
+            frames.y =  ${segment.animationUniforID}[texture2Index];
+        } else {
+            frames.y = float(texture2Index);
+        }
+
+        int texture3Index =  int(((textureIndexMask << secondaryTextureIndex) & uint(${args.attributeID}.y)) >> secondaryTextureIndex);
+        if( ${segment.animationUniforID}[texture3Index] != 0.) {
+            frames.z =  ${segment.animationUniforID}[texture3Index];
+        } else {
+            frames.z = float(texture3Index);
+        }
+
+        int texture4Index =  int(((textureIndexMask << mainTexutreIndex) & uint(${args.attributeID}.z)) >> mainTexutreIndex);
+        if( ${segment.animationUniforID}[texture4Index] != 0.) {
+            frames.w =  ${segment.animationUniforID}[texture4Index];
+        } else {
+            frames.w = float(texture4Index);
+        }
+        return frames;`,
+                    },
+                });
+                texture.shader.addVarying([
+                    {
+                        id: segment.varyingID,
+                        type: "vec4",
+                        body: {
+                            GLSL: () => `${segment.varyingID} = ${functionName}();`,
+                        },
+                    },
+                ]);
+            }
+            segment.animationUniform = new Float32Array(animaitonUniform);
+        }
+    },
+};

package/Textures/TextureBuilder.d.ts

@@ -0,0 +1,16 @@
+import { URITexture } from "@amodx/uri/Textures/URITexture";
+export declare class TextureBuilder {
+    static context: CanvasRenderingContext2D | null;
+    static _textureSize: number;
+    static finalImagWidth: number;
+    static finalImageHeight: number;
+    static _canvas: HTMLCanvasElement;
+    static defineTextureDimensions(textureSize: number, mipMapSizes: number[]): void;
+    static setUpImageCreation(): void;
+    static createMaterialTexture(name: string, images: Map<string, Uint8ClampedArray | string | false>, width?: number, height?: number): Promise<URITexture>;
+    static _create(name: string, images: Map<string, Uint8ClampedArray | string | false>, width: number, height: number): Promise<URITexture<import("@amodx/uri/Scenes/URIScene").URIScene<any>, any>>;
+    static _createMipMap(level: number, images: Map<string, Uint8ClampedArray | string | false>, width: number, height: number): Promise<Uint8ClampedArray>;
+    static getRawData(imageSrc: string): Promise<Uint8ClampedArray>;
+    static loadImage(imgSrcData: string | Uint8ClampedArray, width?: number, height?: number, lod?: number, flip?: boolean): Promise<Uint8ClampedArray>;
+    static _combineImageData(totalLength: number, arrays: Uint8ClampedArray[]): Uint8ClampedArray;
+}

package/Textures/TextureBuilder.js

@@ -0,0 +1,245 @@
+import { URITextureFormat, URITextureSamplingMode, URITextureTypes, } from "@amodx/uri/Constants/URITexturesConstants";
+import { DivineVoxelEngineRender } from "../Contexts/Render/DivineVoxelEngineRender";
+export class TextureBuilder {
+    static context = null;
+    static _textureSize = 16;
+    static finalImagWidth = 16;
+    static finalImageHeight = 16;
+    static _canvas = document.createElement("canvas");
+    static defineTextureDimensions(textureSize, mipMapSizes) {
+        this.finalImagWidth = textureSize < 256 ? 256 : textureSize;
+        this.finalImageHeight = textureSize < 256 ? 256 : textureSize;
+        this._textureSize = textureSize;
+    }
+    static setUpImageCreation() {
+        this._canvas.width = this.finalImagWidth;
+        this._canvas.height = this.finalImageHeight;
+        const context = this._canvas.getContext("2d", { willReadFrequently: true });
+        if (!context) {
+            throw new Error("Context did not load for texture creation.");
+        }
+        context.imageSmoothingEnabled = false;
+        context.imageSmoothingQuality = "high";
+        this.context = context;
+    }
+    static async createMaterialTexture(name, images, width = -1, height = -1) {
+        if (width == -1)
+            width = this.finalImagWidth;
+        if (height == -1)
+            height = this.finalImageHeight;
+        this._canvas.width = this.finalImagWidth;
+        this._canvas.height = this.finalImageHeight;
+        return (await this._create(name, images, width, height));
+        /*    for (const size of this._mipMapSizes) {
+          const texture = await this._createOld(name, images, size, size);
+          textures.push(texture);
+        }
+        return textures; */
+    }
+    static async _create(name, images, width, height) {
+        // const scene = RenderManager.scene!;
+        const data = (await this._createMipMap(0, images, width, height));
+        const texture = DivineVoxelEngineRender.instance.renderer.engine.createTexture({
+            type: URITextureTypes.Texture2DArray,
+            data,
+            width,
+            height,
+            scene: DivineVoxelEngineRender.instance.renderer.scene,
+            layers: images.size + 2,
+            format: URITextureFormat.Rgba,
+            samplingMode: URITextureSamplingMode.TrilinearSamplingMode,
+            //@ts-ignore
+            images,
+        });
+        await texture._create();
+        // texture.anisotropicFilteringLevel = 16;
+        /*     texture._noMipmap = false;
+        const iTexture = texture._texture!;
+        iTexture.generateMipMaps = true;
+        iTexture.useMipMaps = true;
+        engine._bindTextureDirectly(engine._gl.TEXTURE_2D_ARRAY, iTexture);
+    
+        let w = width,
+          h = height,
+          mipMapLevel = 0;
+        while (w >= 1 && h >= 1) {
+          if (mipMapLevel < 3) {
+            this.context!.imageSmoothingEnabled = false;
+          } else {
+            this.context!.imageSmoothingEnabled = true;
+          }
+          const mip = await this._createMipMap(mipMapLevel, images, w, h);
+    
+          const gl = engine._gl;
+          const textureType = engine._getWebGLTextureType(iTexture.type);
+          const format = engine._getInternalFormat(iTexture.format);
+          const internalFormat = engine._getRGBABufferInternalSizedFormat(
+            iTexture.type,
+            iTexture.format,
+            iTexture._useSRGBBuffer
+          );
+    
+          engine._unpackFlipY(texture.invertY);
+    
+          console.log(w, h);
+          let target = gl.TEXTURE_2D_ARRAY;
+    
+          gl.texImage3D(
+            target,
+            mipMapLevel,
+            internalFormat,
+            w,
+            h,
+            images.size + 2,
+            0,
+            format,
+            textureType,
+            mip
+          );
+          w /= 2;
+          h /= 2;
+          mipMapLevel++;
+        }
+    
+        iTexture.width = width;
+        iTexture.height = height;
+        iTexture.isReady = true;
+        //  iTexture.samplingMode = Texture.NEAREST_NEAREST_MIPLINEAR;
+        engine._bindTextureDirectly(engine._gl.TEXTURE_2D_ARRAY, null);
+        texture._texture = iTexture;
+     */
+        return texture;
+    }
+    static async _createMipMap(level, images, width, height) {
+        //   const scene = RenderManager.scene!;
+        const resolvedImages = [];
+        //create blank fill to pad image array buffer
+        const data = [];
+        for (let i = 0; i < width; i++) {
+            for (let j = 0; j < height; j++) {
+                data.push(0, 0, 0, 1);
+            }
+        }
+        resolvedImages.push(new Uint8ClampedArray(data));
+        for (const [path, rawData] of images) {
+            const data = await this.loadImage(rawData ? rawData : path, width, height, level);
+            resolvedImages.push(data);
+        }
+        resolvedImages.push(new Uint8ClampedArray(data));
+        let totalLength = 0;
+        for (const image of resolvedImages) {
+            totalLength += image.byteLength;
+        }
+        return this._combineImageData(totalLength, resolvedImages);
+    }
+    static async getRawData(imageSrc) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.crossOrigin = "Anonymous";
+            image.src = imageSrc;
+            image.onload = () => {
+                if (!this.context) {
+                    return reject(new Error("Context is not set for texture creation."));
+                }
+                this._canvas.width = image.width;
+                this._canvas.height = image.height;
+                this.context.clearRect(0, 0, image.width, image.height);
+                this.context.drawImage(image, 0, 0, image.width, image.height);
+                const imgData = this.context.getImageData(0, 0, image.width, image.height);
+                resolve(imgData.data);
+                this._canvas.width = this.finalImagWidth;
+                this._canvas.height = this.finalImageHeight;
+            };
+            image.onerror = (err) => reject(err);
+        });
+    }
+    static async loadImage(imgSrcData, width = 0, height = 0, lod = 0, flip = true) {
+        let testing = false;
+        if (!width)
+            width = this.finalImagWidth;
+        if (!height)
+            height = this.finalImageHeight;
+        const ctx = TextureBuilder.context;
+        if (!ctx) {
+            throw new Error("Context is not set for texture creation.");
+        }
+        const turnRed = (data) => {
+            for (let i = 0; i < data.length; i += 4) {
+                data[i] = 255; // Red
+                data[i + 1] = 0; // Green
+                data[i + 2] = 0; // Blue
+            }
+        };
+        if (typeof imgSrcData == "string") {
+            const prom = new Promise((resolve) => {
+                const image = new Image();
+                image.src = imgSrcData;
+                image.onload = async () => {
+                    ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+                    ctx.save();
+                    if (flip) {
+                        ctx.scale(1, -1);
+                        ctx.drawImage(image, 0, -image.height, image.width, image.height);
+                    }
+                    else {
+                        ctx.drawImage(image, 0, 0, image.width, image.height);
+                    }
+                    ctx.restore();
+                    const imgData = ctx.getImageData(0, 0, image.width, image.height);
+                    const bitmap = await createImageBitmap(new ImageData(imgData.data, image.width, image.height), {
+                        resizeWidth: width,
+                        resizeHeight: height,
+                        resizeQuality: "pixelated",
+                        premultiplyAlpha: lod != 0 ? "premultiply" : undefined,
+                    });
+                    ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+                    ctx.drawImage(bitmap, 0, 0, width, height);
+                    const bitmapData = ctx.getImageData(0, 0, width, height);
+                    if (testing && lod > 0) {
+                        turnRed(bitmapData.data);
+                    }
+                    resolve(bitmapData.data);
+                };
+            });
+            return prom;
+        }
+        if (imgSrcData instanceof Uint8ClampedArray) {
+            const prom = new Promise(async (resolve) => {
+                ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);
+                ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+                const bitmap = await createImageBitmap(new ImageData(imgSrcData, Math.sqrt(imgSrcData.length / 4), Math.sqrt(imgSrcData.length / 4)), {
+                    resizeWidth: width,
+                    resizeHeight: height,
+                    resizeQuality: "pixelated",
+                    premultiplyAlpha: lod != 0 ? "premultiply" : undefined,
+                });
+                ctx.save();
+                if (flip) {
+                    ctx.scale(1, -1);
+                    ctx.drawImage(bitmap, 0, -height, width, height);
+                }
+                else {
+                    ctx.drawImage(bitmap, 0, 0, width, height);
+                }
+                ctx.restore();
+                const imgData = ctx.getImageData(0, 0, width, height);
+                if (testing && lod > 0) {
+                    turnRed(imgData.data);
+                }
+                resolve(imgData.data);
+            });
+            return prom;
+        }
+        throw new Error("Context is not set for texture creation.");
+    }
+    static _combineImageData(totalLength, arrays) {
+        const combinedImagedata = new Uint8ClampedArray(totalLength);
+        const length = arrays[0].length;
+        for (let i = 0; i < arrays.length; i++) {
+            const array = arrays[i];
+            const previousArrayIndex = length * i;
+            combinedImagedata.set(array, previousArrayIndex);
+        }
+        return combinedImagedata;
+    }
+}

package/Textures/TextureManager.d.ts

@@ -0,0 +1,22 @@
+import type { TextureData, TextureTypeUVMap } from "./Texture.types";
+import { TextureType } from "./TextureType.js";
+import { ConstructorTextureData } from "./Constructor.types";
+export declare class TextureManager {
+    static defaultTexturePath: string;
+    static textureTypes: Map<string, TextureType>;
+    static getTextureIndex(data: ConstructorTextureData, overlay?: boolean): number;
+    static _ready: boolean;
+    static isReady(): boolean;
+    static $INIT(): Promise<void>;
+    static $START_ANIMATIONS(): void;
+    static generateTextureUVMap(): TextureTypeUVMap;
+    static defineDefaultTexturePath(path: string): void;
+    static getTextureData([type, id, segment]: ConstructorTextureData): TextureData | undefined;
+    static getTextureType(id: string): false | TextureType;
+    static getOrAddTextureType(id: string): TextureType;
+    static addTextureType(id: string): TextureType;
+    static clearTextureData(): void;
+    static registerTexture(textureData: TextureData | TextureData[]): void;
+    static getTexturePath(textureType: string, id: string, varation: string, segment?: string, frames?: number): string;
+    static createRawDataMap(): Promise<Map<string, Uint8ClampedArray>>;
+}

package/Textures/TextureManager.js

@@ -0,0 +1,153 @@
+import { EngineSettings } from "../Data/Settings/EngineSettings.js";
+import { TextureBuilder } from "./TextureBuilder.js";
+import { TextureType } from "./TextureType.js";
+export class TextureManager {
+    static defaultTexturePath = "assets/textures";
+    static textureTypes = new Map();
+    static getTextureIndex(data, overlay = false) {
+        const [textureType, textureId, varation] = data;
+        const type = this.getTextureType(textureType);
+        if (!type)
+            return NaN;
+        return type.getTextureIndex(textureId, varation, overlay ? "overlay" : "main");
+    }
+    static _ready = false;
+    static isReady() {
+        return this._ready;
+    }
+    static async $INIT() {
+        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize, EngineSettings.settings.textures.mipMapSizes);
+        for (const [key, type] of this.textureTypes) {
+            await type.build();
+        }
+        this._ready = true;
+    }
+    static $START_ANIMATIONS() {
+        setInterval(() => {
+            for (const [key, type] of this.textureTypes) {
+                type.runAnimations();
+            }
+        }, 50);
+    }
+    static generateTextureUVMap() {
+        const uvMap = {};
+        for (const [key, type] of this.textureTypes) {
+            uvMap[key] = type.getTextureIndexMap();
+        }
+        return uvMap;
+    }
+    static defineDefaultTexturePath(path) {
+        this.defaultTexturePath = path;
+    }
+    static getTextureData([type, id, segment]) {
+        const t = this.getTextureType(type);
+        if (!t)
+            return undefined;
+        let s = segment ? t.segments.get(segment) : t.segments.get("main");
+        if (!s)
+            return undefined;
+        return s.textureMap.get(id);
+    }
+    static getTextureType(id) {
+        const texture = this.textureTypes.get(id);
+        if (!texture)
+            return false;
+        return texture;
+    }
+    static getOrAddTextureType(id) {
+        const texture = this.textureTypes.get(id);
+        if (!texture)
+            return this.addTextureType(id);
+        return texture;
+    }
+    static addTextureType(id) {
+        const newType = new TextureType(id);
+        this.textureTypes.set(id, newType);
+        return newType;
+    }
+    static clearTextureData() {
+        this.textureTypes.forEach((_) => _.clearSegmentData());
+    }
+    static registerTexture(textureData) {
+        if (Array.isArray(textureData)) {
+            for (const texture of textureData) {
+                const type = this.getOrAddTextureType(texture.type);
+                if (!type)
+                    continue;
+                type.addTexture(texture);
+                continue;
+            }
+            return;
+        }
+        const type = this.getOrAddTextureType(textureData.type);
+        if (!type)
+            return;
+        type.addTexture(textureData);
+    }
+    static getTexturePath(textureType, id, varation, segment = "main", frames) {
+        const data = this.getTextureData([textureType, id, segment]);
+        if (!data)
+            throw new Error(`Could not find data for ${textureType} ${id} ${varation}`);
+        let path = data.base64 &&
+            (Array.isArray(data.base64) ? data.base64[0] : data.base64);
+        if (path)
+            return path;
+        const type = this.textureTypes.get(textureType);
+        return type._getPath(data, varation, type.extension);
+    }
+    static async createRawDataMap() {
+        const map = new Map();
+        for (const [typeKey, type] of this.textureTypes) {
+            for (const [segKey, segment] of type.segments) {
+                for (const data of segment.textures) {
+                    if (!data.includeInRawDataMap)
+                        continue;
+                    if (!data.path && !data.rawData)
+                        continue;
+                    const key = `${type.id}|${data.id}|default`;
+                    if (data.frames) {
+                        for (let i = 1; i <= data.frames; i++) {
+                            const rawData = await TextureBuilder.loadImage(data.rawData
+                                ? data.rawData[i - 1]
+                                : type._getPath(data, `${key}-${i}`, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                            data.rawData = rawData;
+                            map.set(`${key}-${i}`, rawData);
+                        }
+                    }
+                    else {
+                        const rawData = await TextureBuilder.loadImage(data.rawData
+                            ? data.rawData
+                            : type._getPath(data, "default", type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                        data.rawData = rawData;
+                        map.set(key, rawData);
+                    }
+                    if (data.variations) {
+                        for (const varId in data.variations) {
+                            const varation = data.variations[varId];
+                            if (!varation.includeInRawDataMap)
+                                continue;
+                            const key = `${type.id}|${data.id}|${varId}`;
+                            if (data.frames) {
+                                for (let i = 1; i <= data.frames; i++) {
+                                    const rawData = await TextureBuilder.loadImage(data.rawData
+                                        ? data.rawData[i - 1]
+                                        : type._getPath(data, `${key}-${i}`, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                                    data.rawData = rawData;
+                                    map.set(`${key}-${i}`, rawData);
+                                }
+                            }
+                            else {
+                                const rawData = await TextureBuilder.loadImage(data.rawData
+                                    ? data.rawData
+                                    : type._getPath(data, varId, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                                data.rawData = rawData;
+                                map.set(key, rawData);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return map;
+    }
+}

package/Textures/TextureRegister.d.ts

@@ -0,0 +1,10 @@
+import type { ConstructorTextureData } from "./Constructor.types";
+import type { TextureTypeUVMap } from "./Texture.types";
+export declare const TextureRegister: {
+    textureDataHasBeenSet: boolean;
+    data: TextureTypeUVMap;
+    getTextureUV(data: ConstructorTextureData, overlay?: boolean): number;
+    setTextureIndex(data: TextureTypeUVMap): void;
+    releaseTextureData(): void;
+    isReady(): boolean;
+};

package/Textures/TextureRegister.js

@@ -0,0 +1,33 @@
+export const TextureRegister = {
+    textureDataHasBeenSet: false,
+    data: {},
+    getTextureUV(data, overlay = false) {
+        const [textureType, textureId, varation] = data;
+        let id = textureId;
+        if (varation) {
+            id = `${textureId}:${varation}`;
+        }
+        let uv = -1;
+        if (!overlay) {
+            uv = this.data[textureType]["main"][id];
+        }
+        else {
+            uv = this.data[textureType]["overlay"][id];
+        }
+        if (uv == -1) {
+            throw new Error(`Texture with id: ${id} does not exists. Overlay : ${overlay}`);
+        }
+        return uv;
+    },
+    setTextureIndex(data) {
+        this.textureDataHasBeenSet = true;
+        this.data = data;
+    },
+    releaseTextureData() {
+        this.data = null;
+        delete this["data"];
+    },
+    isReady() {
+        return this.textureDataHasBeenSet;
+    },
+};

package/Textures/TextureType.d.ts

@@ -0,0 +1,63 @@
+import type { TextureData } from "./Texture.types";
+import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader";
+import { URIMaterial } from "@amodx/uri/Materials/URIMaterial";
+import { URITexture } from "@amodx/uri/Textures/URITexture";
+declare class TextureSegment {
+    parentID: string;
+    id: string;
+    mode: "sampler" | "overlay";
+    attributeID: string;
+    totalTextures: number;
+    textureMap: Map<string, TextureData>;
+    textures: TextureData[];
+    textureIndex: Record<string, number>;
+    animationsMap: number[][];
+    animationTimes: number[][];
+    animations: {
+        uniformIndex: number;
+        overlay?: boolean;
+        keys: number[];
+        currentFrame: number;
+        currentCount: number;
+        keyCounts: number[];
+    }[];
+    varyingID: string;
+    animationUniforID: string;
+    animationUniform: Float32Array;
+    paths: Map<string, Uint8ClampedArray | string | false>;
+    shaderTexture: URITexture<any, any> | null;
+    textureID: string;
+    constructor(parentID: string, id: string, mode: "sampler" | "overlay", attributeID: string);
+    /**# clearData
+     * ---
+     * Clear all un-needed data.
+     */
+    clearData(): void;
+    /**# flush
+     * ---
+     * Clear all data.
+     */
+    flush(): void;
+}
+export declare class TextureType {
+    id: string;
+    extension: string;
+    segments: Map<string, TextureSegment>;
+    materials: Map<string, URIMaterial>;
+    shader: URIShader;
+    constructor(id: string);
+    flushAll(): void;
+    build(): Promise<void>;
+    getTextureIndex(textureId: string, varation?: string, segment?: string): number;
+    clearSegmentData(): void;
+    removeSegment(id: string): false | undefined;
+    addTexture(data: TextureData): false | undefined;
+    addToShader(shader: URIShader): URIShader;
+    addToMaterial(material: URIMaterial): void;
+    runAnimations(): void;
+    getTextureIndexMap(): Record<string, Record<string, number>>;
+    _processVariations(textureData: TextureData, paths: Map<string, Uint8ClampedArray | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
+    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
+    buildTextureIndex(): false | undefined;
+}
+export {};