Refactor aisle API services: remove createAisleApi, update deleteAisleApi to include versionId, and modify wall asset APIs for consistency in endpoint naming. Enhance floor and wall store functionality with new setters and methods for managing floors and walls, including decal handling. Introduce FloorInstance and FloorInstances components for rendering floor data, and implement FloorCreator for interactive floor creation. Add reference floor visualization with snapping capabilities. Update wall API services for improved error handling and response management.

app/src/modules/builder/point/helpers/usePointSnapping.tsx

@@ -11,9 +11,10 @@ const ANGLE_SNAP_DISTANCE_THRESHOLD = 0.5;  // Distance threshold for snapping i
 const CAN_ANGLE_SNAP = true; // Whether snapping is enabled or not
 
 export const usePointSnapping = (currentPoint: { uuid: string, pointType: string, position: [number, number, number] } | null) => {
-    const { aisleStore, wallStore } = useSceneContext();
+    const { aisleStore, wallStore, floorStore } = useSceneContext();
     const { aisles, getConnectedPoints: getConnectedAislePoints } = aisleStore();
     const { walls, getConnectedPoints: getConnectedWallPoints } = wallStore();
+    const { floors, getConnectedPoints: getConnectedFloorPoints } = floorStore();
 
     // Wall Snapping
 
@@ -24,10 +25,13 @@ export const usePointSnapping = (currentPoint: { uuid: string, pointType: string
         );
     }, [walls, currentPoint]);
 
-    const snapWallPoint = useCallback((position: [number, number, number]) => {
+    const snapWallPoint = useCallback((position: [number, number, number], tempPoints?: Point) => {
         if (!currentPoint || !CAN_POINT_SNAP) return { position: position, isSnapped: false, snappedPoint: null };
 
         const otherPoints = getAllOtherWallPoints();
+        if (tempPoints) {
+            otherPoints.push(tempPoints);
+        }
         const currentVec = new THREE.Vector3(...position);
         for (const point of otherPoints) {
             const pointVec = new THREE.Vector3(...point.position);
@@ -187,10 +191,96 @@ export const usePointSnapping = (currentPoint: { uuid: string, pointType: string
         };
     }, [currentPoint, getConnectedAislePoints]);
 
+    // Floor Snapping
+
+    const getAllOtherFloorPoints = useCallback(() => {
+        if (!currentPoint) return [];
+
+        return floors.flatMap(floor =>
+            floor.points.filter(point => point.pointUuid !== currentPoint.uuid)
+        );
+    }, [floors, currentPoint]);
+
+    const snapFloorPoint = useCallback((position: [number, number, number], tempPoints: Point[] | []) => {
+        if (!currentPoint || !CAN_POINT_SNAP) return { position: position, isSnapped: false, snappedPoint: null };
+
+        const otherPoints = [...getAllOtherFloorPoints(), ...tempPoints];
+        const currentVec = new THREE.Vector3(...position);
+
+        for (const point of otherPoints) {
+            const pointVec = new THREE.Vector3(...point.position);
+            const distance = currentVec.distanceTo(pointVec);
+
+            if (distance <= POINT_SNAP_THRESHOLD && currentPoint.pointType === 'Floor') {
+                return { position: point.position, isSnapped: true, snappedPoint: point };
+            }
+        }
+
+        return { position: position, isSnapped: false, snappedPoint: null };
+    }, [currentPoint, getAllOtherFloorPoints]);
+
+    const snapFloorAngle = useCallback((newPosition: [number, number, number]): {
+        position: [number, number, number],
+        isSnapped: boolean,
+        snapSources: THREE.Vector3[]
+    } => {
+        if (!currentPoint || !CAN_ANGLE_SNAP) return { position: newPosition, isSnapped: false, snapSources: [] };
+
+        const connectedPoints = getConnectedFloorPoints(currentPoint.uuid);
+        if (connectedPoints.length === 0) {
+            return { position: newPosition, isSnapped: false, snapSources: [] };
+        }
+
+        const newPos = new THREE.Vector3(...newPosition);
+        let closestX: { pos: THREE.Vector3, dist: number } | null = null;
+        let closestZ: { pos: THREE.Vector3, dist: number } | null = null;
+
+        for (const connectedPoint of connectedPoints) {
+            const cPos = new THREE.Vector3(...connectedPoint.position);
+            const xDist = Math.abs(newPos.x - cPos.x);
+            const zDist = Math.abs(newPos.z - cPos.z);
+
+            if (xDist < ANGLE_SNAP_DISTANCE_THRESHOLD) {
+                if (!closestX || xDist < closestX.dist) {
+                    closestX = { pos: cPos, dist: xDist };
+                }
+            }
+
+            if (zDist < ANGLE_SNAP_DISTANCE_THRESHOLD) {
+                if (!closestZ || zDist < closestZ.dist) {
+                    closestZ = { pos: cPos, dist: zDist };
+                }
+            }
+        }
+
+        const snappedPos = newPos.clone();
+        const snapSources: THREE.Vector3[] = [];
+
+        if (closestX) {
+            snappedPos.x = closestX.pos.x;
+            snapSources.push(closestX.pos.clone());
+        }
+
+        if (closestZ) {
+            snappedPos.z = closestZ.pos.z;
+            snapSources.push(closestZ.pos.clone());
+        }
+
+        const isSnapped = snapSources.length > 0;
+
+        return {
+            position: [snappedPos.x, snappedPos.y, snappedPos.z],
+            isSnapped,
+            snapSources
+        };
+    }, [currentPoint, getConnectedFloorPoints]);
+
     return {
         snapAislePoint,
         snapAisleAngle,
         snapWallPoint,
         snapWallAngle,
+        snapFloorPoint,
+        snapFloorAngle,
     };
 };