@tresjs/core
Version:
Declarative ThreeJS using Vue Components
75 lines (74 loc) • 2.78 kB
TypeScript
import { Camera, WebGLRenderer, Raycaster } from 'three';
import { ComputedRef, DeepReadonly, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
import { RendererLoop } from '../../core/loop';
import { EmitEventFn, TresControl, TresObject, TresScene } from '../../types';
import { UseRendererOptions } from '../useRenderer';
import { SizesType } from '../useSizes';
import { TresEventManager } from '../useTresEventManager';
export interface InternalState {
priority: Ref<number>;
frames: Ref<number>;
maxFrames: number;
}
export interface RenderState {
/**
* If set to 'on-demand', the scene will only be rendered when the current frame is invalidated
* If set to 'manual', the scene will only be rendered when advance() is called
* If set to 'always', the scene will be rendered every frame
*/
mode: Ref<'always' | 'on-demand' | 'manual'>;
priority: Ref<number>;
frames: Ref<number>;
maxFrames: number;
canBeInvalidated: ComputedRef<boolean>;
}
export interface PerformanceState {
maxFrames: number;
fps: {
value: number;
accumulator: number[];
};
memory: {
currentMem: number;
allocatedMem: number;
accumulator: number[];
};
}
export interface TresContext {
scene: ShallowRef<TresScene>;
sizes: SizesType;
extend: (objects: any) => void;
camera: ComputedRef<Camera | undefined>;
cameras: DeepReadonly<Ref<Camera[]>>;
controls: Ref<TresControl | null>;
renderer: ShallowRef<WebGLRenderer>;
raycaster: ShallowRef<Raycaster>;
perf: PerformanceState;
render: RenderState;
loop: RendererLoop;
/**
* Invalidates the current frame when renderMode === 'on-demand'
*/
invalidate: () => void;
/**
* Advance one frame when renderMode === 'manual'
*/
advance: () => void;
registerCamera: (maybeCamera: unknown) => void;
setCameraActive: (cameraOrUuid: Camera | string) => void;
deregisterCamera: (maybeCamera: unknown) => void;
eventManager?: TresEventManager;
registerObjectAtPointerEventHandler?: (object: TresObject) => void;
deregisterObjectAtPointerEventHandler?: (object: TresObject) => void;
registerBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
deregisterBlockingObjectAtPointerEventHandler?: (object: TresObject) => void;
}
export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, emit, }: {
scene: TresScene;
canvas: MaybeRef<HTMLCanvasElement>;
windowSize: MaybeRefOrGetter<boolean>;
rendererOptions: UseRendererOptions;
emit: EmitEventFn;
}): TresContext;
export declare function useTresContext(): TresContext;
export declare const useTres: typeof useTresContext;