gaesup-world 0.9.785 → 0.9.786

package/dist/types/gaesup/animation/actions.d.ts

@@ -0,0 +1,6 @@
+import { playActionsType, subscribeActionsType } from './type';
+export declare function subscribeActions({ type }: subscribeActionsType): void;
+export default function playActions({ type, actions, animationRef, currentAnimation, isActive }: playActionsType): {
+    animationRef: import("react").Ref<import("three").Object3D<import("three").Object3DEventMap>>;
+    currentAnimation: string;
+};

package/dist/types/gaesup/animation/type.d.ts

@@ -0,0 +1,32 @@
+import { Ref } from 'react';
+import * as THREE from 'three';
+import { AnimationAction, AnimationClip, AnimationMixer, Object3D, Object3DEventMap } from 'three';
+import { groundRayType } from '../controller/type';
+export type Api<T extends AnimationClip> = {
+    ref: React.MutableRefObject<Object3D | undefined | null>;
+    clips: AnimationClip[];
+    mixer: AnimationMixer;
+    names: T['name'][];
+    actions: {
+        [key in T['name']]: AnimationAction | null;
+    };
+};
+export type playActionsType = {
+    type: 'character' | 'vehicle' | 'airplane';
+    currentAnimation?: string;
+    actions: actionsType;
+    animationRef: Ref<Object3D<Object3DEventMap>>;
+    isActive: boolean;
+};
+export type subscribeActionsType = {
+    type: 'character' | 'vehicle' | 'airplane';
+    groundRay: groundRayType;
+    animations: AnimationClip[];
+};
+export type actionsType = {
+    [x: string]: THREE.AnimationAction | null;
+};
+export type playResultType = {
+    actions: actionsType;
+    ref: Ref<Object3D<Object3DEventMap>>;
+};

package/dist/types/gaesup/camera/control/normal.d.ts

@@ -0,0 +1,4 @@
+import { cameraPropType } from "../../physics/type";
+import { activeStateType, cameraOptionType } from "../../world/context/type";
+export declare const makeNormalCameraPosition: (activeState: activeStateType, cameraOption: cameraOptionType) => import("three").Vector3;
+export default function normal(prop: cameraPropType): void;

package/dist/types/gaesup/camera/control/orbit.d.ts

@@ -0,0 +1,4 @@
+import { cameraPropType } from "../../physics/type";
+import { activeStateType, cameraOptionType } from "../../world/context/type";
+export declare const makeOrbitCameraPosition: (activeState: activeStateType, cameraOption: cameraOptionType) => import("three").Vector3;
+export default function orbit(prop: cameraPropType): void;

package/dist/types/gaesup/camera/index.d.ts

@@ -0,0 +1,2 @@
+import { cameraPropType } from "../physics/type";
+export default function Camera(prop: cameraPropType): void;

package/dist/types/gaesup/camera/type.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+export type cameraRayType = {
+    origin: THREE.Vector3;
+    hit: THREE.Raycaster;
+    rayCast: THREE.Raycaster | null;
+    length: number;
+    dir: THREE.Vector3;
+    position: THREE.Vector3;
+    intersects: THREE.Intersection<THREE.Mesh>[];
+    detected: THREE.Intersection<THREE.Mesh>[];
+    intersectObjectMap: {
+        [uuid: string]: THREE.Mesh;
+    };
+};

package/dist/types/gaesup/component/active/airplane/index.d.ts

@@ -0,0 +1,2 @@
+import { activeAirplaneInnerType } from "./type";
+export declare function AirplaneRef(props: activeAirplaneInnerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/active/airplane/type.d.ts

@@ -0,0 +1,3 @@
+import { passiveAirplanePropsType } from "../../passive/airplane/type";
+import { innerRefType } from "../../passive/type";
+export type activeAirplaneInnerType = passiveAirplanePropsType & innerRefType;

package/dist/types/gaesup/component/active/character/index.d.ts

@@ -0,0 +1,8 @@
+import { controllerInnerType, refsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+export declare function CharacterRef({ children, props, refs, urls, }: {
+    children: React.ReactNode;
+    props: controllerInnerType;
+    refs: refsType;
+    urls: urlsType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/active/character/type.d.ts

@@ -0,0 +1,12 @@
+import { RigidBodyTypeString } from "@react-three/rapier";
+import * as THREE from "three";
+import { controllerOptionsType } from "../../../controller/type";
+export type activeCharacterPropsType = {
+    characterUrl: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    controllerOptions?: controllerOptionsType;
+    currentAnimation?: string;
+    children?: React.ReactNode;
+    rigidbodyType?: RigidBodyTypeString;
+};

package/dist/types/gaesup/component/active/vehicle/index.d.ts

@@ -0,0 +1,2 @@
+import { activeVehicleInnerType } from "./type";
+export declare function VehicleRef(props: activeVehicleInnerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/active/vehicle/type.d.ts

@@ -0,0 +1,3 @@
+import { innerRefType } from "../../passive/type";
+import { passiveVehiclePropsType } from "../../passive/vehicle/type";
+export type activeVehicleInnerType = passiveVehiclePropsType & innerRefType;

package/dist/types/gaesup/component/index.d.ts

@@ -0,0 +1,5 @@
+import { controllerInnerType, refsType } from "../controller/type";
+export declare function GaesupComponent({ props, refs, }: {
+    props: controllerInnerType;
+    refs: refsType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/airplane/index.d.ts

@@ -0,0 +1,2 @@
+import { airplaneInnerType } from "./type";
+export declare function AirplaneInnerRef(props: airplaneInnerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/airplane/type.d.ts

@@ -0,0 +1,5 @@
+import { ridingType, rigidBodyRefType } from "../common/type";
+export type airplaneUrlType = {
+    wheelUrl?: string;
+};
+export type airplaneInnerType = rigidBodyRefType & ridingType & airplaneUrlType;

package/dist/types/gaesup/component/inner/character/index.d.ts

@@ -0,0 +1,2 @@
+import { characterInnerType } from "./type";
+export declare function CharacterInnerRef(props: characterInnerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/character/type.d.ts

@@ -0,0 +1,10 @@
+import { callbackType } from "../../../controller/initialize/callback/type";
+import { groundRayType, partsType } from "../../../controller/type";
+import { passiveCharacterPropsType } from "../../passive/character/type";
+import { componentTypeString, innerRefType } from "../../passive/type";
+export type characterInnerType = {
+    componentType: componentTypeString;
+    isActive?: boolean;
+    groundRay: groundRayType;
+    parts?: partsType;
+} & passiveCharacterPropsType & innerRefType & callbackType;

package/dist/types/gaesup/component/inner/common/InnerGroupRef.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+export declare const InnerGroupRef: import("react").ForwardRefExoticComponent<{
+    children?: React.ReactNode;
+    objectNode: THREE.Object3D;
+    animationRef: import("react").MutableRefObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    nodes: {
+        [name: string]: THREE.Object3D<THREE.Object3DEventMap>;
+    };
+    isActive?: boolean;
+    ridingUrl?: string;
+    offset?: THREE.Vector3;
+    parts?: import("../../../controller/type").partsType;
+} & import("./type").ridingType & import("react").RefAttributes<THREE.Group<THREE.Object3DEventMap>>>;

package/dist/types/gaesup/component/inner/common/OuterGroupRef.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export declare const OuterGroupRef: import("react").ForwardRefExoticComponent<{
+    children: ReactNode;
+} & import("react").RefAttributes<unknown>>;

package/dist/types/gaesup/component/inner/common/RigidbodyRef.d.ts

@@ -0,0 +1 @@
+export declare const RigidBodyRef: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<unknown>>;

package/dist/types/gaesup/component/inner/common/calc.d.ts

@@ -0,0 +1,7 @@
+import * as THREE from "three";
+export declare const calcCharacterColliderProps: (characterSize: THREE.Vector3) => {
+    height: number;
+    halfHeight: number;
+    radius: number;
+    diameter: number;
+};

package/dist/types/gaesup/component/inner/common/partsGroupRef.d.ts

@@ -0,0 +1,10 @@
+import * as THREE from "three";
+import { componentTypeString } from "../../passive/type";
+export declare const PartsGroupRef: ({ url, isActive, componentType, currentAnimation, color, skeleton, }: {
+    url: string;
+    isActive: boolean;
+    componentType: componentTypeString;
+    currentAnimation: string;
+    color?: string;
+    skeleton?: THREE.Skeleton;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/common/setGroundRay.d.ts

@@ -0,0 +1,2 @@
+import { setGroundRayType } from "./type";
+export declare function useSetGroundRay(): ({ groundRay, length, colliderRef, }: setGroundRayType) => void;

package/dist/types/gaesup/component/inner/common/type.d.ts

@@ -0,0 +1,62 @@
+import { Collider } from "@dimforge/rapier3d-compat";
+import { RigidBodyProps, RigidBodyTypeString } from "@react-three/rapier";
+import { MutableRefObject, RefObject } from "react";
+import * as THREE from "three";
+import { callbackType } from "../../../controller/initialize/callback/type";
+import { groundRayType, partsType } from "../../../controller/type";
+import { urlsType } from "../../../world/context/type";
+import { innerRefType, passivePropsType } from "../../passive/type";
+export type characterColliderType = {
+    height: number;
+    halfHeight: number;
+    radius: number;
+    diameter: number;
+};
+export type InnerGroupRefType = {
+    children?: React.ReactNode;
+    objectNode: THREE.Object3D;
+    animationRef: MutableRefObject<THREE.Object3D<THREE.Object3DEventMap>>;
+    nodes: {
+        [name: string]: THREE.Object3D<THREE.Object3DEventMap>;
+    };
+    isActive?: boolean;
+    ridingUrl?: string;
+    offset?: THREE.Vector3;
+    parts?: partsType;
+} & ridingType;
+export type ridingType = {
+    isRiderOn?: boolean;
+    enableRiding?: boolean;
+};
+export type refPropsType = {
+    children: React.ReactNode;
+    urls: urlsType;
+    isRiderOn?: boolean;
+    enableRiding?: boolean;
+    offset?: THREE.Vector3;
+    name?: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    userData?: {
+        intangible: boolean;
+    };
+    currentAnimation?: string;
+    type?: RigidBodyTypeString;
+};
+export type setGroundRayType = {
+    groundRay: groundRayType;
+    length: number;
+    colliderRef: RefObject<Collider>;
+};
+export type rigidBodyRefType = {
+    name?: string;
+    userData?: {
+        intangible: boolean;
+    };
+    isActive?: boolean;
+    ridingUrl?: string;
+    groundRay?: groundRayType;
+    rigidBodyProps?: RigidBodyProps;
+    isNotColliding?: boolean;
+    parts?: partsType;
+} & passivePropsType & innerRefType & callbackType;

package/dist/types/gaesup/component/inner/rider/index.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+import * as THREE from "three";
+export type riderRefType = {
+    url: string;
+    children?: ReactNode;
+    offset?: THREE.Vector3;
+    euler?: THREE.Euler;
+    currentAnimation?: string;
+};
+export default function RiderRef({ url, children, offset, currentAnimation, }: riderRefType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/vehicle/collider.d.ts

@@ -0,0 +1,9 @@
+import { Collider } from "@dimforge/rapier3d-compat";
+import * as THREE from "three";
+export declare const VehicleWheelCollider: import("react").ForwardRefExoticComponent<{
+    wheelUrl: string;
+    vehicleSize: THREE.Vector3;
+} & import("react").RefAttributes<Collider>>;
+export declare const VehicleCollider: import("react").ForwardRefExoticComponent<{
+    vehicleSize: THREE.Vector3;
+} & import("react").RefAttributes<Collider>>;

package/dist/types/gaesup/component/inner/vehicle/index.d.ts

@@ -0,0 +1,2 @@
+import { vehicleInnerType } from "./type";
+export declare function VehicleInnerRef(props: vehicleInnerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/inner/vehicle/type.d.ts

@@ -0,0 +1,5 @@
+import { ridingType, rigidBodyRefType } from "../common/type";
+export type vehicleUrlType = {
+    wheelUrl?: string;
+};
+export type vehicleInnerType = rigidBodyRefType & ridingType & vehicleUrlType;

package/dist/types/gaesup/component/inner/vehicle/wheels.d.ts

@@ -0,0 +1,8 @@
+import { RapierRigidBody } from "@react-three/rapier";
+import { RefObject } from "react";
+import * as THREE from "three";
+export declare function WheelsRef({ vehicleSize, rigidBodyRef, wheelUrl, }: {
+    vehicleSize: THREE.Vector3;
+    rigidBodyRef: RefObject<RapierRigidBody>;
+    wheelUrl: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/passive/airplane/index.d.ts

@@ -0,0 +1,2 @@
+import { passiveAirplanePropsType } from "./type";
+export declare function PassiveAirplane(props: passiveAirplanePropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/passive/airplane/type.d.ts

@@ -0,0 +1,2 @@
+import { passivePropsType } from "../type";
+export type passiveAirplanePropsType = Omit<passivePropsType, "componentType">;

package/dist/types/gaesup/component/passive/character/index.d.ts

@@ -0,0 +1,2 @@
+import { passiveCharacterPropsType } from "./type";
+export declare function PassiveCharacter(props: passiveCharacterPropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/passive/character/type.d.ts

@@ -0,0 +1,2 @@
+import { passivePropsType } from "../type";
+export type passiveCharacterPropsType = Omit<passivePropsType, "isRiding" | "enableRiding" | "componentType">;

package/dist/types/gaesup/component/passive/type.d.ts

@@ -0,0 +1,38 @@
+import { Collider } from "@dimforge/rapier3d-compat";
+import { CollisionEnterPayload, RapierRigidBody, RigidBodyProps, RigidBodyTypeString } from "@react-three/rapier";
+import { MutableRefObject } from "react";
+import * as THREE from "three";
+import { controllerOptionsType, groundRayType, partsType } from "../../controller/type";
+import { ridingType } from "../inner/common/type";
+export type componentTypeString = "character" | "vehicle" | "airplane";
+export type innerRefType = {
+    colliderRef: MutableRefObject<Collider>;
+    rigidBodyRef: MutableRefObject<RapierRigidBody>;
+    outerGroupRef: MutableRefObject<THREE.Group>;
+    innerGroupRef: MutableRefObject<THREE.Group>;
+};
+export type passivePropsType = {
+    children?: React.ReactNode;
+    groundRay?: groundRayType;
+    url: string;
+    ridingUrl?: string;
+    wheelUrl?: string;
+    position?: THREE.Vector3;
+    rotation?: THREE.Euler;
+    offset?: THREE.Vector3;
+    controllerOptions?: controllerOptionsType;
+    currentAnimation?: string;
+    rigidbodyType?: RigidBodyTypeString;
+    sensor?: boolean;
+    onIntersectionEnter?: (e: CollisionEnterPayload) => Promise<void>;
+    onCollisionEnter?: (e: CollisionEnterPayload) => Promise<void>;
+    componentType: componentTypeString;
+    userData?: {
+        intangible: boolean;
+    };
+    rigidBodyProps?: RigidBodyProps;
+    outerGroupProps?: THREE.Group;
+    innerGroupProps?: THREE.Group;
+    parts?: partsType;
+    isNotColliding?: boolean;
+} & ridingType;

package/dist/types/gaesup/component/passive/vehicle/index.d.ts

@@ -0,0 +1,2 @@
+import { passiveVehiclePropsType } from "./type";
+export declare function PassiveVehicle(props: passiveVehiclePropsType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/component/passive/vehicle/type.d.ts

@@ -0,0 +1,2 @@
+import { passivePropsType } from "../type";
+export type passiveVehiclePropsType = Omit<passivePropsType, "componentType">;

package/dist/types/gaesup/component/type.d.ts

@@ -0,0 +1,18 @@
+import { ObjectMap } from "@react-three/fiber";
+import { RapierRigidBody } from "@react-three/rapier";
+import { RefObject } from "react";
+import * as THREE from "three";
+import { GLTF } from "three-stdlib";
+export type GLTFResult = GLTF & {
+    nodes: {
+        [name: string]: THREE.Mesh | THREE.SkinnedMesh;
+    };
+    materials: {
+        [name: string]: THREE.Material | THREE.MeshStandardMaterial;
+    };
+} & ObjectMap;
+export type passiveRefsType = {
+    rigidBodyRef: RefObject<RapierRigidBody>;
+    outerGroupRef: RefObject<THREE.Group>;
+    innerGroupRef: RefObject<THREE.Group>;
+};

package/dist/types/gaesup/controller/context/index.d.ts

@@ -0,0 +1,48 @@
+import { dispatchType } from "../../utils/type";
+import { gaesupControllerType } from "./type";
+export declare const gaesupControllerDefault: {
+    airplane: {
+        angleDelta: import("three").Vector3;
+        maxAngle: import("three").Vector3;
+        maxSpeed: number;
+        accelRatio: number;
+        brakeRatio: number;
+        buoyancy: number;
+        linearDamping: number;
+    };
+    vehicle: {
+        maxSpeed: number;
+        accelRatio: number;
+        brakeRatio: number;
+        wheelOffset: number;
+        linearDamping: number;
+    };
+    character: {
+        walkSpeed: number;
+        runSpeed: number;
+        turnSpeed: number;
+        jumpSpeed: number;
+        linearDamping: number;
+    };
+    callbacks: {
+        onReady: () => void;
+        onFrame: () => void;
+        onDestory: () => void;
+        onAnimate: () => void;
+    };
+    refs: {
+        colliderRef: any;
+        rigidBodyRef: any;
+        outerGroupRef: any;
+        innerGroupRef: any;
+        characterInnerRef: any;
+    };
+    controllerOptions: {
+        lerp: {
+            cameraTurn: number;
+            cameraPosition: number;
+        };
+    };
+};
+export declare const GaesupControllerContext: import("react").Context<gaesupControllerType>;
+export declare const GaesupControllerDispatchContext: import("react").Context<dispatchType<gaesupControllerType>>;

package/dist/types/gaesup/controller/context/reducer.d.ts

@@ -0,0 +1,12 @@
+import { gaesupControllerType } from "./type";
+export declare function gaesupControllerReducer(props: gaesupControllerType, action: {
+    type: string;
+    payload?: Partial<gaesupControllerType>;
+}): {
+    airplane: import("./type").airplaneType;
+    vehicle: import("./type").vehicleType;
+    character: import("./type").characterType;
+    controllerOptions: import("../type").controllerOptionsType;
+    callbacks?: import("../initialize/callback/type").callbackType;
+    refs?: import("../type").refsType;
+};

package/dist/types/gaesup/controller/context/type.d.ts

@@ -0,0 +1,39 @@
+import { GroupProps } from "@react-three/fiber";
+import * as THREE from "three";
+import { dispatchType } from "../../utils/type";
+import { callbackType } from "../initialize/callback/type";
+import { gaesupControllerContextPropType, refsType } from "../type";
+export type airplaneDebugType = {
+    angleDelta?: THREE.Vector3;
+    maxAngle?: THREE.Vector3;
+    buoyancy?: number;
+    maxSpeed?: number;
+    accelRatio?: number;
+    brakeRatio?: number;
+    linearDamping?: number;
+};
+export type vehicleDebugType = {
+    maxSpeed?: number;
+    accelRatio?: number;
+    brakeRatio?: number;
+    wheelOffset?: number;
+    linearDamping?: number;
+};
+export type characterDebugType = {
+    jumpSpeed?: number;
+    turnSpeed?: number;
+    walkSpeed?: number;
+    runSpeed?: number;
+    linearDamping?: number;
+};
+export interface airplaneType extends GroupProps, airplaneDebugType {
+}
+export interface vehicleType extends GroupProps, vehicleDebugType {
+}
+export interface characterType extends GroupProps, characterDebugType {
+}
+export type gaesupControllerType = gaesupControllerContextPropType & {
+    callbacks?: callbackType;
+    refs?: refsType;
+};
+export type gaesupDisptachType = dispatchType<gaesupControllerType>;

package/dist/types/gaesup/controller/index.d.ts

@@ -0,0 +1,3 @@
+import { controllerType } from "./type";
+export declare function GaesupController(props: controllerType): import("react/jsx-runtime").JSX.Element;
+export declare function GaesupControllerInner(props: controllerType): import("react/jsx-runtime").JSX.Element;

package/dist/types/gaesup/controller/initialize/callback/index.d.ts

@@ -0,0 +1,15 @@
+import { AnimationAction } from "three";
+import { rigidBodyRefType } from "../../../component/inner/common/type";
+import { componentTypeString } from "../../../component/passive/type";
+import { animationTagType } from "../../type";
+export default function initCallback({ props, actions, componentType, }: {
+    props: rigidBodyRefType;
+    actions: {
+        [x: string]: AnimationAction;
+    };
+    componentType: componentTypeString;
+}): {
+    subscribe: ({ tag, condition, action, animationName, key, }: import("../../../world/context/type").animationAtomType) => void;
+    playAnimation: (tag: keyof animationTagType, key: string) => void;
+    dispatch: import("../../../utils/type").dispatchType<Partial<import("../../../world/context/type").gaesupWorldContextType>>;
+};

package/dist/types/gaesup/controller/initialize/callback/type.d.ts

@@ -0,0 +1,23 @@
+import { RootState } from "@react-three/fiber";
+import * as THREE from "three";
+import { activeStateType, animationAtomType, animationStateType, keyControlType, statesType } from "../../../world/context/type";
+export type callbackPropType = {
+    activeState: activeStateType;
+    states: statesType;
+    control: keyControlType;
+    subscribe: (props: animationAtomType) => void;
+};
+export type onFramePropType = callbackPropType & RootState;
+export type onAnimatePropType = onFramePropType & {
+    actions: {
+        [x: string]: THREE.AnimationAction | null;
+    };
+    animationState: animationStateType;
+    playAnimation: any;
+};
+export type callbackType = {
+    onReady?: (prop: callbackPropType) => void;
+    onFrame?: (prop: onFramePropType) => void;
+    onDestory?: (prop: callbackPropType) => void;
+    onAnimate?: (prop: onAnimatePropType) => void;
+};

package/dist/types/gaesup/controller/initialize/index.d.ts

@@ -0,0 +1,8 @@
+import { groundRayType, refsType } from "../../controller/type";
+import { cameraRayType } from "../../camera/type";
+export default function initControllerProps(props: {
+    refs: refsType;
+}): {
+    groundRay: groundRayType;
+    cameraRay: cameraRayType;
+};