export interface ResourceTracker {
    trackBuffer(buffer: GPUBufferResource): void;
    trackTexture(texture: Texture2D | TextureCubeMap): void;
    untrackBuffer(buffer: GPUBufferResource): void;
    untrackTexture(texture: Texture2D | TextureCubeMap): void;
}
export declare class GPUResourceTracker implements ResourceTracker {
    private _totalBufferMemory;
    private _totalTextureMemory;
    private _bufferCount;
    private _textureCount;
    trackBuffer(buffer: GPUBufferResource): void;
    trackTexture(texture: Texture2D | TextureCubeMap): void;
    untrackBuffer(buffer: GPUBufferResource): void;
    untrackTexture(texture: Texture2D | TextureCubeMap): void;
    get totalBufferMemory(): number;
    get totalTextureMemory(): number;
    get bufferCount(): number;
    get textureCount(): number;
    reset(): void;
}
export declare function setResourceTracker(tracker: ResourceTracker): void;
export declare function getResourceTracker(): ResourceTracker | undefined;
export declare class GPUBufferResource {
    protected readonly device: GPUDevice;
    readonly buffer: GPUBuffer;
    readonly size: number;
    readonly usage: GPUBufferUsageFlags;
    constructor(device: GPUDevice, descriptor: {
        size: number;
        usage: GPUBufferUsageFlags;
        label?: string;
        mappedAtCreation?: boolean;
    });
    write(data: BufferSource, offset?: number): void;
    mapAsync(mode: GPUMapModeFlags, offset?: number, size?: number): Promise<void>;
    getMappedRange(offset?: number, size?: number): ArrayBuffer;
    unmap(): void;
    destroy(): void;
}
export declare class VertexBuffer extends GPUBufferResource {
    constructor(device: GPUDevice, descriptor: {
        size: number;
        label?: string;
        usage?: GPUBufferUsageFlags;
    });
}
export declare class IndexBuffer extends GPUBufferResource {
    constructor(device: GPUDevice, descriptor: {
        size: number;
        label?: string;
        usage?: GPUBufferUsageFlags;
    });
}
export declare class UniformBuffer extends GPUBufferResource {
    constructor(device: GPUDevice, descriptor: {
        size: number;
        label?: string;
        usage?: GPUBufferUsageFlags;
    });
}
export declare class StorageBuffer extends GPUBufferResource {
    constructor(device: GPUDevice, descriptor: {
        size: number;
        label?: string;
        usage?: GPUBufferUsageFlags;
    });
}
export interface TextureUploadOptions {
    width?: number;
    height?: number;
    depthOrArrayLayers?: number;
    mipLevel?: number;
    bytesPerRow?: number;
    rowsPerImage?: number;
}
export declare class Texture2D {
    protected readonly device: GPUDevice;
    readonly texture: GPUTexture;
    readonly width: number;
    readonly height: number;
    readonly format: GPUTextureFormat;
    private static mipmapPipelines;
    private static mipmapSamplers;
    constructor(device: GPUDevice, descriptor: {
        width: number;
        height: number;
        format: GPUTextureFormat;
        usage?: GPUTextureUsageFlags;
        mipLevelCount?: number;
        label?: string;
    });
    upload(data: BufferSource, options?: TextureUploadOptions): void;
    private getMipmapPipeline;
    private getMipmapSampler;
    generateMipmaps(commandEncoder: GPUCommandEncoder): void;
    createView(descriptor?: GPUTextureViewDescriptor): GPUTextureView;
    destroy(): void;
    get memorySize(): number;
}
export declare class TextureCubeMap {
    protected readonly device: GPUDevice;
    readonly texture: GPUTexture;
    readonly size: number;
    readonly format: GPUTextureFormat;
    constructor(device: GPUDevice, descriptor: {
        size: number;
        format: GPUTextureFormat;
        usage?: GPUTextureUsageFlags;
        mipLevelCount?: number;
        label?: string;
    });
    uploadFace(face: number, data: BufferSource, mipLevel?: number): void;
    createView(): GPUTextureView;
    destroy(): void;
    get memorySize(): number;
}
export interface SamplerDescriptor {
    minFilter?: GPUFilterMode;
    magFilter?: GPUFilterMode;
    mipmapFilter?: GPUMipmapFilterMode;
    addressModeU?: GPUAddressMode;
    addressModeV?: GPUAddressMode;
    addressModeW?: GPUAddressMode;
    maxAnisotropy?: number;
    compare?: GPUCompareFunction;
    label?: string;
}
export declare class Sampler {
    readonly sampler: GPUSampler;
    constructor(device: GPUDevice, descriptor: SamplerDescriptor);
    destroy(): void;
}
export declare function createLinearSampler(device: GPUDevice): Sampler;
export declare function createNearestSampler(device: GPUDevice): Sampler;
export declare function createClampSampler(device: GPUDevice): Sampler;
export declare function createRepeatSampler(device: GPUDevice): Sampler;
export declare class ShaderModule {
    protected readonly device: GPUDevice;
    readonly module: GPUShaderModule;
    constructor(device: GPUDevice, descriptor: {
        code: string;
        label?: string;
    });
    get compilationInfo(): Promise<GPUCompilationInfo>;
}
export interface PipelineDescriptor {
    vertex: {
        module: ShaderModule;
        entryPoint: string;
        buffers: GPUVertexBufferLayout[];
    };
    fragment?: {
        module: ShaderModule;
        entryPoint: string;
        targets: GPUColorTargetState[];
    };
    primitive?: GPUPrimitiveState;
    depthStencil?: GPUDepthStencilState;
    multisample?: GPUMultisampleState;
    layout: GPUPipelineLayout | 'auto';
    label?: string;
}
export declare class RenderPipeline {
    protected readonly device: GPUDevice;
    readonly pipeline: GPURenderPipeline;
    constructor(device: GPUDevice, descriptor: PipelineDescriptor);
    get layout(): GPUPipelineLayout;
    destroy(): void;
}
export declare class ComputePipeline {
    protected readonly device: GPUDevice;
    readonly pipeline: GPUComputePipeline;
    constructor(device: GPUDevice, descriptor: {
        compute: {
            module: ShaderModule;
            entryPoint: string;
        };
        layout: GPUPipelineLayout | 'auto';
        label?: string;
    });
    get layout(): GPUPipelineLayout;
    destroy(): void;
}
export interface BindGroupLayoutDescriptor {
    entries: {
        binding: number;
        visibility: GPUShaderStageFlags;
        buffer?: GPUBufferBindingLayout;
        texture?: GPUTextureBindingLayout;
        sampler?: GPUSamplerBindingLayout;
        storageTexture?: GPUStorageTextureBindingLayout;
    }[];
    label?: string;
}
export declare class BindGroupLayout {
    protected readonly device: GPUDevice;
    readonly layout: GPUBindGroupLayout;
    constructor(device: GPUDevice, descriptor: BindGroupLayoutDescriptor);
}
export interface BindGroupEntry {
    binding: number;
    resource: GPUBufferResource | GPUTextureView | Sampler | GPUBindingResource;
}
export declare class BindGroup {
    protected readonly device: GPUDevice;
    readonly bindGroup: GPUBindGroup;
    constructor(device: GPUDevice, layout: BindGroupLayout, entries: BindGroupEntry[], label?: string);
    destroy(): void;
}
export declare class BindGroupBuilder {
    private label?;
    private entries;
    constructor(label?: string | undefined);
    addUniformBuffer(binding: number, visibility: GPUShaderStageFlags): this;
    addStorageBuffer(binding: number, visibility: GPUShaderStageFlags, type?: GPUBufferBindingType): this;
    addTexture(binding: number, visibility: GPUShaderStageFlags, sampleType?: GPUTextureSampleType, viewDimension?: GPUTextureViewDimension): this;
    addSampler(binding: number, visibility: GPUShaderStageFlags, type?: GPUSamplerBindingType): this;
    build(device: GPUDevice): BindGroupLayout;
}
export declare class RenderPassDescriptorBuilder {
    private descriptor;
    constructor();
    setColorAttachment(index: number, view: GPUTextureView, options?: {
        loadOp?: GPULoadOp;
        storeOp?: GPUStoreOp;
        clearValue?: GPUColor;
    }): this;
    setDepthStencilAttachment(view: GPUTextureView, options?: {
        depthLoadOp?: GPULoadOp;
        depthStoreOp?: GPUStoreOp;
        depthClearValue?: number;
        stencilLoadOp?: GPULoadOp;
        stencilStoreOp?: GPUStoreOp;
        stencilClearValue?: number;
    }): this;
    build(): GPURenderPassDescriptor;
}
export declare function createRenderPassDescriptor(): RenderPassDescriptorBuilder;
//# sourceMappingURL=resources.d.ts.map