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

Merge pull request 'simulation' (#61) from simulation into main 

Reviewed-on: http://185.100.212.76:7776/Dwinzo-Beta/Dwinzo_dev/pulls/61
This commit is contained in:
Vishnu 2025-04-11 12:57:02 +00:00
parent c109820d27 d76ae8b8b4
commit c7c35e288a
13 changed files with 881 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/src/components/layout/sidebarRight/properties/GlobalProperties.tsx
View File

@ -98,7 +98,7 @@ const GlobalProperties: React.FC = () => {
// setPlaneValue({ height: value * 100, width: value * 100 }); // setPlaneValue({ height: value * 100, width: value * 100 });
} }
function updatedGrid(value: number) { function updatedGrid(value: number) {
console.log(" (value * 100) / 4 : ", (value * 100) / 4); // console.log(" (value * 100) / 4 : ", (value * 100) / 4);
setGridValue({ size: value * 100, divisions: (value * 100) / 4 }); setGridValue({ size: value * 100, divisions: (value * 100) / 4 });
setPlaneValue({ height: value * 100, width: value * 100 }); setPlaneValue({ height: value * 100, width: value * 100 });
} }

4
app/src/components/layout/sidebarRight/properties/ZoneProperties.tsx
View File

@ -32,7 +32,7 @@ const ZoneProperties: React.FC = () => {
if (response.message === "updated successfully") { if (response.message === "updated successfully") {
setEdit(false); setEdit(false);
} else { } else {
console.log(response); // console.log(response);
} }
} catch (error) { } catch (error) {
@ -63,7 +63,7 @@ const ZoneProperties: React.FC = () => {
) )
); );
}else{ }else{
console.log(response?.message); // console.log(response?.message);
} }
} }
function handleVectorChange(key: "zoneViewPortTarget" | "zoneViewPortPosition", newValue: [number, number, number]) { function handleVectorChange(key: "zoneViewPortTarget" | "zoneViewPortPosition", newValue: [number, number, number]) {

2
app/src/components/ui/componets/RealTimeVisulization.tsx
View File

@ -85,7 +85,7 @@ const RealTimeVisulization: React.FC = () => {
const organization = email?.split("@")[1]?.split(".")[0]; const organization = email?.split("@")[1]?.split(".")[0];
try { try {
const response = await getZone2dData(organization); const response = await getZone2dData(organization);
console.log('response: ', response); // console.log('response: ', response);
if (!Array.isArray(response)) { if (!Array.isArray(response)) {
return; return;

2
app/src/components/ui/realTimeVis/floating/FleetEfficiencyComponent.tsx
View File

@ -41,7 +41,7 @@ const FleetEfficiencyComponent = ({object}: any) => {
socket.on("lastOutput", (response) => { socket.on("lastOutput", (response) => {
const responseData = response.input1; const responseData = response.input1;
console.log(responseData); // console.log(responseData);
if (typeof responseData === "number") { if (typeof responseData === "number") {
console.log("It's a number!"); console.log("It's a number!");

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

@ -1,111 +1,108 @@
import { useEffect, useState } from "react"; import { useEffect, useRef, useState } from "react";
import { Line } from "@react-three/drei"; import { Line } from "@react-three/drei";
import { import {
useNavMesh, useNavMesh,
usePlayAgv, usePlayAgv,
useSimulationStates, useSimulationStates,
} from "../../../store/store"; } from "../../../store/store";
import PathNavigator from "./pathNavigator"; import PathNavigator from "./pathNavigator";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore"; import { useAnimationPlaySpeed, usePlayButtonStore, useResetButtonStore } from "../../../store/usePlayButtonStore";
type PathPoints = { type PathPoints = {
modelUuid: string; modelUuid: string;
modelSpeed: number; modelSpeed: number;
bufferTime: number; bufferTime: number;
points: { x: number; y: number; z: number }[]; points: { x: number; y: number; z: number }[];
hitCount: number; hitCount: number;
}; };
interface ProcessContainerProps { interface ProcessContainerProps {
processes: any[]; processes: any[];
agvRef: any; agvRef: any;
MaterialRef: any; MaterialRef: any;
} }
const Agv: React.FC<ProcessContainerProps> = ({ const Agv: React.FC<ProcessContainerProps> = ({
processes, processes,
agvRef, agvRef,
MaterialRef, MaterialRef,
}) => { }) => {
const [pathPoints, setPathPoints] = useState<PathPoints[]>([]); const [pathPoints, setPathPoints] = useState<PathPoints[]>([]);
const { simulationStates } = useSimulationStates(); const { simulationStates } = useSimulationStates();
const { navMesh } = useNavMesh(); const { navMesh } = useNavMesh();
const { isPlaying } = usePlayButtonStore(); const { isPlaying } = usePlayButtonStore();
const { PlayAgv, setPlayAgv } = usePlayAgv(); const { isReset, setReset } = useResetButtonStore();
const { speed } = useAnimationPlaySpeed();
const globalSpeed = useRef(1);
useEffect(() => { globalSpeed.current = speed }, [speed])
useEffect(() => {
if (!isPlaying || isReset) {
agvRef.current = [];
}
}, [isPlaying, isReset])
useEffect(() => { useEffect(() => {
if (simulationStates.length > 0) { if (simulationStates.length > 0) {
const agvModels = simulationStates.filter( const agvModels = simulationStates.filter(
(val) => val.modelName === "agv" && val.type === "Vehicle" (val) => val.modelName === "agv" && val.type === "Vehicle"
); );
const newPathPoints = agvModels const newPathPoints = agvModels
.filter( .filter(
(model: any) => (model: any) =>
model.points && model.points &&
model.points.actions && model.points.actions &&
typeof model.points.actions.start === "object" && typeof model.points.actions.start === "object" &&
typeof model.points.actions.end === "object" && typeof model.points.actions.end === "object" &&
"x" in model.points.actions.start && "x" in model.points.actions.start &&
"y" in model.points.actions.start && "y" in model.points.actions.start &&
"x" in model.points.actions.end && "x" in model.points.actions.end &&
"y" in model.points.actions.end "y" in model.points.actions.end
) )
.map((model: any) => ({ .map((model: any) => ({
modelUuid: model.modeluuid, modelUuid: model.modeluuid,
modelSpeed: model.points.speed, modelSpeed: model.points.speed,
bufferTime: model.points.actions.buffer, bufferTime: model.points.actions.buffer,
hitCount: model.points.actions.hitCount, hitCount: model.points.actions.hitCount,
points: [ points: [
{ { x: model.position[0], y: model.position[1], z: model.position[2], },
x: model.position[0], { x: model.points.actions.start.x, y: 0, z: model.points.actions.start.y, },
y: model.position[1], { x: model.points.actions.end.x, y: 0, z: model.points.actions.end.y, },
z: model.position[2], ],
}, }));
{
x: model.points.actions.start.x,
y: 0,
z: model.points.actions.start.y,
},
{
x: model.points.actions.end.x,
y: 0,
z: model.points.actions.end.y,
},
],
}));
setPathPoints(newPathPoints); setPathPoints(newPathPoints);
} }
}, [simulationStates]); }, [simulationStates]);
return ( return (
<> <>
{pathPoints.map((pair, i) => ( {pathPoints.map((pair, i) => (
<group key={i} visible={!isPlaying}> <group key={i} visible={!isPlaying}>
<PathNavigator <PathNavigator
navMesh={navMesh} navMesh={navMesh}
pathPoints={pair.points} pathPoints={pair.points}
id={pair.modelUuid} id={pair.modelUuid}
speed={pair.modelSpeed} speed={pair.modelSpeed}
bufferTime={pair.bufferTime} globalSpeed={globalSpeed.current}
hitCount={pair.hitCount} bufferTime={pair.bufferTime}
processes={processes} hitCount={pair.hitCount}
agvRef={agvRef} processes={processes}
MaterialRef={MaterialRef} agvRef={agvRef}
/> MaterialRef={MaterialRef}
/>
{pair.points.slice(1).map((point, idx) => ( {pair.points.slice(1).map((point, idx) => (
<mesh position={[point.x, point.y, point.z]} key={idx}> <mesh position={[point.x, point.y, point.z]} key={idx}>
<sphereGeometry args={[0.3, 15, 15]} /> <sphereGeometry args={[0.3, 15, 15]} />
<meshStandardMaterial color="red" /> <meshStandardMaterial color="red" />
</mesh> </mesh>
))} ))}
</group> </group>
))} ))}
</> </>
); );
}; };
export default Agv; export default Agv;

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

@ -3,15 +3,15 @@ import * as THREE from "three";
import { useFrame, useThree } from "@react-three/fiber"; import { useFrame, useThree } from "@react-three/fiber";
import { NavMeshQuery } from "@recast-navigation/core"; import { NavMeshQuery } from "@recast-navigation/core";
import { Line } from "@react-three/drei"; import { Line } from "@react-three/drei";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore"; import { useAnimationPlaySpeed, usePlayButtonStore } from "../../../store/usePlayButtonStore";
import { usePlayAgv } from "../../../store/store"; import { usePlayAgv } from "../../../store/store";
import crate from "../../../assets/gltf-glb/crate_box.glb";
interface PathNavigatorProps { interface PathNavigatorProps {
navMesh: any; navMesh: any;
pathPoints: any; pathPoints: any;
id: string; id: string;
speed: number; speed: number;
globalSpeed: number,
bufferTime: number; bufferTime: number;
hitCount: number; hitCount: number;
processes: any[]; processes: any[];
@ -31,6 +31,7 @@ export default function PathNavigator({
pathPoints, pathPoints,
id, id,
speed, speed,
globalSpeed,
bufferTime, bufferTime,
hitCount, hitCount,
processes, processes,
@ -38,30 +39,12 @@ export default function PathNavigator({
MaterialRef, MaterialRef,
}: PathNavigatorProps) { }: PathNavigatorProps) {
const [currentPhase, setCurrentPhase] = useState<Phase>("initial"); const [currentPhase, setCurrentPhase] = useState<Phase>("initial");
//
const [path, setPath] = useState<[number, number, number][]>([]); const [path, setPath] = useState<[number, number, number][]>([]);
const PickUpDrop = useRef([]); const [toPickupPath, setToPickupPath] = useState<[number, number, number][]>([]);
const [pickupDropPath, setPickupDropPath] = useState<[number, number, number][]>([]);
// const [currentPhase, setCurrentPhase] = useState<"initial" | "loop">( const [dropPickupPath, setDropPickupPath] = useState<[number, number, number][]>([]);
// "initial" const [initialPosition, setInitialPosition] = useState<THREE.Vector3 | null>(null);
// ); const [initialRotation, setInitialRotation] = useState<THREE.Euler | null>(null);
const [toPickupPath, setToPickupPath] = useState<[number, number, number][]>(
[]
);
const [pickupDropPath, setPickupDropPath] = useState<
[number, number, number][]
>([]);
const [dropPickupPath, setDropPickupPath] = useState<
[number, number, number][]
>([]);
const [initialPosition, setInitialPosition] = useState<THREE.Vector3 | null>(
null
);
const [initialRotation, setInitialRotation] = useState<THREE.Euler | null>(
null
);
const [boxVisible, setBoxVisible] = useState(false); const [boxVisible, setBoxVisible] = useState(false);
const distancesRef = useRef<number[]>([]); const distancesRef = useRef<number[]>([]);
@ -70,11 +53,20 @@ export default function PathNavigator({
const isWaiting = useRef(false); const isWaiting = useRef(false);
const timeoutRef = useRef<NodeJS.Timeout | null>(null); const timeoutRef = useRef<NodeJS.Timeout | null>(null);
const hasStarted = useRef(false); const hasStarted = useRef(false);
const hasReachedPickup = useRef(false);
const { scene } = useThree(); const { scene } = useThree();
const { isPlaying } = usePlayButtonStore(); const { isPlaying } = usePlayButtonStore();
const { PlayAgv, setPlayAgv } = usePlayAgv(); const { PlayAgv, setPlayAgv } = usePlayAgv();
const boxRef = useRef<THREE.Mesh | null>(null);
const baseMaterials = useMemo(() => ({
Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
Default: new THREE.MeshStandardMaterial({ color: 0xcccccc })
}), []);
useEffect(() => { useEffect(() => {
const object = scene.getObjectByProperty("uuid", id); const object = scene.getObjectByProperty("uuid", id);
if (object) { if (object) {
@ -105,12 +97,16 @@ export default function PathNavigator({
setPath([]); setPath([]);
setCurrentPhase("initial"); setCurrentPhase("initial");
setToPickupPath([]);
setPickupDropPath([]); setPickupDropPath([]);
setDropPickupPath([]); setDropPickupPath([]);
setBoxVisible(false);
distancesRef.current = []; distancesRef.current = [];
totalDistanceRef.current = 0; totalDistanceRef.current = 0;
progressRef.current = 0; progressRef.current = 0;
isWaiting.current = false; isWaiting.current = false;
hasStarted.current = false;
hasReachedPickup.current = false;
if (initialPosition && initialRotation) { if (initialPosition && initialRotation) {
const object = scene.getObjectByProperty("uuid", id); const object = scene.getObjectByProperty("uuid", id);
@ -130,27 +126,16 @@ export default function PathNavigator({
const [pickup, drop] = pathPoints.slice(-2); const [pickup, drop] = pathPoints.slice(-2);
PickUpDrop.current = pathPoints.slice(-2);
const object = scene.getObjectByProperty("uuid", id); const object = scene.getObjectByProperty("uuid", id);
if (!object) return; if (!object) return;
const currentPosition = { const currentPosition = object.position;
x: object.position.x,
y: object.position.y,
z: object.position.z,
};
const toPickupPath = computePath(currentPosition, pickup); const toPickupPath = computePath(currentPosition, pickup);
const pickupToDropPath = computePath(pickup, drop); const pickupToDropPath = computePath(pickup, drop);
const dropToPickupPath = computePath(drop, pickup); const dropToPickupPath = computePath(drop, pickup);
if ( if (toPickupPath.length && pickupToDropPath.length && dropToPickupPath.length) {
toPickupPath.length &&
pickupToDropPath.length &&
dropToPickupPath.length
) {
setPickupDropPath(pickupToDropPath); setPickupDropPath(pickupToDropPath);
setDropPickupPath(dropToPickupPath); setDropPickupPath(dropToPickupPath);
setToPickupPath(toPickupPath); setToPickupPath(toPickupPath);
@ -177,25 +162,9 @@ export default function PathNavigator({
isWaiting.current = false; isWaiting.current = false;
}, [path]); }, [path]);
// Add these refs outside the useFrame if not already present: function logAgvStatus(id: string, status: string) {
const startPointReached = useRef(false); // console.log(`AGV ${id}: ${status}`);
}
const baseMaterials = useMemo(
() => ({
Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
// Default: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
Default: new THREE.MeshStandardMaterial(),
}),
[]
);
// Example usage:
const targetModelUUID = id; // Replace with your target ID
const matchedProcess = findProcessByTargetModelUUID(
processes,
targetModelUUID
);
function findProcessByTargetModelUUID(processes: any, targetModelUUID: any) { function findProcessByTargetModelUUID(processes: any, targetModelUUID: any) {
for (const process of processes) { for (const process of processes) {
@ -206,75 +175,55 @@ export default function PathNavigator({
(target: any) => target.modelUUID === targetModelUUID (target: any) => target.modelUUID === targetModelUUID
) )
) { ) {
// return process.id;
return process.id; // Return the process if a match is found
} }
} }
} }
} }
return null; // Return null if no match is found return null;
} }
useFrame((_, delta) => {});
const boxRef = useRef<THREE.Mesh | null>(null);
useEffect(() => { useEffect(() => {
if (!scene || !boxRef || !processes) return; if (!scene || !boxRef || !processes || !MaterialRef.current) return;
// 1. Find the existing object by UUID
const existingObject = scene.getObjectByProperty("uuid", id); const existingObject = scene.getObjectByProperty("uuid", id);
if (!existingObject) return; if (!existingObject) return;
// 2. Find the process that targets this object's modelUUID if (boxRef.current?.parent) {
boxRef.current.parent.remove(boxRef.current);
boxRef.current = null;
}
if (boxVisible) { if (boxVisible) {
const matchedProcess = findProcessByTargetModelUUID(processes, id); const matchedProcess = findProcessByTargetModelUUID(processes, id);
let materialType: "Box" | "Crate" | "Default" = "Default";
// 3. Determine the material (from materialref) if a process is matched
let materialType = "Default";
if (matchedProcess) { if (matchedProcess) {
const materialEntry = MaterialRef.current.find((item: any) => const materialEntry = MaterialRef.current.find((item: any) =>
item.objects.some((obj: any) => obj.processId === matchedProcess) item.objects.some((obj: any) => obj.processId === matchedProcess)
); );
console.log("materialEntry: ", materialEntry);
if (materialEntry) { if (materialEntry) {
materialType = materialEntry.material; // "Box" or "Crate" materialType = materialEntry.material;
} }
} }
// 4. Create the box mesh with the assigned material
const boxGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5); const boxGeometry = new THREE.BoxGeometry(0.5, 0.5, 0.5);
const boxMaterial = baseMaterials[materialType as MaterialType]; const boxMesh = new THREE.Mesh(boxGeometry, baseMaterials[materialType]);
const boxMesh = new THREE.Mesh(boxGeometry, boxMaterial);
boxMesh.position.y = 1; boxMesh.position.y = 1;
boxMesh.name = `box-${id}`; boxMesh.name = `box-${id}`;
// 5. Add to scene and cleanup
existingObject.add(boxMesh); existingObject.add(boxMesh);
boxRef.current = boxMesh; boxRef.current = boxMesh;
} }
if (!startPointReached.current && boxVisible) {
setBoxVisible(false);
}
return () => { return () => {
if (boxRef.current?.parent) { if (boxRef.current?.parent) {
boxRef.current.parent.remove(boxRef.current); boxRef.current.parent.remove(boxRef.current);
} }
boxRef.current = null;
}; };
}, [ }, [processes, MaterialRef, boxVisible, scene, id, baseMaterials]);
processes,
MaterialRef,
boxVisible,
findProcessByTargetModelUUID,
startPointReached,
]);
useFrame((_, delta) => { useFrame((_, delta) => {
const currentAgv = (agvRef.current || []).find( const currentAgv = (agvRef.current || []).find((agv: AGVData) => agv.vehicleId === id);
(agv: AGVData) => agv.vehicleId === id
);
if (!scene || !id || !isPlaying) return; if (!scene || !id || !isPlaying) return;
@ -283,7 +232,6 @@ export default function PathNavigator({
if (isPlaying && !hasStarted.current) { if (isPlaying && !hasStarted.current) {
hasStarted.current = false; hasStarted.current = false;
startPointReached.current = false;
progressRef.current = 0; progressRef.current = 0;
isWaiting.current = false; isWaiting.current = false;
if (timeoutRef.current) { if (timeoutRef.current) {
@ -295,10 +243,9 @@ export default function PathNavigator({
const isAgvReady = () => { const isAgvReady = () => {
if (!agvRef.current || agvRef.current.length === 0) return false; if (!agvRef.current || agvRef.current.length === 0) return false;
if (!currentAgv) return false; if (!currentAgv) return false;
return hitCount === currentAgv.expectedHitCount; return currentAgv.isActive && hitCount >= currentAgv.maxHitCount;
}; };
// Step 1: Snap to start point on first play
if (isPlaying && !hasStarted.current && toPickupPath.length > 0) { if (isPlaying && !hasStarted.current && toPickupPath.length > 0) {
setBoxVisible(false); setBoxVisible(false);
const startPoint = new THREE.Vector3(...toPickupPath[0]); const startPoint = new THREE.Vector3(...toPickupPath[0]);
@ -311,146 +258,132 @@ export default function PathNavigator({
} }
hasStarted.current = true; hasStarted.current = true;
startPointReached.current = true;
progressRef.current = 0; progressRef.current = 0;
hasReachedPickup.current = false;
setToPickupPath(toPickupPath.slice(-1)); setToPickupPath(toPickupPath.slice(-1));
logAgvStatus(id, "Started from station, heading to pickup");
return; return;
} }
// Step 2: Wait at start point for AGV readiness if (isPlaying && currentPhase === "initial" && !hasReachedPickup.current) {
if (isPlaying && startPointReached.current && path.length === 0) { const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
if (!isAgvReady()) {
return; // Prevent transitioning to the next phase if AGV is not ready if (reached) {
hasReachedPickup.current = true;
if (currentAgv) {
currentAgv.status = 'picking';
}
logAgvStatus(id, "Reached pickup point, Waiting for material");
} }
setBoxVisible(true);
setPath([...toPickupPath]); // Start path transition once the AGV is ready
setCurrentPhase("toDrop");
progressRef.current = 0;
console.log("startPointReached: ", startPointReached.current);
startPointReached.current = false;
return; return;
} }
if (path.length < 2) return; if (isPlaying && currentAgv?.isActive && currentPhase === "initial") {
if (!isAgvReady()) return;
setTimeout(() => {
setBoxVisible(true);
setPath([...pickupDropPath]);
setCurrentPhase("toDrop");
progressRef.current = 0;
logAgvStatus(id, "Started from pickup point, heading to drop point");
if (currentAgv) {
currentAgv.status = 'toDrop';
}
}, 0)
return;
}
progressRef.current += delta * speed; if (isPlaying && currentPhase === "toDrop") {
const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
if (reached && !isWaiting.current) {
isWaiting.current = true;
logAgvStatus(id, "Reached drop point");
if (currentAgv) {
currentAgv.status = 'droping';
}
timeoutRef.current = setTimeout(() => {
setPath([...dropPickupPath]);
setCurrentPhase("toPickup");
progressRef.current = 0;
isWaiting.current = false;
setBoxVisible(false);
if (currentAgv) {
currentAgv.status = 'toPickup';
}
logAgvStatus(id, "Started from droping point, heading to pickup point");
}, bufferTime * 1000);
}
return;
}
if (isPlaying && currentPhase === "toPickup") {
const reached = moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
if (reached) {
if (currentAgv) {
currentAgv.isActive = false;
}
setCurrentPhase("initial");
if (currentAgv) {
currentAgv.status = 'picking';
}
logAgvStatus(id, "Reached pickup point again, cycle complete");
}
return;
}
moveAlongPath(object, path, distancesRef.current, speed, delta, progressRef);
});
function moveAlongPath(
object: THREE.Object3D,
path: [number, number, number][],
distances: number[],
speed: number,
delta: number,
progressRef: React.MutableRefObject<number>
): boolean {
if (path.length < 2) return false;
progressRef.current += delta * (speed * globalSpeed);
let covered = progressRef.current; let covered = progressRef.current;
let accumulated = 0; let accumulated = 0;
let index = 0; let index = 0;
if (distancesRef.current.length !== path.length - 1) { for (; index < distances.length; index++) {
distancesRef.current = []; const dist = distances[index];
totalDistanceRef.current = 0; if (accumulated + dist >= covered) break;
accumulated += dist;
}
for (let i = 0; i < path.length - 1; i++) { if (index >= path.length - 1) {
const start = new THREE.Vector3(...path[i]); if (path.length > 1) {
const end = new THREE.Vector3(...path[i + 1]); const lastDirection = new THREE.Vector3(...path[path.length - 1])
const distance = start.distanceTo(end); .sub(new THREE.Vector3(...path[path.length - 2]))
distancesRef.current.push(distance); .normalize();
totalDistanceRef.current += distance; object.rotation.y = Math.atan2(lastDirection.x, lastDirection.z);
} }
return true;
} }
while (
index < distancesRef.current.length &&
covered > accumulated + distancesRef.current[index]
) {
accumulated += distancesRef.current[index];
index++;
}
// AGV has completed its path
if (index >= distancesRef.current.length) {
progressRef.current = totalDistanceRef.current;
timeoutRef.current = setTimeout(() => {
if (!isAgvReady()) {
isWaiting.current = false;
return;
}
let nextPath = [];
let nextPhase = currentPhase;
if (currentPhase === "toDrop") {
nextPath = dropPickupPath;
nextPhase = "toPickup";
setBoxVisible(false);
} else if (currentPhase === "toPickup") {
// When returning to start point (toPickup phase completed)
// Set position to toPickupPath[1] instead of [0]
if (toPickupPath.length > 1) {
object.position.copy(new THREE.Vector3(...toPickupPath[1]));
// Also set rotation towards the next point if available
if (toPickupPath.length > 2) {
const nextPoint = new THREE.Vector3(...toPickupPath[2]);
const direction = nextPoint
.clone()
.sub(object.position)
.normalize();
object.rotation.y = Math.atan2(direction.x, direction.z);
}
}
// Reset the path and mark start point as reached
setPath([]);
startPointReached.current = true;
progressRef.current = 0;
distancesRef.current = [];
// Stop the AGV by setting isplaying to false
if (currentAgv) {
currentAgv.isplaying = false;
}
// Clear timeout and return to prevent further movement
if (timeoutRef.current) {
clearTimeout(timeoutRef.current);
timeoutRef.current = null;
}
return;
} else {
nextPath = pickupDropPath;
nextPhase = "toDrop";
setBoxVisible(true);
}
setPath([...nextPath]);
setCurrentPhase(nextPhase);
progressRef.current = 0;
isWaiting.current = false;
distancesRef.current = [];
// Reset hit count for the next cycle
if (agvRef.current) {
agvRef.current = agvRef.current.map((agv: AGVData) =>
agv.vehicleId === id ? { ...agv, hitCount: 0 } : agv
);
}
}, bufferTime * 1000);
return;
}
// Step 4: Interpolate position and rotation
const start = new THREE.Vector3(...path[index]); const start = new THREE.Vector3(...path[index]);
const end = new THREE.Vector3(...path[index + 1]); const end = new THREE.Vector3(...path[index + 1]);
const dist = distancesRef.current[index]; const dist = distances[index];
if (!dist || dist === 0) return;
const t = THREE.MathUtils.clamp((covered - accumulated) / dist, 0, 1); const t = THREE.MathUtils.clamp((covered - accumulated) / dist, 0, 1);
object.position.copy(start.clone().lerp(end, t)); object.position.copy(start.clone().lerp(end, t));
const direction = new THREE.Vector3().subVectors(end, start).normalize(); if (dist > 0.1) {
object.rotation.y = Math.atan2(direction.x, direction.z); const targetDirection = end.clone().sub(start).normalize();
}); const targetRotationY = Math.atan2(targetDirection.x, targetDirection.z);
const rotationSpeed = Math.min(5 * delta, 1);
object.rotation.y = THREE.MathUtils.lerp(object.rotation.y, targetRotationY, rotationSpeed);
}
return false;
}
useEffect(() => { useEffect(() => {
return () => { return () => {

1
app/src/modules/scene/IntialLoad/loadInitialFloorItems.ts
View File

@ -20,7 +20,6 @@ async function loadInitialFloorItems(
const organization = (email!.split("@")[1]).split(".")[0]; const organization = (email!.split("@")[1]).split(".")[0];
const items = await getFloorAssets(organization); const items = await getFloorAssets(organization);
console.log('items: ', items);
localStorage.setItem("FloorItems", JSON.stringify(items)); localStorage.setItem("FloorItems", JSON.stringify(items));
await initializeDB(); await initializeDB();

6
app/src/modules/scene/controls/selection/selectionControls.tsx
View File

@ -14,7 +14,6 @@ import CopyPasteControls from "./copyPasteControls";
import MoveControls from "./moveControls"; import MoveControls from "./moveControls";
import RotateControls from "./rotateControls"; import RotateControls from "./rotateControls";
import useModuleStore from "../../../../store/useModuleStore"; import useModuleStore from "../../../../store/useModuleStore";
import { detectModifierKeys } from "../../../../utils/shortcutkeys/detectModifierKeys";
const SelectionControls: React.FC = () => { const SelectionControls: React.FC = () => {
const { camera, controls, gl, scene, pointer } = useThree(); const { camera, controls, gl, scene, pointer } = useThree();
@ -102,13 +101,12 @@ const SelectionControls: React.FC = () => {
}; };
const onKeyDown = (event: KeyboardEvent) => { const onKeyDown = (event: KeyboardEvent) => {
const keyCombination = detectModifierKeys(event);
if (movedObjects.length > 0 || rotatedObjects.length > 0) return; if (movedObjects.length > 0 || rotatedObjects.length > 0) return;
if (keyCombination === "ESCAPE") { if (event.key.toLowerCase() === "escape") {
event.preventDefault(); event.preventDefault();
clearSelection(); clearSelection();
} }
if (keyCombination === "DELETE") { if (event.key.toLowerCase() === "delete") {
event.preventDefault(); event.preventDefault();
deleteSelection(); deleteSelection();
} }

121
app/src/modules/simulation/process/processAnimator.tsx
View File

@ -26,6 +26,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
}) => { }) => {
const gltf = useLoader(GLTFLoader, crate) as GLTF; const gltf = useLoader(GLTFLoader, crate) as GLTF;
const groupRef = useRef<THREE.Group>(null); const groupRef = useRef<THREE.Group>(null);
const tempStackedObjectsRef = useRef<Record<string, boolean>>({});
const { const {
animationStates, animationStates,
@ -43,27 +44,19 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
checkAndCountTriggers, checkAndCountTriggers,
} = useProcessAnimation(processes, setProcesses, agvRef); } = useProcessAnimation(processes, setProcesses, agvRef);
const baseMaterials = useMemo( const baseMaterials = useMemo(() => ({
() => ({ Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }),
Box: new THREE.MeshStandardMaterial({ color: 0x8b4513 }), Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }),
Crate: new THREE.MeshStandardMaterial({ color: 0x00ff00 }), Default: new THREE.MeshStandardMaterial(),
// Default: new THREE.MeshStandardMaterial({ color: 0x00ff00 }), }), []);
Default: new THREE.MeshStandardMaterial(),
}),
[]
);
useEffect(() => { useEffect(() => {
// Update material references for all spawned objects // Update material references for all spawned objects
Object.entries(animationStates).forEach(([processId, processState]) => { Object.entries(animationStates).forEach(([processId, processState]) => {
Object.keys(processState.spawnedObjects).forEach((objectId) => { Object.keys(processState.spawnedObjects).forEach((objectId) => {
const entry = { const entry = { processId, objectId, };
processId,
objectId,
};
const materialType = const materialType = processState.spawnedObjects[objectId]?.currentMaterialType;
processState.spawnedObjects[objectId]?.currentMaterialType;
if (!materialType) { if (!materialType) {
return; return;
@ -72,17 +65,13 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
const matRefArray = MaterialRef.current; const matRefArray = MaterialRef.current;
// Find existing material group // Find existing material group
const existing = matRefArray.find( const existing = matRefArray.find((entryGroup: { material: string; objects: any[] }) =>
(entryGroup: { material: string; objects: any[] }) => entryGroup.material === materialType
entryGroup.material === materialType
); );
if (existing) { if (existing) {
// Check if this processId + objectId already exists // Check if this processId + objectId already exists
const alreadyExists = existing.objects.some( const alreadyExists = existing.objects.some((o: any) => o.processId === entry.processId && o.objectId === entry.objectId);
(o: any) =>
o.processId === entry.processId && o.objectId === entry.objectId
);
if (!alreadyExists) { if (!alreadyExists) {
existing.objects.push(entry); existing.objects.push(entry);
@ -102,8 +91,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
useFrame(() => { useFrame(() => {
// Spawn logic frame // Spawn logic frame
const currentTime = const currentTime = clockRef.current.getElapsedTime() - elapsedBeforePauseRef.current;
clockRef.current.getElapsedTime() - elapsedBeforePauseRef.current;
setAnimationStates((prev) => { setAnimationStates((prev) => {
const newStates = { ...prev }; const newStates = { ...prev };
@ -131,10 +119,7 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
: parseFloat(spawnAction.spawnInterval as string) || 0; : parseFloat(spawnAction.spawnInterval as string) || 0;
// Check if this is a zero interval spawn and we already spawned an object // Check if this is a zero interval spawn and we already spawned an object
if ( if (spawnInterval === 0 && processState.hasSpawnedZeroIntervalObject === true) {
spawnInterval === 0 &&
processState.hasSpawnedZeroIntervalObject === true
) {
return; // Don't spawn more objects for zero interval return; // Don't spawn more objects for zero interval
} }
@ -312,35 +297,87 @@ const ProcessAnimator: React.FC<ProcessContainerProps> = ({
// } // }
// } // }
// if (isLastPoint) {
// if (currentPointData?.actions) {
// const hasNonInherit = hasNonInheritActions(
// currentPointData.actions
// );
// if (!hasNonInherit) {
// // Remove the object if all actions are inherit
// updatedObjects[objectId] = {
// ...obj,
// visible: false,
// state: { ...stateRef, isAnimating: false },
// };
// return;
// }
// } else {
// // No actions at last point - remove the object
// updatedObjects[objectId] = {
// ...obj,
// visible: false,
// state: { ...stateRef, isAnimating: false },
// };
// return;
// }
// }
if (isLastPoint) { if (isLastPoint) {
if (currentPointData?.actions) { const isAgvPicking = agvRef.current.some(
const hasNonInherit = hasNonInheritActions( (agv: any) => agv.processId === process.id && agv.status === "picking"
currentPointData.actions );
);
if (!hasNonInherit) { const shouldHide = !currentPointData?.actions || !hasNonInheritActions(currentPointData.actions);
// Remove the object if all actions are inherit
if (shouldHide) {
if (isAgvPicking) {
updatedObjects[objectId] = { updatedObjects[objectId] = {
...obj, ...obj,
visible: false, visible: false,
state: { ...stateRef, isAnimating: false }, state: {
...stateRef,
isAnimating: false,
},
};
} else {
tempStackedObjectsRef.current[objectId] = true;
updatedObjects[objectId] = {
...obj,
visible: true,
state: {
...stateRef,
isAnimating: true,
},
}; };
return;
} }
} else {
// No actions at last point - remove the object return;
}
}
if (tempStackedObjectsRef.current[objectId]) {
const isAgvPicking = agvRef.current.some(
(agv: any) => agv.processId === process.id && agv.status === "picking"
);
if (isAgvPicking) {
delete tempStackedObjectsRef.current[objectId];
updatedObjects[objectId] = { updatedObjects[objectId] = {
...obj, ...obj,
visible: false, visible: false,
state: { ...stateRef, isAnimating: false }, state: {
...stateRef,
isAnimating: false,
},
}; };
return;
} }
} }
if (!isLastPoint) { if (!isLastPoint) {
const nextPoint = path[nextPointIdx]; const nextPoint = path[nextPointIdx];
const distance = const distance = path[stateRef.currentIndex].distanceTo(nextPoint);
path[stateRef.currentIndex].distanceTo(nextPoint);
const effectiveSpeed = stateRef.speed * speedRef.current; const effectiveSpeed = stateRef.speed * speedRef.current;
const movement = effectiveSpeed * delta; const movement = effectiveSpeed * delta;

36
app/src/modules/simulation/process/processCreator.tsx
View File

@ -57,7 +57,7 @@
// pointActions: PointAction[][]; // pointActions: PointAction[][];
// pointTriggers: PointTrigger[][]; // pointTriggers: PointTrigger[][];
// speed: number; // speed: number;
// isplaying: boolean; // isActive: boolean;
// } // }
// interface ProcessCreatorProps { // interface ProcessCreatorProps {
@ -147,7 +147,7 @@
// pointActions: [], // pointActions: [],
// pointTriggers: [], // Added point triggers array // pointTriggers: [], // Added point triggers array
// speed: 1, // speed: 1,
// isplaying: false, // isActive: false,
// }); // });
// // Enhanced connection checking function // // Enhanced connection checking function
@ -283,7 +283,7 @@
// pointActions, // pointActions,
// pointTriggers, // pointTriggers,
// speed: processSpeed, // speed: processSpeed,
// isplaying: false, // isActive: false,
// }; // };
// }, // },
// [scene] // [scene]
@ -410,7 +410,7 @@
// p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID) // p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID)
// ) // )
// .join(","), // .join(","),
// isplaying: false, // isActive: false,
// })); // }));
// }, [convertedPaths]); // }, [convertedPaths]);
@ -459,6 +459,7 @@ import {
ConveyorEventsSchema, ConveyorEventsSchema,
VehicleEventsSchema, VehicleEventsSchema,
} from "../../../types/world/worldTypes"; } from "../../../types/world/worldTypes";
import { usePlayButtonStore } from "../../../store/usePlayButtonStore";
// Type definitions // Type definitions
export interface PointAction { export interface PointAction {
@ -495,7 +496,7 @@ export interface SimulationPath {
points: PathPoint[]; points: PathPoint[];
pathPosition: [number, number, number]; pathPosition: [number, number, number];
speed?: number; speed?: number;
isplaying: boolean; isActive: boolean;
} }
export interface Process { export interface Process {
@ -505,7 +506,7 @@ export interface Process {
pointActions: PointAction[][]; pointActions: PointAction[][];
pointTriggers: PointTrigger[][]; pointTriggers: PointTrigger[][];
speed: number; speed: number;
isplaying: boolean; isActive: boolean;
} }
interface ProcessCreatorProps { interface ProcessCreatorProps {
@ -538,13 +539,13 @@ function convertToSimulationPath(
actions: Array.isArray(point.actions) actions: Array.isArray(point.actions)
? point.actions.map(normalizeAction) ? point.actions.map(normalizeAction)
: point.actions : point.actions
? [normalizeAction(point.actions)] ? [normalizeAction(point.actions)]
: [], : [],
triggers: Array.isArray(point.triggers) triggers: Array.isArray(point.triggers)
? point.triggers.map(normalizeTrigger) ? point.triggers.map(normalizeTrigger)
: point.triggers : point.triggers
? [normalizeTrigger(point.triggers)] ? [normalizeTrigger(point.triggers)]
: [], : [],
connections: { connections: {
targets: point.connections.targets.map((target) => ({ targets: point.connections.targets.map((target) => ({
modelUUID: target.modelUUID, modelUUID: target.modelUUID,
@ -556,7 +557,7 @@ function convertToSimulationPath(
typeof path.speed === "string" typeof path.speed === "string"
? parseFloat(path.speed) || 1 ? parseFloat(path.speed) || 1
: path.speed || 1, : path.speed || 1,
isplaying: false, // Added missing property isActive: false, // Added missing property
}; };
} else { } else {
// For vehicle paths, handle the case where triggers might not exist // For vehicle paths, handle the case where triggers might not exist
@ -570,8 +571,8 @@ function convertToSimulationPath(
actions: Array.isArray(path.points.actions) actions: Array.isArray(path.points.actions)
? path.points.actions.map(normalizeAction) ? path.points.actions.map(normalizeAction)
: path.points.actions : path.points.actions
? [normalizeAction(path.points.actions)] ? [normalizeAction(path.points.actions)]
: [], : [],
triggers: [], triggers: [],
connections: { connections: {
targets: path.points.connections.targets.map((target) => ({ targets: path.points.connections.targets.map((target) => ({
@ -582,7 +583,7 @@ function convertToSimulationPath(
], ],
pathPosition: path.position, pathPosition: path.position,
speed: path.points.speed || 1, speed: path.points.speed || 1,
isplaying: false, isActive: false,
}; };
} }
} }
@ -595,7 +596,7 @@ const createEmptyProcess = (): Process => ({
pointActions: [], pointActions: [],
pointTriggers: [], // Added point triggers array pointTriggers: [], // Added point triggers array
speed: 1, speed: 1,
isplaying: false, isActive: false,
}); });
// Enhanced connection checking function // Enhanced connection checking function
@ -731,7 +732,7 @@ export function useProcessCreation() {
pointActions, pointActions,
pointTriggers, pointTriggers,
speed: processSpeed, speed: processSpeed,
isplaying: false, isActive: false,
}; };
}, },
[scene] [scene]
@ -824,6 +825,7 @@ const ProcessCreator: React.FC<ProcessCreatorProps> = React.memo(
const { createProcessesFromPaths } = useProcessCreation(); const { createProcessesFromPaths } = useProcessCreation();
const prevPathsRef = useRef<SimulationPath[]>([]); const prevPathsRef = useRef<SimulationPath[]>([]);
const prevProcessesRef = useRef<Process[]>([]); const prevProcessesRef = useRef<Process[]>([]);
const { isPlaying } = usePlayButtonStore();
const convertedPaths = useMemo((): SimulationPath[] => { const convertedPaths = useMemo((): SimulationPath[] => {
if (!simulationStates) return []; if (!simulationStates) return [];
@ -858,7 +860,7 @@ const ProcessCreator: React.FC<ProcessCreatorProps> = React.memo(
p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID) p.connections.targets.map((t: { modelUUID: string }) => t.modelUUID)
) )
.join(","), .join(","),
isplaying: false, isActive: false,
})); }));
}, [convertedPaths]); }, [convertedPaths]);

2
app/src/modules/simulation/process/types.ts
View File

@ -39,7 +39,7 @@ export interface ProcessPath {
pathRotation: number[]; pathRotation: number[];
speed: number; speed: number;
type: "Conveyor" | "Vehicle"; type: "Conveyor" | "Vehicle";
isplaying: boolean isActive: boolean
} }
export interface ProcessData { export interface ProcessData {

1027
app/src/modules/simulation/process/useProcessAnimations.tsx
View File

File diff suppressed because it is too large Load Diff

1
app/src/modules/simulation/simulation.tsx
View File

@ -15,7 +15,6 @@ import Agv from "../builder/agv/agv";
function Simulation() { function Simulation() {
const { activeModule } = useModuleStore(); const { activeModule } = useModuleStore();
const pathsGroupRef = useRef() as React.MutableRefObject<THREE.Group>; const pathsGroupRef = useRef() as React.MutableRefObject<THREE.Group>;
const { simulationStates, setSimulationStates } = useSimulationStates();
const [processes, setProcesses] = useState<any[]>([]); const [processes, setProcesses] = useState<any[]>([]);
const agvRef = useRef([]); const agvRef = useRef([]);
const MaterialRef = useRef([]); const MaterialRef = useRef([]);