@octanejs/drei 0.0.1

package/src/core/catalog-textures.three.tsrx

@@ -0,0 +1,105 @@
+import { useLayoutEffect, useMemo, use } from '@octanejs/three/renderer';
+import { RepeatWrapping, type Texture, Vector2 } from 'three';
+import { slotDefault } from './compiler-slot.js';
+import { resolveRenderChildren, type RenderChildren } from './octane-children.js';
+import { resourcePromise } from './resource.js';
+import { useTexture } from './Texture.three.tsrx';
+import {
+	loadCatalogList,
+	MATCAP_LIST_URL,
+	MATCAP_ROOT,
+	NORMAL_LIST_URL,
+	NORMAL_ROOT,
+} from './catalog-resource.js';
+
+function getFormatString(format: number) {
+	switch (format) {
+		case 64:
+			return '-64px';
+		case 128:
+			return '-128px';
+		case 256:
+			return '-256px';
+		case 512:
+			return '-512px';
+		default:
+			return '';
+	}
+}
+
+export function useMatcapTexture(
+	id: number | string = 0,
+	format = 1024,
+	onLoad?: (texture: Texture | Texture[]) => void,
+): [Texture, string, number] {
+	id = slotDefault(id, 0);
+	format = slotDefault(format, 1024);
+	onLoad = slotDefault(onLoad, undefined);
+	const matcapList = use(resourcePromise(loadCatalogList, [MATCAP_LIST_URL]));
+	const defaultMatcap = matcapList[0];
+	const total = useMemo(() => Object.keys(matcapList).length, []);
+	const fileHash = useMemo(() => {
+		if (typeof id === 'string') return id;
+		if (typeof id === 'number') return matcapList[id];
+		return null;
+	}, [id]);
+	const fileName = `${fileHash || defaultMatcap}${getFormatString(format)}.png`;
+	const url = `${MATCAP_ROOT}/${format}/${fileName}`;
+	const texture = useTexture(url, onLoad) as Texture;
+	return [texture, url, total];
+}
+
+export function MatcapTexture({
+	children,
+	id,
+	format,
+	onLoad,
+}: {
+	children?: RenderChildren<ReturnType<typeof useMatcapTexture>>;
+	id?: Parameters<typeof useMatcapTexture>[0];
+	format?: Parameters<typeof useMatcapTexture>[1];
+	onLoad?: Parameters<typeof useMatcapTexture>[2];
+}) @{
+	const texture = useMatcapTexture(id, format, onLoad);
+	<>{resolveRenderChildren(children, texture)}</>
+}
+
+type Settings = {
+	repeat?: number[];
+	anisotropy?: number;
+	offset?: number[];
+};
+
+export function useNormalTexture(
+	id = 0,
+	settings: Settings = {},
+	onLoad?: (texture: Texture | Texture[]) => void,
+): [Texture, string, number] {
+	id = slotDefault(id, 0);
+	settings = slotDefault(settings, {});
+	onLoad = slotDefault(onLoad, undefined);
+	const { repeat = [1, 1], anisotropy = 1, offset = [0, 0] } = settings;
+	const normalsList = use(resourcePromise(loadCatalogList, [NORMAL_LIST_URL]));
+	const total = useMemo(() => Object.keys(normalsList).length, []);
+	const defaultNormal = normalsList[0];
+	const imageName = normalsList[id] || defaultNormal;
+	const url = `${NORMAL_ROOT}/normals/${imageName}`;
+	const texture = useTexture(url, onLoad) as Texture;
+	useLayoutEffect(() => {
+		if (!texture) return;
+		texture.wrapS = texture.wrapT = RepeatWrapping;
+		texture.repeat = new Vector2(repeat[0], repeat[1]);
+		texture.offset = new Vector2(offset[0], offset[1]);
+		texture.anisotropy = anisotropy;
+	}, [texture, anisotropy, repeat, offset]);
+	return [texture, url, total];
+}
+
+export function NormalTexture({ children, id, onLoad, ...settings }: {
+	children?: RenderChildren<ReturnType<typeof useNormalTexture>>;
+	id?: Parameters<typeof useNormalTexture>[0];
+	onLoad?: Parameters<typeof useNormalTexture>[2];
+} & Settings) @{
+	const value = useNormalTexture(id, settings, onLoad);
+	<>{resolveRenderChildren(children, value)}</>
+}

package/src/core/compiler-slot.ts

@@ -0,0 +1,9 @@
+/** Restore an omitted optional argument when the TSRX compiler supplied its call-site slot. */
+export function slotDefault<T>(value: T, fallback: T): T {
+	return typeof value === 'symbol' ? fallback : value;
+}
+
+/** Remove the TSRX compiler's trailing call-site slot from a variadic argument list. */
+export function stripTrailingSlot<T>(values: T[]): T[] {
+	return typeof values.at(-1) === 'symbol' ? values.slice(0, -1) : values;
+}

package/src/core/effects-utils.ts

@@ -0,0 +1,8 @@
+export function isWebGL2Available(): boolean {
+	try {
+		const canvas = document.createElement('canvas');
+		return Boolean(window.WebGL2RenderingContext && canvas.getContext('webgl2'));
+	} catch {
+		return false;
+	}
+}

package/src/core/environment-loader.ts

@@ -0,0 +1,87 @@
+import { GainMapLoader, HDRJPGLoader } from '@monogrid/gainmap-js';
+import { CubeTextureLoader, type ColorSpace, type Loader } from 'three';
+import { EXRLoader, RGBELoader } from 'three-stdlib';
+
+export const CUBEMAP_ROOT =
+	'https://raw.githack.com/pmndrs/drei-assets/456060a26bbeb8fdf79326f224b6d99b8bcce736/hdri/';
+export const defaultEnvironmentFiles = [
+	'/px.png',
+	'/nx.png',
+	'/py.png',
+	'/ny.png',
+	'/pz.png',
+	'/nz.png',
+];
+
+export const environmentPresets = {
+	apartment: 'lebombo_1k.hdr',
+	city: 'potsdamer_platz_1k.hdr',
+	dawn: 'kiara_1_dawn_1k.hdr',
+	forest: 'forest_slope_1k.hdr',
+	lobby: 'st_fagans_interior_1k.hdr',
+	night: 'dikhololo_night_1k.hdr',
+	park: 'rooitou_park_1k.hdr',
+	studio: 'studio_small_03_1k.hdr',
+	sunset: 'venice_sunset_1k.hdr',
+	warehouse: 'empty_warehouse_01_1k.hdr',
+};
+
+type Preset = keyof typeof environmentPresets;
+
+export interface EnvironmentLoaderProps {
+	files?: string | string[];
+	path?: string;
+	preset?: Preset;
+	extensions?: (loader: Loader) => void;
+	colorSpace?: ColorSpace;
+}
+
+export function validateEnvironmentPreset(preset: string): asserts preset is Preset {
+	if (!(preset in environmentPresets)) {
+		throw new Error(`Preset must be one of: ${Object.keys(environmentPresets).join(', ')}`);
+	}
+}
+
+export function resolveEnvironmentOptions(options: Partial<EnvironmentLoaderProps> = {}) {
+	let files = options.files ?? defaultEnvironmentFiles;
+	let path = options.path ?? '';
+	if (options.preset) {
+		validateEnvironmentPreset(options.preset);
+		files = environmentPresets[options.preset];
+		path = CUBEMAP_ROOT;
+	}
+	return { ...options, files, path };
+}
+
+export function environmentExtension(files: string | string[]) {
+	const multiple = Array.isArray(files);
+	const isCubemap = multiple && files.length === 6;
+	const isGainmap = multiple && files.length === 3 && files.some((file) => file.endsWith('json'));
+	const firstEntry = multiple ? files[0] : files;
+	const extension: string | undefined = isCubemap
+		? 'cube'
+		: isGainmap
+			? 'webp'
+			: firstEntry.startsWith('data:application/exr')
+				? 'exr'
+				: firstEntry.startsWith('data:application/hdr')
+					? 'hdr'
+					: firstEntry.startsWith('data:image/jpeg')
+						? 'jpg'
+						: firstEntry.split('.').pop()?.split('?').shift()?.toLowerCase();
+	return { extension, isCubemap, isGainmap, multiple };
+}
+
+export function environmentLoader(extension: string | undefined) {
+	return extension === 'cube'
+		? CubeTextureLoader
+		: extension === 'hdr'
+			? RGBELoader
+			: extension === 'exr'
+				? EXRLoader
+				: extension === 'jpg' || extension === 'jpeg'
+					? HDRJPGLoader
+					: extension === 'webp'
+						? GainMapLoader
+						: null;
+}

package/src/core/font-resource.ts

@@ -0,0 +1,31 @@
+import { FontLoader } from 'three-stdlib';
+
+export interface Glyph {
+	_cachedOutline: string[];
+	ha: number;
+	o: string;
+}
+
+export interface FontData {
+	boundingBox: { yMax: number; yMin: number };
+	familyName: string;
+	glyphs: { [key: string]: Glyph };
+	resolution: number;
+	underlineThickness: number;
+}
+
+export type FontInput = string | FontData;
+let fontLoader: FontLoader | null = null;
+
+async function loadFontData(font: FontInput): Promise<FontData> {
+	return typeof font === 'string' ? await (await fetch(font)).json() : font;
+}
+
+function parseFontData(fontData: FontData) {
+	fontLoader ??= new FontLoader();
+	return fontLoader.parse(fontData);
+}
+
+export async function loadFont(font: FontInput) {
+	return parseFontData(await loadFontData(font));
+}

package/src/core/gltf-loader.ts

@@ -0,0 +1,33 @@
+import { DRACOLoader, GLTFLoader, MeshoptDecoder } from 'three-stdlib';
+
+export type Path = string | string[];
+export type UseDraco = boolean | string;
+export type UseMeshopt = boolean;
+export type ExtendLoader = (loader: GLTFLoader) => void;
+
+let dracoLoader: DRACOLoader | null = null;
+let decoderPath = 'https://www.gstatic.com/draco/versioned/decoders/1.5.5/';
+
+export function gltfExtensions(
+	useDraco: UseDraco = true,
+	useMeshopt: UseMeshopt = true,
+	extendLoader?: ExtendLoader,
+) {
+	return (loader: GLTFLoader) => {
+		extendLoader?.(loader);
+		if (useDraco) {
+			dracoLoader ??= new DRACOLoader();
+			dracoLoader.setDecoderPath(typeof useDraco === 'string' ? useDraco : decoderPath);
+			loader.setDRACOLoader(dracoLoader);
+		}
+		if (useMeshopt) {
+			loader.setMeshoptDecoder(
+				typeof MeshoptDecoder === 'function' ? MeshoptDecoder() : MeshoptDecoder,
+			);
+		}
+	};
+}
+
+export function setGltfDecoderPath(path: string): void {
+	decoderPath = path;
+}

package/src/core/gradient-types.ts

@@ -0,0 +1,4 @@
+export enum GradientType {
+	Linear = 'linear',
+	Radial = 'radial',
+}

package/src/core/index.ts

@@ -0,0 +1,295 @@
+export { calculateScaleFactor } from './calculateScaleFactor.js';
+export { meshBounds } from './meshBounds.js';
+export { shaderMaterial } from './shaderMaterial.js';
+export { RoundedBox, RoundedBoxGeometry } from './RoundedBox.three.tsrx';
+export type { RoundedBoxGeometryProps, RoundedBoxProps } from './RoundedBox.three.tsrx';
+export { GizmoViewcube } from './GizmoViewcube.three.tsrx';
+export { GizmoViewport } from './GizmoViewport.three.tsrx';
+export { useContextBridge } from './useContextBridge.three.tsrx';
+export { Text } from './Text.three.tsrx';
+export type { TextProps } from './Text.three.tsrx';
+export { MeshRefractionMaterial } from './MeshRefractionMaterial.three.tsrx';
+export type { MeshRefractionMaterialProps } from './MeshRefractionMaterial.three.tsrx';
+export { MeshReflectorMaterial } from './MeshReflectorMaterial.three.tsrx';
+export type { MeshReflectorMaterialProps } from './MeshReflectorMaterial.three.tsrx';
+export { Wireframe } from './Wireframe.three.tsrx';
+export { Caustics } from './Caustics.three.tsrx';
+export type { CausticsProps } from './Caustics.three.tsrx';
+export { MeshTransmissionMaterial } from './MeshTransmissionMaterial.three.tsrx';
+export type { MeshTransmissionMaterialProps } from './MeshTransmissionMaterial.three.tsrx';
+export { MeshPortalMaterial } from './MeshPortalMaterial.three.tsrx';
+export type { PortalProps } from './MeshPortalMaterial.three.tsrx';
+export {
+	Box,
+	Capsule,
+	Circle,
+	Cone,
+	Cylinder,
+	Dodecahedron,
+	Extrude,
+	Icosahedron,
+	Lathe,
+	Octahedron,
+	Plane,
+	Polyhedron,
+	Ring,
+	Shape,
+	Sphere,
+	Tetrahedron,
+	Torus,
+	TorusKnot,
+	Tube,
+} from './shapes.three.tsrx';
+export type { Args, ShapeProps } from './shapes.three.tsrx';
+export { Progress, useProgress } from './Progress.three.tsrx';
+export { IsObject, Texture, useTexture } from './Texture.three.tsrx';
+export type { MappedTextureType } from './Texture.three.tsrx';
+export { CubeTexture, useCubeTexture } from './CubeTexture.three.tsrx';
+export type { CubeTextureOptions, CubeTextureProps } from './CubeTexture.three.tsrx';
+export { Ktx2, useKTX2 } from './Ktx2.three.tsrx';
+export { useFont } from './useFont.three.tsrx';
+export type { FontData, Glyph } from './useFont.three.tsrx';
+export { Clone } from './Clone.three.tsrx';
+export type { CloneProps } from './Clone.three.tsrx';
+export { Gltf, useGLTF } from './Gltf.three.tsrx';
+export type { GltfProps } from './Gltf.three.tsrx';
+export { Fbx, useFBX } from './Fbx.three.tsrx';
+export { useEnvironment } from './useEnvironment.three.tsrx';
+export type { EnvironmentLoaderProps } from './environment-loader.js';
+export { useAspect } from './useAspect.three.tsrx';
+export { AdaptiveDpr, AdaptiveEvents, BakeShadows } from './AdaptivePerformance.three.tsrx';
+export { ScreenSpace } from './ScreenSpace.three.tsrx';
+export type { ScreenSpaceProps } from './ScreenSpace.three.tsrx';
+export { Detailed } from './Detailed.three.tsrx';
+export type { DetailedProps } from './Detailed.three.tsrx';
+export { ComputedAttribute } from './ComputedAttribute.three.tsrx';
+export type { ComputedAttributeProps } from './ComputedAttribute.three.tsrx';
+export { MultiMaterial } from './MultiMaterial.three.tsrx';
+export type { MultiMaterialProps } from './MultiMaterial.three.tsrx';
+export { useCamera } from './useCamera.three.tsrx';
+export { useIntersect } from './useIntersect.three.tsrx';
+export {
+	Mask,
+	MeshDiscardMaterial,
+	PointMaterial,
+	PointMaterialImpl,
+	ScreenQuad,
+	useMask,
+} from './simple-materials.three.tsrx';
+export { Backdrop, BBAnchor, Billboard, Float } from './scene-motion.three.tsrx';
+export type {
+	BackdropProps,
+	BBAnchorProps,
+	BillboardProps,
+	FloatProps,
+} from './scene-motion.three.tsrx';
+export { Fbo, useFBO } from './Fbo.three.tsrx';
+export type { FboProps } from './Fbo.three.tsrx';
+export {
+	CubeCamera,
+	OrthographicCamera,
+	PerspectiveCamera,
+	useCubeCamera,
+} from './cameras.three.tsrx';
+export { useDepthBuffer } from './useDepthBuffer.three.tsrx';
+export {
+	MatcapTexture,
+	NormalTexture,
+	useMatcapTexture,
+	useNormalTexture,
+} from './catalog-textures.three.tsrx';
+export { GradientTexture, GradientType } from './GradientTexture.three.tsrx';
+export type { GradientTextureProps } from './GradientTexture.three.tsrx';
+export {
+	CatmullRomLine,
+	CubicBezierLine,
+	Edges,
+	Line,
+	QuadraticBezierLine,
+} from './lines.three.tsrx';
+export {
+	ArcballControls,
+	DeviceOrientationControls,
+	FirstPersonControls,
+	FlyControls,
+	MapControls,
+	OrbitControls,
+	TrackballControls,
+} from './basic-controls.three.tsrx';
+export { PointerLockControls } from './PointerLockControls.three.tsrx';
+export type { PointerLockControlsProps } from './PointerLockControls.three.tsrx';
+export { Center } from './Center.three.tsrx';
+export type { CenterProps, OnCenterCallbackProps } from './Center.three.tsrx';
+export { Bounds, useBounds } from './Bounds.three.tsrx';
+export type { BoundsApi, BoundsProps, SizeProps } from './Bounds.three.tsrx';
+export { useAnimations } from './useAnimations.three.tsrx';
+export { useBoxProjectedEnv } from './useBoxProjectedEnv.three.tsrx';
+export { Resize } from './Resize.three.tsrx';
+export type { ResizeProps } from './Resize.three.tsrx';
+export { CameraShake } from './CameraShake.three.tsrx';
+export type { CameraShakeProps, ShakeController } from './CameraShake.three.tsrx';
+export { Decal } from './Decal.three.tsrx';
+export type { DecalProps } from './Decal.three.tsrx';
+export { Shadow, ShadowAlpha } from './shadows.three.tsrx';
+export type { ShadowAlphaProps, ShadowProps, ShadowType } from './shadows.three.tsrx';
+export { Grid } from './Grid.three.tsrx';
+export type { GridMaterialType, GridProps } from './Grid.three.tsrx';
+export { Helper, useHelper } from './Helper.three.tsrx';
+export type { HelperProps } from './Helper.three.tsrx';
+export { ScreenSizer } from './ScreenSizer.three.tsrx';
+export type { ScreenSizerProps } from './ScreenSizer.three.tsrx';
+export { Preload } from './Preload.three.tsrx';
+export type { PreloadProps } from './Preload.three.tsrx';
+export { Bvh, useBVH } from './Bvh.three.tsrx';
+export type { BVHOptions, BvhProps } from './Bvh.three.tsrx';
+export { Sky, calcPosFromAngles } from './Sky.three.tsrx';
+export type { SkyProps } from './Sky.three.tsrx';
+export { checkIfFrameIsEmpty, getFirstFrame, useSpriteLoader } from './useSpriteLoader.three.tsrx';
+export type { FrameData, MetaData, Size, SpriteData } from './useSpriteLoader.three.tsrx';
+export { SpriteAnimator, useSpriteAnimator } from './SpriteAnimator.three.tsrx';
+export type { SpriteAnimatorProps } from './SpriteAnimator.three.tsrx';
+export { SpotLight, SpotLightShadow } from './SpotLight.three.tsrx';
+export type { SpotLightProps } from './SpotLight.three.tsrx';
+export { Splat } from './Splat.three.tsrx';
+export type { SharedState, SplatMaterialType, SplatProps, TargetMesh } from './Splat.three.tsrx';
+export { Lightformer } from './Lightformer.three.tsrx';
+export type { LightProps } from './Lightformer.three.tsrx';
+export { MeshDistortMaterial, MeshWobbleMaterial } from './motion-materials.three.tsrx';
+export type { MeshDistortMaterialProps, WobbleMaterialProps } from './motion-materials.three.tsrx';
+export { isWebGL2Available } from './effects-utils.js';
+export { Effects } from './Effects.three.tsrx';
+export type { EffectsProps } from './Effects.three.tsrx';
+export { Hud } from './Hud.three.tsrx';
+export type { HudProps } from './Hud.three.tsrx';
+export { Sparkles } from './Sparkles.three.tsrx';
+export type { SparklesProps } from './Sparkles.three.tsrx';
+export { CurveModifier } from './CurveModifier.three.tsrx';
+export type { CurveModifierProps, CurveModifierRef } from './CurveModifier.three.tsrx';
+export { Stars } from './Stars.three.tsrx';
+export type { StarsProps } from './Stars.three.tsrx';
+export { Segment, SegmentObject, Segments } from './Segments.three.tsrx';
+export type { SegmentProps, SegmentsProps } from './Segments.three.tsrx';
+export { MarchingCube, MarchingCubes, MarchingPlane } from './MarchingCubes.three.tsrx';
+export type {
+	MarchingCubeProps,
+	MarchingCubesProps,
+	MarchingPlaneProps,
+} from './MarchingCubes.three.tsrx';
+export { PositionalAudio } from './PositionalAudio.three.tsrx';
+export type { PositionalAudioProps } from './PositionalAudio.three.tsrx';
+export { AsciiRenderer } from './AsciiRenderer.three.tsrx';
+export type { AsciiRendererProps } from './AsciiRenderer.three.tsrx';
+export { TransformControls } from './TransformControls.three.tsrx';
+export type { TransformControlsProps } from './TransformControls.three.tsrx';
+export { SoftShadows } from './softShadows.three.tsrx';
+export type { SoftShadowsProps } from './softShadows.three.tsrx';
+export { PerformanceMonitor, usePerformanceMonitor } from './PerformanceMonitor.three.tsrx';
+export type {
+	PerformanceMonitorApi,
+	PerformanceMonitorProps,
+} from './PerformanceMonitor.three.tsrx';
+export { CameraControls, CameraControlsImpl } from './CameraControls.three.tsrx';
+export type { CameraControlsProps } from './CameraControls.three.tsrx';
+export { DetectGPU, useDetectGPU } from './DetectGPU.three.tsrx';
+export type { DetectGPUProps } from './DetectGPU.three.tsrx';
+export { Stats } from './Stats.three.tsrx';
+export type { StatsProps } from './Stats.three.tsrx';
+export { StatsGl } from './StatsGl.three.tsrx';
+export type { StatsGlProps } from './StatsGl.three.tsrx';
+export { VideoTexture, useVideoTexture } from './VideoTexture.three.tsrx';
+export type { VideoTextureProps } from './VideoTexture.three.tsrx';
+export { TrailTexture, useTrailTexture } from './TrailTexture.three.tsrx';
+export type { TrailTextureProps } from './TrailTexture.three.tsrx';
+export { Point, Points, PointsBuffer, PositionPoint } from './Points.three.tsrx';
+export type { PointsBuffersProps, PointsInstancesProps } from './Points.three.tsrx';
+export {
+	createInstances,
+	Instance,
+	InstancedAttribute,
+	Instances,
+	Merged,
+	PositionMesh,
+} from './Instances.three.tsrx';
+export type {
+	InstanceProps,
+	InstancedAttributeProps,
+	InstancesProps,
+	MergedProps,
+} from './Instances.three.tsrx';
+export { Sampler, useSurfaceSampler } from './Sampler.three.tsrx';
+export type { SamplerProps, TransformFn, useSurfaceSamplerProps } from './Sampler.three.tsrx';
+export { Cloud, CloudInstance, Clouds } from './Cloud.three.tsrx';
+export type { CloudProps, CloudsProps } from './Cloud.three.tsrx';
+export { Trail, useTrail } from './Trail.three.tsrx';
+export type { MeshLineGeometry, TrailProps } from './Trail.three.tsrx';
+export {
+	Environment,
+	EnvironmentCube,
+	EnvironmentMap,
+	EnvironmentPortal,
+} from './Environment.three.tsrx';
+export type { EnvironmentProps } from './Environment.three.tsrx';
+export { Text3D } from './Text3D.three.tsrx';
+export type { Text3DProps } from './Text3D.three.tsrx';
+export { Example } from './Example.three.tsrx';
+export type { ExampleApi, ExampleProps } from './Example.three.tsrx';
+export { Svg } from './Svg.three.tsrx';
+export type { SvgProps } from './Svg.three.tsrx';
+export { RenderTexture } from './RenderTexture.three.tsrx';
+export type { RenderTextureProps } from './RenderTexture.three.tsrx';
+export { RenderCubeTexture } from './RenderCubeTexture.three.tsrx';
+export type { RenderCubeTextureApi, RenderCubeTextureProps } from './RenderCubeTexture.three.tsrx';
+export { Fisheye } from './Fisheye.three.tsrx';
+export type { FisheyeProps } from './Fisheye.three.tsrx';
+export { Outlines } from './Outlines.three.tsrx';
+export type { OutlinesProps } from './Outlines.three.tsrx';
+export { ContactShadows } from './ContactShadows.three.tsrx';
+export type { ContactShadowsProps } from './ContactShadows.three.tsrx';
+export {
+	AccumulativeShadows,
+	RandomizedLight,
+	accumulativeContext,
+} from './AccumulativeShadows.three.tsrx';
+export type {
+	AccumulativeShadowsProps,
+	RandomizedLightProps,
+} from './AccumulativeShadows.three.tsrx';
+export { Stage } from './Stage.three.tsrx';
+export type { StageProps } from './Stage.three.tsrx';
+export { Image } from './Image.three.tsrx';
+export type { ImageProps } from './Image.three.tsrx';
+export { MotionPathControls, useMotion } from './MotionPathControls.three.tsrx';
+export type { MotionPathProps, MotionPathRef } from './MotionPathControls.three.tsrx';
+export { GizmoHelper, useGizmoContext } from './GizmoHelper.three.tsrx';
+export type { GizmoHelperProps } from './GizmoHelper.three.tsrx';
+export type {
+	ArcballControlsProps,
+	DeviceOrientationControlsProps,
+	FirstPersonControlsProps,
+	FlyControlsProps,
+	MapControlsProps,
+	OrbitControlsChangeEvent,
+	OrbitControlsProps,
+	TrackballControlsProps,
+} from './basic-controls.three.tsrx';
+export type {
+	CatmullRomLineProps,
+	CubicBezierLineProps,
+	EdgesProps,
+	EdgesRef,
+	LineProps,
+	QuadraticBezierLineProps,
+	QuadraticBezierLineRef,
+} from './lines.three.tsrx';
+export type {
+	CubeCameraOptions,
+	CubeCameraProps,
+	OrthographicCameraProps,
+	PerspectiveCameraProps,
+} from './cameras.three.tsrx';
+export type {
+	MaskProps,
+	MeshDiscardMaterialProps,
+	PointMaterialProps,
+	ScreenQuadProps,
+} from './simple-materials.three.tsrx';