arcanumcube/dist/types/webgl.d.ts

Arcanum Cube

import * as THREE from 'three';
import { Cube, ArcanumCube } from './core.js';
import type { Twist, Sticker } from './core.js';
import { type Skin } from './skins.js';
export declare const CUBE_SIDE_LEN = 1.9;
export type TwistOptions = {
    onStart?: (self: WebGLArcanumCube) => void;
    onTwisted?: (self: WebGLArcanumCube, twist: Twist, step: number, total: number) => void;
    onComplete?: (self: WebGLArcanumCube) => void;
    onSolved?: (self: WebGLArcanumCube) => void;
};
type WebGLSticker = Sticker & {
    mesh?: THREE.Mesh;
};
export type WebGLCubeConfig = {
    scale: number;
    stickerScale: number;
    gap: number;
    enableShadow: boolean;
    skin: Skin;
    envMap?: THREE.Texture;
    wireframe: boolean;
    wireframeColor: THREE.ColorRepresentation;
};
declare class WebGLCube extends Cube {
    protected _stickers: WebGLSticker[];
    private _config;
    private _skin;
    private _group;
    private _entityGroup;
    private _outlineGroup;
    constructor(x: number, y: number, z: number, opts?: Partial<WebGLCubeConfig>);
    getGroup(): THREE.Group;
    setStickerScale(scale: number): void;
    setGap(gap: number): void;
    getStickers(): WebGLSticker[];
    getEntityGroup(): THREE.Group;
    getOutlineGroup(): THREE.Group;
    init(): void;
    stretch(strength: number): void;
    enableShadow(flag: boolean): void;
    select(flag?: boolean): void;
    activate(): void;
    deactivate(): void;
}
export type WebGLArcanumCubeConfig = {
    debug: boolean;
    scale: number;
    stickerScale: number;
    gap: number;
    enableShadow: boolean;
    skin: Skin;
    envMap?: THREE.Texture;
    showSelectedCube: boolean;
    showTwistGroup: boolean;
    enableCoreLight: boolean;
    coreLightColor: THREE.ColorRepresentation;
    coreLightIntensity: number;
    wireframe: boolean;
    wireframeColor: THREE.ColorRepresentation;
    twistOptions?: TwistOptions;
};
/** Arcanum Cube object for WebGL class */
export declare class WebGLArcanumCube extends ArcanumCube {
    /** config */
    private _config;
    /** cube objects matrix */
    protected _matrix: WebGLCube[][][];
    /** WebGL THREE.js Group */
    private _group;
    /** cube meshes */
    private _cubeObjectList;
    /** cube map */
    private _cubeMap;
    /** selected cube */
    private _selectedCube?;
    /** selected sticker */
    private _selectedSticker?;
    /** current rotating group */
    private _twistGroup?;
    /** dragging state */
    private _draggingTwist?;
    /** max degree to cancel the dragging */
    private _cancelDragDeg;
    /** easing group */
    private _easings;
    /** light at the center of cube */
    private _coreLights;
    /** status of locking the twist */
    private _lockTwist;
    constructor(options?: Partial<WebGLArcanumCubeConfig>);
    getGroup(): THREE.Group;
    getCubeObjectList(): THREE.Group[];
    init(): Promise<void>;
    private _init;
    setSkin(skin: Skin): Promise<void>;
    lockTwist(flag: boolean): void;
    isTwisting(): boolean;
    reset(duration?: number): void;
    selectedCube(): WebGLCube | undefined;
    selectedSticker(): WebGLSticker | undefined;
    getCubeFromObject(object: THREE.Object3D): WebGLCube | undefined;
    getStickerFromMesh(mesh: THREE.Object3D, cube?: WebGLCube): WebGLSticker | undefined;
    selectCube(cube?: WebGLCube): void;
    deselectCube(): void;
    selectSticker(mesh: THREE.Object3D): void;
    deselectSticker(): void;
    getMovementList(sticker: WebGLSticker, position: [x: number, y: number, z: number]): {
        twist: Twist;
        normal: [number, number, number];
    }[];
    private _reconstructGroups;
    dragTwist(twist: Twist, rad: number): void;
    dragTwistEnd(): void;
    scramble(steps?: number, duration?: number): void;
    undo(steps?: number, duration?: number): void;
    easingTwist(twist: Twist | Twist[], reverse?: boolean, duration?: number, cancel?: boolean, options?: TwistOptions): void;
    private _immediatelyTwist;
    private _easingTwist;
    update(): void;
    setCoreLightColor(color: THREE.ColorRepresentation): void;
    setCoreLightIntensity(intensity: number): void;
}
export {};