182 lines
8.3 KiB
TypeScript
182 lines
8.3 KiB
TypeScript
import React, { useEffect, useRef, useState } from 'react'
|
|
import IKInstance from '../ikInstance/ikInstance';
|
|
import RoboticArmAnimator from '../animator/roboticArmAnimator';
|
|
import { usePlayButtonStore } from '../../../../../store/usePlayButtonStore';
|
|
import { useArmBotStore } from '../../../../../store/simulation/useArmBotStore';
|
|
import armModel from "../../../../../assets/gltf-glb/rigged/ik_arm_4.glb";
|
|
import { useThree } from "@react-three/fiber";
|
|
import { useFloorItems } from '../../../../../store/store';
|
|
import useModuleStore from '../../../../../store/useModuleStore';
|
|
import { Vector3 } from "three";
|
|
import * as THREE from "three";
|
|
|
|
interface Process {
|
|
triggerId: string;
|
|
startPoint?: Vector3;
|
|
endPoint?: Vector3;
|
|
speed: number;
|
|
}
|
|
function RoboticArmInstance({ robot }: { robot: ArmBotStatus }) {
|
|
|
|
const { isPlaying } = usePlayButtonStore();
|
|
const [currentPhase, setCurrentPhase] = useState<(string)>("init");
|
|
const { scene } = useThree();
|
|
const targetBone = "Target";
|
|
const { activeModule } = useModuleStore();
|
|
const [ikSolver, setIkSolver] = useState<any>(null);
|
|
const { addCurrentAction, setArmBotActive, setArmBotState, removeCurrentAction } = useArmBotStore();
|
|
const { floorItems } = useFloorItems();
|
|
const groupRef = useRef<any>(null);
|
|
const [processes, setProcesses] = useState<Process[]>([]);
|
|
const [armBotCurvePoints, setArmBotCurvePoints] = useState({ start: [], end: [] })
|
|
const restPosition = new THREE.Vector3(0, 2, 1.6);
|
|
let armBotCurveRef = useRef<THREE.CatmullRomCurve3 | null>(null)
|
|
const [path, setPath] = useState<[number, number, number][]>([]);
|
|
|
|
useEffect(() => {
|
|
let armItems = floorItems?.filter((val: any) =>
|
|
val.modeluuid === "3abf5d46-b59e-4e6b-9c02-a4634b64b82d"
|
|
);
|
|
// Get the first matching item
|
|
let armItem = armItems?.[0];
|
|
if (armItem) {
|
|
const targetMesh = scene?.getObjectByProperty("uuid", armItem.modeluuid);
|
|
if (targetMesh) {
|
|
targetMesh.visible = activeModule !== "simulation"
|
|
}
|
|
}
|
|
const targetBones = ikSolver?.mesh.skeleton.bones.find(
|
|
(b: any) => b.name === targetBone
|
|
);
|
|
|
|
if (isPlaying) {
|
|
//Moving armBot from initial point to rest position.
|
|
if (!robot?.isActive && robot?.state == "idle" && currentPhase == "init") {
|
|
|
|
setArmBotActive(robot.modelUuid, true)
|
|
setArmBotState(robot.modelUuid, "running")
|
|
setCurrentPhase("init-to-rest");
|
|
if (targetBones) {
|
|
let curve = createCurveBetweenTwoPoints(targetBones.position, restPosition)
|
|
if (curve) {
|
|
setPath(curve.points.map(point => [point.x, point.y, point.z]));
|
|
}
|
|
}
|
|
logStatus(robot.modelUuid, "Starting from init to rest")
|
|
}
|
|
//Waiting for trigger.
|
|
else if (robot && !robot.isActive && robot.state === "idle" && currentPhase === "rest" && !robot.currentAction) {
|
|
console.log("trigger");
|
|
setTimeout(() => {
|
|
addCurrentAction(robot.modelUuid, 'action-003');
|
|
}, 3000);
|
|
}
|
|
else if (robot && !robot.isActive && robot.state === "idle" && currentPhase === "rest" && robot.currentAction) {
|
|
if (robot.currentAction) {
|
|
setArmBotActive(robot.modelUuid, true);
|
|
setArmBotState(robot.modelUuid, "running");
|
|
setCurrentPhase("rest-to-start");
|
|
const startPoint = robot.point.actions[0].process.startPoint;
|
|
if (startPoint) {
|
|
let curve = createCurveBetweenTwoPoints(restPosition, new THREE.Vector3(startPoint[0], startPoint[1], startPoint[2]));
|
|
if (curve) {
|
|
setPath(curve.points.map(point => [point.x, point.y, point.z]));
|
|
}
|
|
}
|
|
}
|
|
logStatus(robot.modelUuid, "Starting from rest to start")
|
|
}
|
|
else if (robot && !robot.isActive && robot.state === "idle" && currentPhase === "picking" && robot.currentAction) {
|
|
setArmBotActive(robot.modelUuid, true);
|
|
setArmBotState(robot.modelUuid, "running");
|
|
setCurrentPhase("start-to-end");
|
|
const startPoint = robot.point.actions[0].process.startPoint;
|
|
const endPoint = robot.point.actions[0].process.endPoint;
|
|
if (startPoint && endPoint) {
|
|
let curve = createCurveBetweenTwoPoints(
|
|
new THREE.Vector3(startPoint[0], startPoint[1], startPoint[2]),
|
|
new THREE.Vector3(endPoint[0], endPoint[1], endPoint[2])
|
|
);
|
|
if (curve) {
|
|
setPath(curve.points.map(point => [point.x, point.y, point.z]));
|
|
}
|
|
}
|
|
logStatus(robot.modelUuid, "Starting from start to end")
|
|
}
|
|
else if (robot && !robot.isActive && robot.state === "idle" && currentPhase === "dropping" && robot.currentAction) {
|
|
setArmBotActive(robot.modelUuid, true);
|
|
setArmBotState(robot.modelUuid, "running");
|
|
setCurrentPhase("end-to-rest");
|
|
const endPoint = robot.point.actions[0].process.endPoint;
|
|
if (endPoint) {
|
|
let curve = createCurveBetweenTwoPoints(new THREE.Vector3(endPoint[0], endPoint[1], endPoint[2]), restPosition
|
|
);
|
|
if (curve) {
|
|
setPath(curve.points.map(point => [point.x, point.y, point.z]));
|
|
}
|
|
}
|
|
logStatus(robot.modelUuid, "Starting from end to rest")
|
|
}
|
|
}
|
|
|
|
}, [currentPhase, robot, isPlaying, ikSolver])
|
|
|
|
|
|
function createCurveBetweenTwoPoints(p1: any, p2: any) {
|
|
const mid = new THREE.Vector3().addVectors(p1, p2).multiplyScalar(0.5);
|
|
mid.y += 0.5;
|
|
|
|
const points = [p1, mid, p2];
|
|
return new THREE.CatmullRomCurve3(points);
|
|
}
|
|
|
|
|
|
const HandleCallback = () => {
|
|
if (robot.isActive && robot.state == "running" && currentPhase == "init-to-rest") {
|
|
console.log("Callback triggered: rest");
|
|
setArmBotActive(robot.modelUuid, false)
|
|
setArmBotState(robot.modelUuid, "idle")
|
|
setCurrentPhase("rest");
|
|
setPath([])
|
|
}
|
|
else if (robot.isActive && robot.state == "running" && currentPhase == "rest-to-start") {
|
|
console.log("Callback triggered: pick.");
|
|
setArmBotActive(robot.modelUuid, false)
|
|
setArmBotState(robot.modelUuid, "idle")
|
|
setCurrentPhase("picking");
|
|
setPath([])
|
|
}
|
|
else if (robot.isActive && robot.state == "running" && currentPhase == "start-to-end") {
|
|
console.log("Callback triggered: drop.");
|
|
setArmBotActive(robot.modelUuid, false)
|
|
setArmBotState(robot.modelUuid, "idle")
|
|
setCurrentPhase("dropping");
|
|
setPath([])
|
|
}
|
|
else if (robot.isActive && robot.state == "running" && currentPhase == "end-to-rest") {
|
|
console.log("Callback triggered: rest, cycle completed.");
|
|
setArmBotActive(robot.modelUuid, false)
|
|
setArmBotState(robot.modelUuid, "idle")
|
|
setCurrentPhase("rest");
|
|
setPath([])
|
|
removeCurrentAction(robot.modelUuid)
|
|
}
|
|
}
|
|
const logStatus = (id: string, status: string) => {
|
|
console.log(id +","+ status);
|
|
}
|
|
|
|
return (
|
|
<>
|
|
|
|
<IKInstance modelUrl={armModel} setIkSolver={setIkSolver} ikSolver={ikSolver} robot={robot} groupRef={groupRef} processes={processes}
|
|
setArmBotCurvePoints={setArmBotCurvePoints} />
|
|
<RoboticArmAnimator armUuid={robot?.modelUuid} HandleCallback={HandleCallback}
|
|
currentPhase={currentPhase} targetBone={targetBone} ikSolver={ikSolver} robot={robot}
|
|
logStatus={logStatus} groupRef={groupRef} processes={processes} armBotCurveRef={armBotCurveRef} path={path} />
|
|
|
|
</>
|
|
)
|
|
}
|
|
|
|
export default RoboticArmInstance; |