Dwinzo-Beta
/
Dwinzo_dev
4
0
Fork 3
Code Issues Pull Requests Packages Projects Releases Wiki Activity

solved few bugs in agv

This commit is contained in:
Poovizhi99 2025-04-04 09:46:18 +05:30
parent 1dc04d19bb
commit 37f912a6f1
4 changed files with 130 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
app/src/components/ui/Tools.tsx
View File

@ -438,7 +438,6 @@ const Tools: React.FC = () => {
}`}
onClick={() => {
setIsPlaying(!isPlaying);
setActiveTool("play");
}}
>
<PlayIcon isActive={activeTool === "play"} />

3
app/src/components/ui/simulation/simulationPlayer.tsx
View File

@ -1,6 +1,7 @@
import React, { useState, useRef, useEffect } from "react";
import { ExitIcon, PlayStopIcon, ResetIcon } from "../../icons/SimulationIcons";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
import { useActiveTool } from "../../../store/store";
const SimulationPlayer: React.FC = () => {
const [speed, setSpeed] = useState<number>(1);
@ -8,6 +9,7 @@ const SimulationPlayer: React.FC = () => {
const { setIsPlaying } = usePlayButtonStore();
const sliderRef = useRef<HTMLDivElement>(null);
const isDragging = useRef(false);
const { setActiveTool } = useActiveTool();
// Button functions
const handleReset = () => {
@ -19,6 +21,7 @@ const SimulationPlayer: React.FC = () => {
const handleExit = () => {
setPlaySimulation(false);
setIsPlaying(false);
setActiveTool("cursor")
};
// Slider functions starts

62
app/src/modules/builder/agv/agv.tsx
View File

@ -19,7 +19,9 @@ const Agv = ({
}) => {
const [pathPoints, setPathPoints] = useState<
{
uuid: string;
modelUuid: string;
modelSpeed: number;
bufferTime: number;
points: { x: number; y: number; z: number }[];
}[]
>([]);
@ -32,6 +34,7 @@ const Agv = ({
(val: any) => val.modelName === "agv"
);
console.log("agvModels: ", agvModels);
let findMesh = agvModels.filter(
(val: any) =>
val.modeluuid === selectedActionSphere?.path?.modeluuid &&
@ -49,8 +52,9 @@ const Agv = ({
"y" in findMesh[0].point.actions.end
? [
{
uuid: findMesh[0].modeluuid, // Ensure it's a number
modelUuid: findMesh[0].modeluuid, // Ensure it's a number
modelSpeed: findMesh[0].point.speed,
bufferTime: findMesh[0].point.actions.buffer,
points: [
{
x: findMesh[0].position[0],
@ -72,15 +76,29 @@ const Agv = ({
]
: [];
if (result.length > 0) {
// setPathPoints((prev) => [...prev, ...result]);
setPathPoints((prev) => {
const existingUUIDs = new Set(prev.map((item) => item.uuid));
const newItems = result.filter(
(item) => !existingUUIDs.has(item.uuid)
const existingIndex = prev.findIndex(
(item) => item.modelUuid === result[0].modelUuid
);
return [...prev, ...newItems];
if (existingIndex !== -1) {
const updatedPathPoints = [...prev];
updatedPathPoints[existingIndex] = result[0];
return updatedPathPoints;
} else {
return [...prev, ...result];
}
});
}
}
// setPathPoints((prev) => {
// const existingUUIDs = new Set(prev.map((item) => item.uuid));
// const newItems = result.filter(
// (item) => !existingUUIDs.has(item.uuid)
// );
// return [...prev, ...newItems];
// });
}, [simulationPaths, selectedActionSphere]);
let groupRef = useRef() as Types.RefGroup;
@ -96,12 +114,40 @@ const Agv = ({
plane={plane}
/>
{pathPoints.map((pair, i) => (
<>
<PathNavigator
navMesh={navMesh}
selectedPoints={pair.points}
id={pair.uuid}
id={pair.modelUuid}
key={i}
speed={pair.modelSpeed}
bufferTime={pair.bufferTime}
/>
{/* {pair.points.length > 2 && (
<>
<mesh
position={[
pair.points[1].x,
pair.points[1].y,
pair.points[1].z,
]}
>
<sphereGeometry args={[0.3, 15, 15]} />
<meshStandardMaterial color="red" />
</mesh>
<mesh
position={[
pair.points[2].x,
pair.points[2].y,
pair.points[2].z,
]}
>
<sphereGeometry args={[0.3, 15, 15]} />
<meshStandardMaterial color="red" />
</mesh>
</>
)} */}
</>
))}
<group ref={groupRef} visible={false} name="Meshes"></group>
</>

94
app/src/modules/builder/agv/pathNavigator.tsx
View File

@ -3,30 +3,38 @@ import * as THREE from "three";
import { useFrame, useThree } from "@react-three/fiber";
import { NavMeshQuery } from "@recast-navigation/core";
import { Line } from "@react-three/drei";
import { useTh } from "leva/dist/declarations/src/styles";
import { useActiveTool } from "../../../store/store";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
// Define interface for props
interface PathNavigatorProps {
navMesh: any;
selectedPoints: any;
id: string;
speed: number;
bufferTime: number;
}
export default function PathNavigator({
navMesh,
selectedPoints,
id,
speed,
bufferTime,
}: PathNavigatorProps) {
const [path, setPath] = useState<[number, number, number][]>([]);
const progressRef = useRef(0);
const distancesRef = useRef<number[]>([]);
const totalDistanceRef = useRef(0);
const currentSegmentIndex = useRef(0);
const [stop, setStop] = useState<boolean>(true);
const { scene } = useThree();
const { activeTool } = useActiveTool();
const { isPlaying, setIsPlaying } = usePlayButtonStore();
const [startPoint, setStartPoint] = useState(new THREE.Vector3());
const meshRef = useRef<THREE.Mesh | null>(null);
const isWaiting = useRef<boolean>(false); // Flag to track waiting state
const delayTime = bufferTime;
const movingForward = useRef<boolean>(true); // Tracks whether the object is moving forward
// Compute distances and total distance when the path changes
useEffect(() => {
if (!scene || !id || path.length < 2) return;
@ -39,19 +47,17 @@ export default function PathNavigator({
distances.push(segmentDistance);
totalDistance += segmentDistance;
}
distancesRef.current = distances;
totalDistanceRef.current = totalDistance;
progressRef.current = 0; // Reset progress when the path changes
progressRef.current = 0;
}, [path]);
useEffect(() => {
if (!navMesh || selectedPoints.length === 0) return;
// Flatten the selectedPoints array into a single list of points
const allPoints = selectedPoints.flat();
// Compute paths between consecutive points
const computedPath: [number, number, number][] = [];
for (let i = 0; i < allPoints.length - 1; i++) {
const start = allPoints[i];
setStartPoint(
@ -64,7 +70,10 @@ export default function PathNavigator({
const navMeshQuery = new NavMeshQuery(navMesh);
const { path: segmentPath } = navMeshQuery.computePath(start, end);
if (segmentPath && segmentPath.length > 0) {
if (!segmentPath || segmentPath.length === 0) {
continue;
}
computedPath.push(
...segmentPath.map(({ x, y, z }): [number, number, number] => [
x,
@ -72,28 +81,24 @@ export default function PathNavigator({
z,
])
);
}
} catch (error) {}
}
// Set the full computed path
if (computedPath.length > 0) {
setPath(computedPath);
currentSegmentIndex.current = 0; // Reset to the first segment
currentSegmentIndex.current = 0;
}
}, [selectedPoints, navMesh, path]);
}, [selectedPoints, navMesh]);
useFrame((_, delta) => {
if (!scene || !id || path.length < 2) return;
// Find the object in the scene
// Find the object in the scene by its UUID
const findObject = scene.getObjectByProperty("uuid", id);
if (activeTool === "play") {
if (!findObject) return;
const speed = 5;
progressRef.current += delta * speed;
if (isPlaying) {
const fast = speed;
progressRef.current += delta * fast;
let coveredDistance = progressRef.current;
let accumulatedDistance = 0;
@ -108,9 +113,24 @@ export default function PathNavigator({
index++;
}
// If the object has reached the end of the path, stop moving
if (index >= distancesRef.current.length) {
progressRef.current = totalDistanceRef.current;
if (!isWaiting.current) {
isWaiting.current = true; // Set waiting flag
setTimeout(() => {
progressRef.current = 0; // Reset progress
movingForward.current = !movingForward.current; // Toggle direction
// Reverse the path and distances arrays
path.reverse();
distancesRef.current.reverse();
// Reset the waiting flag
isWaiting.current = false;
}, delayTime * 1000); // Convert seconds to milliseconds
}
return;
}
@ -119,31 +139,35 @@ export default function PathNavigator({
const end = new THREE.Vector3(...path[index + 1]);
const segmentDistance = distancesRef.current[index];
const t = (coveredDistance - accumulatedDistance) / segmentDistance;
const t = Math.min(
(coveredDistance - accumulatedDistance) / segmentDistance,
1
); // Clamp t to avoid overshooting
const position = start.clone().lerp(end, t);
findObject.position.copy(position);
// Rotate the object to face the direction of movement
const direction = new THREE.Vector3().subVectors(end, start).normalize();
const targetQuaternion = new THREE.Quaternion().setFromUnitVectors(
new THREE.Vector3(0, 0, 1), // Assuming forward direction is (0, 0, 1)
direction
);
findObject.quaternion.slerp(targetQuaternion, 0.1); // Smoothly interpolate rotation
} else if (activeTool === "cursor") {
findObject?.position.copy(startPoint);
const targetYRotation = Math.atan2(direction.x, direction.z);
findObject.rotation.y += (targetYRotation - findObject.rotation.y) * 0.1;
} else {
findObject.position.copy(startPoint);
}
});
return (
<>
{path.length > 0 && <Line points={path} color="blue" lineWidth={3} />}
{/* {path.length > 0 && (
<mesh ref={meshRef} position={path.length > 0 ? path[0] : [0, 0.1, 0]}>
<boxGeometry args={[1, 1, 1]} />
<meshNormalMaterial />
{path.length > 0 && (
<>
<Line points={path} color="blue" lineWidth={3} />
{selectedPoints.map((val: any, i: any) => (
<mesh position={[val[0], val[1] + 1, val[2]]} key={i}>
<sphereGeometry args={[50, 5, 5]} />
<meshBasicMaterial color={"red"} />
</mesh>
)} */}
))}
</>
)}
</>
);
}