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

Merge remote-tracking branch 'origin/v2' into v2-ui

This commit is contained in:
Vishnu 2025-05-21 12:59:44 +05:30
parent 39e3b28ba7 60a277f7f0
commit 1eb5522716
5 changed files with 343 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
app/src/modules/simulation/events/arrows/arrows.tsx
View File

@ -160,29 +160,26 @@ export function ArrowOnQuadraticBezier({
const arrowRadius = 0.01 * scale; const arrowRadius = 0.01 * scale;
const arrowHeadRadius = arrowRadius * 2.5; const arrowHeadRadius = arrowRadius * 2.5;
const curveLength = useMemo(() => fullCurve.getLength(), [fullCurve]);
const arrowHeadTOffset = useMemo(() => Math.min(arrowHeadLength / curveLength, 0.5), [arrowHeadLength, curveLength]);
const endT = 1 - arrowHeadTOffset;
const subCurve = useMemo(() => { const subCurve = useMemo(() => {
const t1 = Math.max(0, endT - segmentSize / 2); const centerT = 0.5;
const t2 = Math.min(1, endT + segmentSize / 2); const t1 = Math.max(0, centerT - segmentSize / 2);
const t2 = Math.min(1, centerT + segmentSize / 2);
const divisions = 10; const divisions = 10;
const subPoints = Array.from({ length: divisions + 1 }, (_, i) => { const subPoints = Array.from({ length: divisions + 1 }, (_, i) => {
const t = THREE.MathUtils.lerp(t1, t2, i / divisions); const t = THREE.MathUtils.lerp(t1, t2, i / divisions);
return fullCurve.getPoint(t); return fullCurve.getPoint(t);
}); });
return new THREE.CatmullRomCurve3(subPoints); return new THREE.CatmullRomCurve3(subPoints);
}, [fullCurve, endT, segmentSize]); }, [fullCurve, segmentSize]);
const tubeGeometry = useMemo( const tubeGeometry = useMemo(
() => new THREE.TubeGeometry(subCurve, 20, arrowRadius, 8, false), () => new THREE.TubeGeometry(subCurve, 20, arrowRadius, 8, false),
[subCurve, arrowRadius] [subCurve, arrowRadius]
); );
const arrowPosition = useMemo(() => fullCurve.getPoint(1), [fullCurve]); const arrowPosition = useMemo(() => subCurve.getPoint(1), [subCurve]);
const arrowTangent = useMemo(() => fullCurve.getTangent(1).normalize(), [fullCurve]); const arrowTangent = useMemo(() => subCurve.getTangent(1).normalize(), [subCurve]);
const arrowRotation = useMemo(() => { const arrowRotation = useMemo(() => {
return new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), arrowTangent); return new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), arrowTangent);

22
app/src/modules/simulation/events/points/creator/pointsCreator.tsx
View File

@ -15,7 +15,7 @@ function PointsCreator() {
const { gl, raycaster, scene, pointer, camera } = useThree(); const { gl, raycaster, scene, pointer, camera } = useThree();
const { subModule } = useSubModuleStore(); const { subModule } = useSubModuleStore();
const { events, updatePoint, getPointByUuid, getEventByModelUuid } = useEventsStore(); const { events, updatePoint, getPointByUuid, getEventByModelUuid } = useEventsStore();
const { getEventByModelUuid: getEventByModelUuidFromProduct, updatePoint: updatePointFromProduct, getEventByModelUuid: getEventByModelUuidFromProduct2 } = useProductStore(); const { getEventByModelUuid: getEventByModelUuidFromProduct, updatePoint: updatePointFromProduct, getEventByModelUuid: getEventByModelUuidFromProduct2, getPointByUuid: getPointByUuidFromProduct } = useProductStore();
const { selectedProduct } = useSelectedProduct(); const { selectedProduct } = useSelectedProduct();
const { activeModule } = useModuleStore(); const { activeModule } = useModuleStore();
const transformRef = useRef<any>(null); const transformRef = useRef<any>(null);
@ -76,7 +76,7 @@ function PointsCreator() {
}, [selectedEventSphere]); }, [selectedEventSphere]);
const updatePointToState = (selectedEventSphere: THREE.Mesh) => { const updatePointToState = (selectedEventSphere: THREE.Mesh) => {
let point = JSON.parse( let point: PointsScheme = JSON.parse(
JSON.stringify( JSON.stringify(
getPointByUuid( getPointByUuid(
selectedEventSphere.userData.modelUuid, selectedEventSphere.userData.modelUuid,
@ -90,15 +90,30 @@ function PointsCreator() {
selectedEventSphere.position.y, selectedEventSphere.position.y,
selectedEventSphere.position.z, selectedEventSphere.position.z,
]; ];
point.rotation = [
selectedEventSphere.rotation.x,
selectedEventSphere.rotation.y,
selectedEventSphere.rotation.z,
];
const event = getEventByModelUuidFromProduct(selectedProduct.productId, selectedEventSphere.userData.modelUuid); const event = getEventByModelUuidFromProduct(selectedProduct.productId, selectedEventSphere.userData.modelUuid);
if (event && selectedProduct.productId !== '') { if (event && selectedProduct.productId !== '') {
const updatedPoint = JSON.parse(
JSON.stringify(
getPointByUuidFromProduct(selectedProduct.productId, selectedEventSphere.userData.modelUuid, selectedEventSphere.userData.pointUuid)
)
);
if (updatedPoint) {
updatedPoint.position = point.position;
updatedPoint.rotation = point.rotation;
const updatedEvent = updatePointFromProduct( const updatedEvent = updatePointFromProduct(
selectedProduct.productId, selectedProduct.productId,
selectedEventSphere.userData.modelUuid, selectedEventSphere.userData.modelUuid,
selectedEventSphere.userData.pointUuid, selectedEventSphere.userData.pointUuid,
point updatedPoint
) )
if (updatedEvent) { if (updatedEvent) {
updatePoint( updatePoint(
@ -115,6 +130,7 @@ function PointsCreator() {
} }
} }
} }
}
}; };
useEffect(() => { useEffect(() => {

65
app/src/modules/simulation/machine/eventManager/useMachineEventManager.ts Normal file
View File

@ -0,0 +1,65 @@
import { useEffect, useRef } from 'react';
import { useFrame } from '@react-three/fiber';
import { useMachineStore } from '../../../../store/simulation/useMachineStore';
type MachineCallback = {
machineId: string;
callback: () => void;
};
export function useMachineEventManager() {
const { getMachineById } = useMachineStore();
const callbacksRef = useRef<MachineCallback[]>([]);
const isMonitoringRef = useRef(false);
// Add a new machine to monitor
const addMachineToMonitor = (machineId: string, callback: () => void) => {
// Avoid duplicates
if (!callbacksRef.current.some((entry) => entry.machineId === machineId)) {
callbacksRef.current.push({ machineId, callback });
}
// Start monitoring if not already running
if (!isMonitoringRef.current) {
isMonitoringRef.current = true;
}
};
// Remove a machine from monitoring
const removeMachineFromMonitor = (machineId: string) => {
callbacksRef.current = callbacksRef.current.filter(
(entry) => entry.machineId !== machineId
);
// Stop monitoring if no more machines to track
if (callbacksRef.current.length === 0) {
isMonitoringRef.current = false;
}
};
// Check machine states every frame
useFrame(() => {
if (!isMonitoringRef.current || callbacksRef.current.length === 0) return;
callbacksRef.current.forEach(({ machineId, callback }) => {
const machine = getMachineById(machineId);
if (machine && machine.isActive === false && machine.state === 'idle' && !machine.currentAction) {
callback();
removeMachineFromMonitor(machineId); // Remove after triggering
}
});
});
// Cleanup on unmount
useEffect(() => {
return () => {
callbacksRef.current = [];
isMonitoringRef.current = false;
};
}, []);
return {
addMachineToMonitor,
removeMachineFromMonitor,
};
}

167
app/src/modules/simulation/triggers/triggerHandler/useTriggerHandler.ts
View File

@ -10,6 +10,8 @@ import { useStorageUnitStore } from '../../../../store/simulation/useStorageUnit
import { useArmBotEventManager } from '../../roboticArm/eventManager/useArmBotEventManager'; import { useArmBotEventManager } from '../../roboticArm/eventManager/useArmBotEventManager';
import { useConveyorStore } from '../../../../store/simulation/useConveyorStore'; import { useConveyorStore } from '../../../../store/simulation/useConveyorStore';
import { useConveyorEventManager } from '../../conveyor/eventManager/useConveyorEventManager'; import { useConveyorEventManager } from '../../conveyor/eventManager/useConveyorEventManager';
import { useVehicleEventManager } from '../../vehicle/instances/eventManager/useVehicleEventManager';
import { useMachineEventManager } from '../../machine/eventManager/useMachineEventManager';
export function useTriggerHandler() { export function useTriggerHandler() {
const { handleAction } = useActionHandler(); const { handleAction } = useActionHandler();
@ -19,6 +21,8 @@ export function useTriggerHandler() {
const { getConveyorById } = useConveyorStore(); const { getConveyorById } = useConveyorStore();
const { addArmBotToMonitor } = useArmBotEventManager(); const { addArmBotToMonitor } = useArmBotEventManager();
const { addConveyorToMonitor } = useConveyorEventManager(); const { addConveyorToMonitor } = useConveyorEventManager();
const { addVehicleToMonitor } = useVehicleEventManager();
const { addMachineToMonitor } = useMachineEventManager();
const { getVehicleById } = useVehicleStore(); const { getVehicleById } = useVehicleStore();
const { getMachineById } = useMachineStore(); const { getMachineById } = useMachineStore();
const { getStorageUnitById } = useStorageUnitStore(); const { getStorageUnitById } = useStorageUnitStore();
@ -89,7 +93,7 @@ export function useTriggerHandler() {
if (vehicle) { if (vehicle) {
if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.currentLoad < vehicle.point.action.loadCapacity) { if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.isPicking && vehicle.currentLoad < vehicle.point.action.loadCapacity) {
setIsVisible(materialId, false); setIsVisible(materialId, false);
@ -98,8 +102,10 @@ export function useTriggerHandler() {
} else { } else {
// Event Manager Needed // Handle current action using Event Manager
addVehicleToMonitor(vehicle.modelUuid, () => {
handleAction(action, materialId);
})
} }
} }
} }
@ -140,7 +146,78 @@ export function useTriggerHandler() {
if (action) { if (action) {
if (armBot) { if (armBot) {
if (action && action.triggers.length > 0 &&
action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid &&
action.triggers[0]?.triggeredAsset?.triggeredAction?.actionUuid &&
action.triggers[0]?.triggeredAsset?.triggeredPoint?.pointUuid) {
const model = getEventByModelUuid(selectedProduct.productId, action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid);
if (model?.type === 'vehicle') {
const vehicle = getVehicleById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid);
if (vehicle) {
if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.isPicking && vehicle.currentLoad < vehicle.point.action.loadCapacity) {
// Handle current action from vehicle
setIsPaused(materialId, true);
handleAction(action, materialId);
} else {
// Handle current action using Event Manager
setIsPaused(materialId, true);
addVehicleToMonitor(vehicle.modelUuid,
() => {
handleAction(action, materialId);
}
)
}
}
} else if (model?.type === 'machine') {
const armBot = getArmBotById(trigger.triggeredAsset?.triggeredModel.modelUuid);
if (armBot) {
if (armBot.isActive === false && armBot.state === 'idle') {
const machine = getMachineById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid);
if (machine) {
if (machine.isActive === false && machine.state === 'idle' && !machine.currentAction) {
setIsPaused(materialId, true);
handleAction(action, materialId);
} else {
// Handle current action using Event Manager
setIsPaused(materialId, true);
addMachineToMonitor(machine.modelUuid,
() => {
handleAction(action, materialId);
}
)
}
}
} else {
addArmBotToMonitor(armBot.modelUuid,
() => {
const machine = getMachineById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '');
if (machine) {
if (machine.isActive === false && machine.state === 'idle' && !machine.currentAction) {
setIsPaused(materialId, true);
handleAction(action, materialId);
} else {
// Handle current action using Event Manager
setIsPaused(materialId, true);
addMachineToMonitor(machine.modelUuid,
() => {
handleAction(action, materialId);
}
)
}
}
}
);
}
}
} else {
if (armBot.isActive === false && armBot.state === 'idle') { if (armBot.isActive === false && armBot.state === 'idle') {
// Handle current action from arm bot // Handle current action from arm bot
@ -149,7 +226,7 @@ export function useTriggerHandler() {
} else { } else {
// Event Manager Needed // Handle current action using Event Manager
setIsPaused(materialId, true); setIsPaused(materialId, true);
addArmBotToMonitor(armBot.modelUuid, addArmBotToMonitor(armBot.modelUuid,
() => handleAction(action, materialId) () => handleAction(action, materialId)
@ -157,6 +234,24 @@ export function useTriggerHandler() {
} }
} }
} else {
if (armBot.isActive === false && armBot.state === 'idle') {
// Handle current action from arm bot
setIsPaused(materialId, true);
handleAction(action, materialId);
} else {
// Handle current action using Event Manager
setIsPaused(materialId, true);
addArmBotToMonitor(armBot.modelUuid,
() => handleAction(action, materialId)
);
}
}
}
} }
} }
} }
@ -334,11 +429,20 @@ export function useTriggerHandler() {
if (model?.type === 'transfer') { if (model?.type === 'transfer') {
const conveyor = getConveyorById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || ''); const conveyor = getConveyorById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '');
if (conveyor) { if (conveyor) {
const previousModel = getEventByModelUuid(selectedProduct.productId, material.previous?.modelUuid || '');
if (previousModel) {
if (previousModel.type === 'transfer' && previousModel.modelUuid === model.modelUuid) {
handleAction(action, materialId)
} else {
addConveyorToMonitor(conveyor.modelUuid, addConveyorToMonitor(conveyor.modelUuid,
() => { () => {
handleAction(action, materialId) handleAction(action, materialId)
} }
) )
}
} else {
handleAction(action, materialId)
}
// handleAction(action, materialId) // handleAction(action, materialId)
} }
} else { } else {
@ -347,18 +451,28 @@ export function useTriggerHandler() {
} else { } else {
// Event Manager Needed // Handle current action using Event Manager
addArmBotToMonitor(armBot.modelUuid, addArmBotToMonitor(armBot.modelUuid,
() => { () => {
const model = getEventByModelUuid(selectedProduct.productId, action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || ''); const model = getEventByModelUuid(selectedProduct.productId, action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '');
if (model?.type === 'transfer') { if (model?.type === 'transfer') {
const conveyor = getConveyorById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || ''); const conveyor = getConveyorById(action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '');
if (conveyor) { if (conveyor) {
const previousModel = getEventByModelUuid(selectedProduct.productId, material.previous?.modelUuid || '');
if (previousModel) {
if (previousModel.type === 'transfer' && previousModel.modelUuid === model.modelUuid) {
handleAction(action, materialId)
} else {
addConveyorToMonitor(conveyor.modelUuid, addConveyorToMonitor(conveyor.modelUuid,
() => { () => {
handleAction(action, materialId) handleAction(action, materialId)
} }
) )
}
} else {
handleAction(action, materialId)
}
// handleAction(action, materialId) // handleAction(action, materialId)
} }
} else { } else {
@ -432,17 +546,54 @@ export function useTriggerHandler() {
if (vehicle) { if (vehicle) {
if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.currentLoad < vehicle.point.action.loadCapacity) { if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.isPicking && vehicle.currentLoad < vehicle.point.action.loadCapacity) {
setPreviousLocation(material.materialId, {
modelUuid: material.current.modelUuid,
pointUuid: material.current.pointUuid,
actionUuid: material.current.actionUuid,
})
setCurrentLocation(material.materialId, {
modelUuid: action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '',
pointUuid: action.triggers[0]?.triggeredAsset?.triggeredPoint?.pointUuid || '',
actionUuid: action.triggers[0]?.triggeredAsset?.triggeredAction?.actionUuid || '',
});
setNextLocation(material.materialId, null);
setIsVisible(materialId, false); setIsVisible(materialId, false);
setIsPaused(materialId, false);
// Handle current action from vehicle // Handle current action from vehicle
handleAction(nextAction, materialId); handleAction(nextAction, materialId);
} else { } else {
// Event Manager Needed // Handle current action using Event Manager
setIsPaused(materialId, true);
addVehicleToMonitor(vehicle.modelUuid,
() => {
setPreviousLocation(material.materialId, {
modelUuid: material.current.modelUuid,
pointUuid: material.current.pointUuid,
actionUuid: material.current.actionUuid,
})
setCurrentLocation(material.materialId, {
modelUuid: action.triggers[0]?.triggeredAsset?.triggeredModel.modelUuid || '',
pointUuid: action.triggers[0]?.triggeredAsset?.triggeredPoint?.pointUuid || '',
actionUuid: action.triggers[0]?.triggeredAsset?.triggeredAction?.actionUuid || '',
});
setNextLocation(material.materialId, null);
setIsPaused(materialId, false);
setIsVisible(materialId, false);
handleAction(nextAction, materialId);
}
)
} }
} }
} }
@ -491,7 +642,7 @@ export function useTriggerHandler() {
if (vehicle) { if (vehicle) {
if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.currentLoad < vehicle.point.action.loadCapacity) { if (vehicle.isActive === false && vehicle.state === 'idle' && vehicle.isPicking && vehicle.currentLoad < vehicle.point.action.loadCapacity) {
setIsVisible(materialId, false); setIsVisible(materialId, false);

65
app/src/modules/simulation/vehicle/instances/eventManager/useVehicleEventManager.ts Normal file
View File

@ -0,0 +1,65 @@
import { useEffect, useRef } from 'react';
import { useFrame } from '@react-three/fiber';
import { useVehicleStore } from '../../../../../store/simulation/useVehicleStore';
type VehicleCallback = {
vehicleId: string;
callback: () => void;
};
export function useVehicleEventManager() {
const { getVehicleById } = useVehicleStore();
const callbacksRef = useRef<VehicleCallback[]>([]);
const isMonitoringRef = useRef(false);
// Add a new vehicle to monitor
const addVehicleToMonitor = (vehicleId: string, callback: () => void) => {
// Avoid duplicates
if (!callbacksRef.current.some((entry) => entry.vehicleId === vehicleId)) {
callbacksRef.current.push({ vehicleId, callback });
}
// Start monitoring if not already running
if (!isMonitoringRef.current) {
isMonitoringRef.current = true;
}
};
// Remove a vehicle from monitoring
const removeVehicleFromMonitor = (vehicleId: string) => {
callbacksRef.current = callbacksRef.current.filter(
(entry) => entry.vehicleId !== vehicleId
);
// Stop monitoring if no more vehicles to track
if (callbacksRef.current.length === 0) {
isMonitoringRef.current = false;
}
};
// Check vehicle states every frame
useFrame(() => {
if (!isMonitoringRef.current || callbacksRef.current.length === 0) return;
callbacksRef.current.forEach(({ vehicleId, callback }) => {
const vehicle = getVehicleById(vehicleId);
if (vehicle && vehicle.isActive === false && vehicle.state === 'idle' && vehicle.isPicking && vehicle.currentLoad < vehicle.point.action.loadCapacity) {
callback();
removeVehicleFromMonitor(vehicleId); // Remove after triggering
}
});
});
// Cleanup on unmount
useEffect(() => {
return () => {
callbacksRef.current = [];
isMonitoringRef.current = false;
};
}, []);
return {
addVehicleToMonitor,
removeVehicleFromMonitor,
};
}