@tresjs/core 5.0.0-next.4 → 5.0.0-next.6

package/dist/src/components/TresCanvas.vue.d.ts

@@ -63,6 +63,7 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     onPointermissed?: ((event: PointerEvent<MouseEvent>) => any) | undefined;
     onBeforeLoop?: ((context: TresContextWithClock) => any) | undefined;
 }>, {
+    windowSize: boolean;
     antialias: boolean;
     stencil: boolean;
     depth: boolean;
@@ -77,7 +78,6 @@ declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<Tr
     shadowMapType: THREE.ShadowMapType;
     useLegacyLights: boolean;
     renderMode: "always" | "on-demand" | "manual";
-    windowSize: boolean;
     enableProvideBridge: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     canvasRef: HTMLCanvasElement;

package/dist/src/composables/index.d.ts

@@ -5,5 +5,5 @@ export * from './useLoader';
 export * from './useLoop';
 export * from './useRenderer/useRendererManager';
 export * from './useTres';
-export * from './useTresContextProvider';
+export { type TresContext, useTresContext, useTresContextProvider } from './useTresContextProvider';
 export { UseLoader };

package/dist/src/composables/useCreateRafLoop/index.d.ts

@@ -2,17 +2,13 @@ export interface RafLoopContext {
     delta: number;
     elapsed: number;
 }
-type LoopFunction = (notifySuccess: () => void) => void;
 /**
- * @param defaultFunction the default function that is called before after the after event hook is triggered and after the before is triggered.
- * @param notifySuccess a callback that should be called to indicate a successfull cycle.
+ * @param cycleFn the function that is called before the after event hook is triggered and after the before event hook is triggered.
  */
-export declare const useCreateRafLoop: (defaultFunction: LoopFunction, notifySuccess: () => void) => {
+export declare const useCreateRafLoop: (cycleFn: () => void) => {
     start: () => void;
     stop: () => void;
     isActive: Readonly<import('vue').ShallowRef<boolean>>;
     onBeforeLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
     onLoop: import('@vueuse/core').EventHookOn<RafLoopContext>;
-    replaceLoopFunction: (fn: LoopFunction) => void;
 };
-export {};

package/dist/src/composables/useGraph/index.d.ts

@@ -1,4 +1,3 @@
-import { Object3D } from 'three';
 import { MaybeRef } from '@vueuse/core';
 import { TresObject } from '../../types';
-export declare function useGraph(object: MaybeRef<Object3D | TresObject>): import('vue').ComputedRef<import('../..').TresObjectMap>;
+export declare function useGraph(object: MaybeRef<TresObject>): import('vue').ComputedRef<import('../..').TresObjectMap>;

package/dist/src/composables/useLoop/index.d.ts

@@ -10,5 +10,5 @@ export declare const useLoop: () => {
     isActive: Readonly<import('vue').ShallowRef<boolean>>;
     onBeforeRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
     onRender: import('../../utils/createPriorityEventHook').PriorityEventHookOn<LoopContext>;
-    render: (fn: (notifySuccess: () => void) => void) => void;
+    render: (fn: import('..').RenderFunction) => void;
 };

package/dist/src/composables/useRenderer/useRendererManager.d.ts

@@ -11,6 +11,7 @@ import { TresScene } from '../../types';
  * If set to 'always', the scene will be rendered every frame
  */
 export type RenderMode = 'always' | 'on-demand' | 'manual';
+export type RenderFunction = (notifySuccess: () => void) => void;
 export type TresRenderer = WebGLRenderer | Renderer;
 export interface RendererOptions {
     /**
@@ -180,7 +181,6 @@ export declare function useRendererManager({ scene, canvas, options, contextPart
         isActive: Readonly<ShallowRef<boolean>>;
         onBeforeLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
         onLoop: import('@vueuse/core').EventHookOn<import('../useCreateRafLoop').RafLoopContext>;
-        replaceLoopFunction: (fn: (notifySuccess: () => void) => void) => void;
     };
     instance: TresRenderer;
     advance: () => void;
@@ -189,5 +189,6 @@ export declare function useRendererManager({ scene, canvas, options, contextPart
     invalidate: (amountOfFramesToInvalidate?: number) => void;
     canBeInvalidated: import('vue').ComputedRef<boolean>;
     mode: "always" | "on-demand" | "manual" | undefined;
+    replaceRenderFunction: (fn: RenderFunction) => void;
 };
 export type UseRendererManagerReturn = ReturnType<typeof useRendererManager>;

package/dist/src/composables/useTresContextProvider/index.d.ts

@@ -13,10 +13,12 @@ export interface TresContext {
     renderer: UseRendererManagerReturn;
     events: ReturnType<typeof useEventManager>;
 }
-export declare function useTresContextProvider({ scene, canvas, windowSize, rendererOptions, }: {
+export declare const INJECTION_KEY = "useTres";
+declare const useTresContextProvider: (args_0: {
     scene: TresScene;
     canvas: MaybeRef<HTMLCanvasElement>;
     windowSize: MaybeRefOrGetter<boolean>;
     rendererOptions: RendererOptions;
-}): TresContext;
-export declare function useTresContext(): TresContext;
+}) => TresContext;
+declare const useTresContext: () => TresContext;
+export { useTresContext, useTresContextProvider };

package/dist/src/types/index.d.ts

@@ -57,6 +57,12 @@ export interface TresObject3D extends THREE.Object3D<THREE.Object3DEventMap> {
 export type TresObject = TresBaseObject & (TresObject3D | THREE.BufferGeometry | THREE.Material | THREE.Fog) & {
     __tres?: LocalState;
 };
+/**
+ * Union type covering all common Three.js material types
+ * This provides better TypeScript intellisense and type checking
+ * when accessing specific material properties
+ */
+export type TresMaterial = THREE.MeshBasicMaterial | THREE.MeshStandardMaterial | THREE.MeshPhysicalMaterial | THREE.MeshLambertMaterial | THREE.MeshPhongMaterial | THREE.MeshToonMaterial | THREE.MeshNormalMaterial | THREE.MeshMatcapMaterial | THREE.MeshDepthMaterial | THREE.MeshDistanceMaterial | THREE.LineBasicMaterial | THREE.LineDashedMaterial | THREE.PointsMaterial | THREE.SpriteMaterial | THREE.ShaderMaterial | THREE.RawShaderMaterial | THREE.ShadowMaterial | THREE.Material;
 export type TresInstance = TresObject & {
     __tres: LocalState;
 };

package/dist/src/utils/graph.d.ts

@@ -1,14 +1,15 @@
-import { Material, Mesh, Object3D, Scene } from 'three';
+import { Mesh, Scene } from 'three';
+import { TresMaterial, TresObject } from '../types';
 export interface TresObjectMap {
     nodes: {
-        [name: string]: Object3D;
+        [name: string]: TresObject;
     };
     materials: {
-        [name: string]: Material;
+        [name: string]: TresMaterial;
     };
     meshes: {
         [name: string]: Mesh;
     };
     scene?: Scene;
 }
-export declare function buildGraph(object: Object3D): TresObjectMap;
+export declare function buildGraph(object: TresObject): TresObjectMap;