diff --git a/app/src/components/ui/Tools.tsx b/app/src/components/ui/Tools.tsx
index f6389e9..7f66584 100644
--- a/app/src/components/ui/Tools.tsx
+++ b/app/src/components/ui/Tools.tsx
@@ -17,6 +17,7 @@ import { handleSaveTemplate } from "../../modules/visualization/handleSaveTempla
import { usePlayButtonStore } from "../../store/usePlayButtonStore";
import useTemplateStore from "../../store/useTemplateStore";
import { useSelectedZoneStore } from "../../store/useZoneStore";
+import { useAddAction, useDeleteModels, useSelectedWallItem, useToggleView } from "../../store/store";
const Tools: React.FC = () => {
const { templates } = useTemplateStore();
@@ -32,12 +33,32 @@ const Tools: React.FC = () => {
const { addTemplate } = useTemplateStore();
const { selectedZone } = useSelectedZoneStore();
+ // wall options
+ const { setToggleView } = useToggleView();
+ const { setDeleteModels } = useDeleteModels();
+ const { setAddAction } = useAddAction();
+ const { setSelectedWallItem } = useSelectedWallItem();
+
+
// Reset activeTool whenever activeModule changes
useEffect(() => {
setActiveTool(activeSubTool);
setActiveSubTool(activeSubTool);
}, [activeModule]);
+ const toggleSwitch = () => {
+ if (toggleThreeD) {
+ setSelectedWallItem(null);
+ setDeleteModels(false);
+ setAddAction(null);
+ setToggleView(true);
+ }
+ else {
+ setToggleView(false);
+ }
+ setToggleThreeD(!toggleThreeD);
+ };
+
useEffect(() => {
const handleOutsideClick = (event: MouseEvent) => {
if (
@@ -61,9 +82,8 @@ const Tools: React.FC = () => {
{activeSubTool == "cursor" && (
{
setActiveTool("cursor");
}}
@@ -73,9 +93,8 @@ const Tools: React.FC = () => {
)}
{activeSubTool == "free-hand" && (
{
setActiveTool("free-hand");
}}
@@ -134,9 +153,8 @@ const Tools: React.FC = () => {
{
setActiveTool("draw-wall");
}}
@@ -144,9 +162,8 @@ const Tools: React.FC = () => {
{
setActiveTool("draw-zone");
}}
@@ -154,9 +171,8 @@ const Tools: React.FC = () => {
{
setActiveTool("draw-aisle");
}}
@@ -164,9 +180,8 @@ const Tools: React.FC = () => {
{
setActiveTool("draw-floor");
}}
@@ -233,9 +248,7 @@ const Tools: React.FC = () => {
{
- setToggleThreeD(!toggleThreeD);
- }}
+ onClick={toggleSwitch}
>
2d
diff --git a/app/src/modules/builder/csg/csg.tsx b/app/src/modules/builder/csg/csg.tsx
new file mode 100644
index 0000000..0926710
--- /dev/null
+++ b/app/src/modules/builder/csg/csg.tsx
@@ -0,0 +1,54 @@
+import * as THREE from "three";
+import { Geometry, Base, Subtraction } from "@react-three/csg";
+import { useDeleteModels } from "../../../store/store";
+import { useRef } from "react";
+
+export interface CsgProps {
+ position: THREE.Vector3 | [number, number, number];
+ scale: THREE.Vector3 | [number, number, number];
+ model: THREE.Object3D;
+ hoveredDeletableWallItem: { current: THREE.Mesh | null };
+}
+
+export const Csg: React.FC
= (props) => {
+ const { deleteModels } = useDeleteModels();
+ const modelRef = useRef();
+ const originalMaterials = useRef>(new Map());
+
+ const handleHover = (hovered: boolean, object: THREE.Mesh | null) => {
+ if (modelRef.current && deleteModels) {
+ modelRef.current.traverse((child) => {
+ if (child instanceof THREE.Mesh) {
+ if (!originalMaterials.current.has(child)) {
+ originalMaterials.current.set(child, child.material);
+ }
+ child.material = child.material.clone();
+ child.material.color.set(hovered && deleteModels ? 0xff0000 : (originalMaterials.current.get(child) as any).color);
+ }
+ });
+ }
+ props.hoveredDeletableWallItem.current = hovered ? object : null;
+ };
+
+ return (
+
+
+
+
+
+
+ {
+ e.stopPropagation();
+ handleHover(true, e.object.parent);
+ }}
+ onPointerOut={(e: any) => {
+ e.stopPropagation();
+ handleHover(false, null);
+ }}
+ />
+
+ );
+};
diff --git a/app/src/modules/builder/eventDeclaration/dragControlDeclaration.ts b/app/src/modules/builder/eventDeclaration/dragControlDeclaration.ts
new file mode 100644
index 0000000..3e5bc5c
--- /dev/null
+++ b/app/src/modules/builder/eventDeclaration/dragControlDeclaration.ts
@@ -0,0 +1,80 @@
+import * as THREE from 'three';
+import { DragControls } from 'three/examples/jsm/controls/DragControls';
+import * as CONSTANTS from '../../../types/world/worldConstants';
+import DragPoint from '../geomentries/points/dragPoint';
+
+import * as Types from "../../../types/world/worldTypes";
+// import { updatePoint } from '../../../services/factoryBuilder/lines/updatePointApi';
+import { Socket } from 'socket.io-client';
+
+export default async function addDragControl(
+ dragPointControls: Types.RefDragControl,
+ currentLayerPoint: Types.RefMeshArray,
+ state: Types.ThreeState,
+ floorPlanGroupPoint: Types.RefGroup,
+ floorPlanGroupLine: Types.RefGroup,
+ lines: Types.RefLines,
+ onlyFloorlines: Types.RefOnlyFloorLines,
+ socket: Socket
+) {
+
+ ////////// Dragging Point and also change the size to indicate during hover //////////
+
+ dragPointControls.current = new DragControls(currentLayerPoint.current, state.camera, state.gl.domElement);
+ dragPointControls.current.enabled = false;
+
+ dragPointControls.current.addEventListener('drag', function (event) {
+ const object = event.object;
+ if (object.visible) {
+ (state.controls as any).enabled = false;
+ DragPoint(event as any, floorPlanGroupPoint, floorPlanGroupLine, state.scene, lines, onlyFloorlines)
+ } else {
+ (state.controls as any).enabled = true;
+ }
+ });
+
+ dragPointControls.current.addEventListener('dragstart', function (event) {
+ });
+
+ dragPointControls.current.addEventListener('dragend', async function (event) {
+ if (!dragPointControls.current) return;
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // await updatePoint(
+ // organization,
+ // { "x": event.object.position.x, "y": 0.01, "z": event.object.position.z },
+ // event.object.uuid,
+ // )
+
+ //SOCKET
+
+ const data = {
+ organization: organization,
+ position: { "x": event.object.position.x, "y": 0.01, "z": event.object.position.z },
+ uuid: event.object.uuid,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:update', data);
+
+ if (state.controls) {
+ (state.controls as any).enabled = true;
+ }
+ });
+
+ dragPointControls.current.addEventListener('hoveron', function (event: any) {
+ if ((event.object as Types.Mesh).name === "point") {
+ event.object.material.uniforms.uInnerColor.value.set(event.object.userData.color)
+ }
+ });
+
+ dragPointControls.current.addEventListener('hoveroff', function (event: any) {
+ if ((event.object as Types.Mesh).name === "point") {
+ event.object.material.uniforms.uInnerColor.value.set(new THREE.Color(CONSTANTS.pointConfig.defaultInnerColor))
+ }
+ });
+
+}
\ No newline at end of file
diff --git a/app/src/modules/builder/eventFunctions/handleContextMenu.ts b/app/src/modules/builder/eventFunctions/handleContextMenu.ts
new file mode 100644
index 0000000..fad1e64
--- /dev/null
+++ b/app/src/modules/builder/eventFunctions/handleContextMenu.ts
@@ -0,0 +1,8 @@
+import * as Types from "../../../types/world/worldTypes";
+
+export default function handleContextMenu(
+ menuVisible: Types.Boolean,
+ setMenuVisible: Types.BooleanState
+): void {
+ // setMenuVisible(true)
+}
\ No newline at end of file
diff --git a/app/src/modules/builder/eventFunctions/handleMeshDown.ts b/app/src/modules/builder/eventFunctions/handleMeshDown.ts
new file mode 100644
index 0000000..43806b8
--- /dev/null
+++ b/app/src/modules/builder/eventFunctions/handleMeshDown.ts
@@ -0,0 +1,64 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../types/world/worldTypes";
+
+function handleMeshDown(
+ event: Types.MeshEvent,
+ currentWallItem: Types.RefMesh,
+ setSelectedWallItem: Types.setSelectedWallItemSetState,
+ setSelectedItemsIndex: Types.setSelectedItemsIndexSetState,
+ wallItems: Types.wallItems,
+ toggleView: Types.Boolean
+): void {
+
+ ////////// To select which of the Wall item and CSG is selected to be dragged //////////
+
+ if (!toggleView) {
+ if (currentWallItem.current) {
+ currentWallItem.current.children.forEach((child) => {
+ if ((child as THREE.Mesh).isMesh && child.name !== "CSG_REF") {
+ const material = (child as THREE.Mesh).material;
+ if (Array.isArray(material)) {
+ material.forEach(mat => {
+ if (mat instanceof THREE.MeshStandardMaterial) {
+ mat.emissive = new THREE.Color("black");
+ }
+ });
+ } else if (material instanceof THREE.MeshStandardMaterial) {
+ material.emissive = new THREE.Color("black");
+ }
+ }
+ });
+ currentWallItem.current = null;
+ setSelectedWallItem(null);
+ setSelectedItemsIndex(null);
+ }
+
+ if (event.intersections.length > 0) {
+ const clickedIndex = wallItems.findIndex((item) => item.model === event.intersections[0]?.object?.parent?.parent);
+ if (clickedIndex !== -1) {
+ setSelectedItemsIndex(clickedIndex);
+ const wallItemModel = wallItems[clickedIndex]?.model;
+ if (wallItemModel && wallItemModel.parent && wallItemModel.parent.parent) {
+ currentWallItem.current = (wallItemModel.parent.parent.children[0]?.children[1]?.children[0] as Types.Mesh) || null;
+ setSelectedWallItem(wallItemModel.parent);
+ // currentWallItem.current?.children.forEach((child) => {
+ // if ((child as THREE.Mesh).isMesh && child.name !== "CSG_REF") {
+ // const material = (child as THREE.Mesh).material;
+ // if (Array.isArray(material)) {
+ // material.forEach(mat => {
+ // if (mat instanceof THREE.MeshStandardMaterial) {
+ // mat.emissive = new THREE.Color("green");
+ // }
+ // });
+ // } else if (material instanceof THREE.MeshStandardMaterial) {
+ // material.emissive = new THREE.Color("green");
+ // }
+ // }
+ // });
+ }
+ }
+ }
+ }
+}
+export default handleMeshDown;
diff --git a/app/src/modules/builder/eventFunctions/handleMeshMissed.ts b/app/src/modules/builder/eventFunctions/handleMeshMissed.ts
new file mode 100644
index 0000000..9588a48
--- /dev/null
+++ b/app/src/modules/builder/eventFunctions/handleMeshMissed.ts
@@ -0,0 +1,34 @@
+import * as THREE from 'three';
+import * as Types from "../../../types/world/worldTypes";
+
+function handleMeshMissed(
+ currentWallItem: Types.RefMesh,
+ setSelectedWallItem: Types.setSelectedWallItemSetState,
+ setSelectedItemsIndex: Types.setSelectedItemsIndexSetState
+): void {
+
+ ////////// If an item is selected and then clicked outside other than the selected object, this runs and removes the color of the selected object and sets setSelectedWallItem and setSelectedItemsIndex as null //////////
+
+ if (currentWallItem.current) {
+ currentWallItem.current.children.forEach((child) => {
+ if ((child as THREE.Mesh).isMesh && child.name !== "CSG_REF") {
+ const material = (child as THREE.Mesh).material;
+
+ if (Array.isArray(material)) {
+ material.forEach(mat => {
+ if (mat instanceof THREE.MeshStandardMaterial) {
+ mat.emissive = new THREE.Color("black");
+ }
+ });
+ } else if (material instanceof THREE.MeshStandardMaterial) {
+ material.emissive = new THREE.Color("black");
+ }
+ }
+ });
+ currentWallItem.current = null;
+ setSelectedWallItem(null);
+ setSelectedItemsIndex(null);
+ }
+}
+
+export default handleMeshMissed;
diff --git a/app/src/modules/builder/functions/deletableLineOrPoint.ts b/app/src/modules/builder/functions/deletableLineOrPoint.ts
new file mode 100644
index 0000000..423c581
--- /dev/null
+++ b/app/src/modules/builder/functions/deletableLineOrPoint.ts
@@ -0,0 +1,87 @@
+import * as THREE from 'three';
+import * as CONSTANTS from '../../../types/world/worldConstants';
+import * as Types from "../../../types/world/worldTypes";
+
+function DeletableLineorPoint(
+ state: Types.ThreeState,
+ plane: Types.RefMesh,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroupPoint: Types.RefGroup,
+ hoveredDeletableLine: Types.RefMesh,
+ hoveredDeletablePoint: Types.RefMesh
+): void {
+
+ ////////// Altering the color of the hovered line or point during the deletion time //////////
+
+ if (!plane.current) return;
+ let intersects = state.raycaster.intersectObject(plane.current, true);
+
+ let visibleIntersectLines;
+ if (floorPlanGroupLine.current) { visibleIntersectLines = state.raycaster?.intersectObjects(floorPlanGroupLine.current.children, true); }
+ const visibleIntersectLine = visibleIntersectLines?.find(intersect => intersect.object.visible) as THREE.Line | undefined || null;
+
+ let visibleIntersectPoints;
+ if (floorPlanGroupPoint.current) {
+ visibleIntersectPoints = state.raycaster?.intersectObjects(floorPlanGroupPoint.current.children, true);
+ }
+ const visibleIntersectPoint = visibleIntersectPoints?.find(intersect => intersect.object.visible) as THREE.Mesh | undefined;
+
+ function getLineColor(lineType: string | undefined): string {
+ switch (lineType) {
+ case CONSTANTS.lineConfig.wallName: return CONSTANTS.lineConfig.wallColor;
+ case CONSTANTS.lineConfig.floorName: return CONSTANTS.lineConfig.floorColor;
+ case CONSTANTS.lineConfig.aisleName: return CONSTANTS.lineConfig.aisleColor;
+ default: return CONSTANTS.lineConfig.defaultColor;
+ }
+ }
+
+ if (intersects.length > 0) {
+ if (visibleIntersectPoint) {
+ if (hoveredDeletableLine.current) {
+ const lineType = hoveredDeletableLine.current.userData.linePoints[1]?.[3];
+ const color = getLineColor(lineType);
+ (hoveredDeletableLine.current.material as THREE.MeshBasicMaterial).color = new THREE.Color(color);
+ hoveredDeletableLine.current = null;
+ }
+
+ hoveredDeletablePoint.current = (visibleIntersectPoint as any).object;
+ (hoveredDeletablePoint.current as any).material.uniforms.uInnerColor.value.set(new THREE.Color("red"));
+ (hoveredDeletablePoint.current as any).material.uniforms.uColor.value.set(new THREE.Color("red"));
+ // (hoveredDeletablePoint.current as THREE.Mesh).scale.set(1.5, 1.5, 1.5);
+ } else if (hoveredDeletablePoint.current) {
+ (hoveredDeletablePoint.current as any).material.uniforms.uInnerColor.value.set(CONSTANTS.pointConfig.defaultInnerColor);
+ (hoveredDeletablePoint.current as any).material.uniforms.uColor.value.set((hoveredDeletablePoint.current as any).userData.color);
+ // hoveredDeletablePoint.current.scale.set(1, 1, 1);
+ hoveredDeletablePoint.current = null;
+ }
+
+ if (visibleIntersectLine && !visibleIntersectPoint) {
+ if (hoveredDeletableLine.current) {
+ const lineType = hoveredDeletableLine.current.userData.linePoints[1]?.[3];
+ const color = getLineColor(lineType);
+ (hoveredDeletableLine.current.material as THREE.MeshBasicMaterial).color = new THREE.Color(color);
+ hoveredDeletableLine.current = null;
+ }
+
+ if (hoveredDeletablePoint.current) {
+ (hoveredDeletablePoint.current as any).material.uniforms.uInnerColor.value.set(CONSTANTS.pointConfig.defaultInnerColor);
+ (hoveredDeletablePoint.current as any).material.uniforms.uColor.value.set((hoveredDeletablePoint.current as any).userData.color);
+ // hoveredDeletablePoint.current.scale.set(1, 1, 1);
+ hoveredDeletablePoint.current = null;
+ }
+
+ hoveredDeletableLine.current = (visibleIntersectLine as any).object;
+ if (hoveredDeletableLine.current) {
+ (hoveredDeletableLine.current.material as THREE.MeshBasicMaterial).color = new THREE.Color("red");
+ }
+ } else if (hoveredDeletableLine.current) {
+ const lineType = hoveredDeletableLine.current.userData.linePoints[1]?.[3];
+ const color = getLineColor(lineType);
+ (hoveredDeletableLine.current.material as THREE.MeshBasicMaterial).color = new THREE.Color(color);
+ hoveredDeletableLine.current = null;
+ }
+ }
+
+}
+
+export default DeletableLineorPoint;
diff --git a/app/src/modules/builder/functions/draw.ts b/app/src/modules/builder/functions/draw.ts
new file mode 100644
index 0000000..341c741
--- /dev/null
+++ b/app/src/modules/builder/functions/draw.ts
@@ -0,0 +1,97 @@
+import * as Types from "../../../types/world/worldTypes";
+import * as CONSTANTS from '../../../types/world/worldConstants';
+import createAndMoveReferenceLine from "../geomentries/lines/createAndMoveReferenceLine";
+
+async function Draw(
+ state: Types.ThreeState,
+ plane: Types.RefMesh,
+ cursorPosition: Types.Vector3,
+ floorPlanGroupPoint: Types.RefGroup,
+ floorPlanGroupLine: Types.RefGroup,
+ snappedPoint: Types.RefVector3,
+ isSnapped: Types.RefBoolean,
+ isSnappedUUID: Types.RefString,
+ line: Types.RefLine,
+ lines: Types.RefLines,
+ ispreSnapped: Types.RefBoolean,
+ floorPlanGroup: Types.RefGroup,
+ ReferenceLineMesh: Types.RefMesh,
+ LineCreated: Types.RefBoolean,
+ setRefTextUpdate: Types.NumberIncrementState,
+ Tube: Types.RefTubeGeometry,
+ anglesnappedPoint: Types.RefVector3,
+ isAngleSnapped: Types.RefBoolean,
+ toolMode: Types.String,
+): Promise {
+
+ ////////// Snapping the cursor during the drawing time and also changing the color of the intersected lines //////////
+
+ if (!plane.current) return;
+ const intersects = state.raycaster.intersectObject(plane.current, true);
+
+ if (intersects.length > 0 && (toolMode === "Wall" || toolMode === "Aisle" || toolMode === "Floor")) {
+ const intersectionPoint = intersects[0].point;
+ cursorPosition.copy(intersectionPoint);
+ const snapThreshold = 1;
+
+ if (line.current.length === 0) {
+ for (const point of floorPlanGroupPoint.current.children) {
+ const pointType = point.userData.type;
+
+ const canSnap =
+ ((toolMode === "Wall") && (pointType === CONSTANTS.lineConfig.wallName || pointType === CONSTANTS.lineConfig.floorName)) ||
+ ((toolMode === "Floor") && (pointType === CONSTANTS.lineConfig.wallName || pointType === CONSTANTS.lineConfig.floorName)) ||
+ ((toolMode === "Aisle") && pointType === CONSTANTS.lineConfig.aisleName);;
+
+ if (canSnap && cursorPosition.distanceTo(point.position) < snapThreshold + 0.5 && point.visible) {
+ cursorPosition.copy(point.position);
+ snappedPoint.current = point.position;
+ ispreSnapped.current = true;
+ isSnapped.current = false;
+ isSnappedUUID.current = point.uuid;
+ break;
+ } else {
+ ispreSnapped.current = false;
+ }
+ }
+ } else if (line.current.length > 0 && line.current[0]) {
+ for (const point of floorPlanGroupPoint.current.children) {
+ const pointType = point.userData.type;
+
+ let canSnap =
+ ((toolMode === "Wall") && (pointType === CONSTANTS.lineConfig.wallName || pointType === CONSTANTS.lineConfig.floorName)) ||
+ ((toolMode === "Floor") && (pointType === CONSTANTS.lineConfig.wallName || pointType === CONSTANTS.lineConfig.floorName)) ||
+ ((toolMode === "Aisle") && pointType === CONSTANTS.lineConfig.aisleName);
+
+ if (canSnap && cursorPosition.distanceTo(point.position) < snapThreshold && point.visible) {
+ cursorPosition.copy(point.position);
+ snappedPoint.current = point.position;
+ isSnapped.current = true;
+ ispreSnapped.current = false;
+ isSnappedUUID.current = point.uuid;
+ break;
+ } else {
+ isSnapped.current = false;
+ }
+ }
+
+ createAndMoveReferenceLine(
+ line.current[0][0],
+ cursorPosition,
+ isSnapped,
+ ispreSnapped,
+ line,
+ setRefTextUpdate,
+ floorPlanGroup,
+ ReferenceLineMesh,
+ LineCreated,
+ Tube,
+ anglesnappedPoint,
+ isAngleSnapped
+ );
+ }
+ }
+
+}
+
+export default Draw;
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/aisles/addAilseToScene.ts b/app/src/modules/builder/geomentries/aisles/addAilseToScene.ts
new file mode 100644
index 0000000..9cd74ed
--- /dev/null
+++ b/app/src/modules/builder/geomentries/aisles/addAilseToScene.ts
@@ -0,0 +1,56 @@
+import * as THREE from 'three';
+import * as Types from '../../../../types/world/worldTypes';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+export default async function addAisleToScene(
+ aisle: Types.Line,
+ floorGroupAisle: Types.RefGroup,
+): Promise {
+ if (aisle.length >= 2 && aisle[0] && aisle[1]) {
+ const start: Types.Vector3 = aisle[0][0];
+ const end: Types.Vector3 = aisle[1][0];
+
+ const direction = new THREE.Vector3(
+ end.x - start.x,
+ end.y - start.y,
+ end.z - start.z
+ ).normalize();
+
+ const perp = new THREE.Vector3(-direction.z, 0, direction.x).normalize();
+ const offsetDistance = CONSTANTS.aisleConfig.width;
+
+ const leftStart = new THREE.Vector3().copy(start).addScaledVector(perp, offsetDistance);
+ const rightStart = new THREE.Vector3().copy(start).addScaledVector(perp, -offsetDistance);
+ const leftEnd = new THREE.Vector3().copy(end).addScaledVector(perp, offsetDistance);
+ const rightEnd = new THREE.Vector3().copy(end).addScaledVector(perp, -offsetDistance);
+
+ const stripShape = new THREE.Shape();
+ stripShape.moveTo(leftStart.x, leftStart.z);
+ stripShape.lineTo(leftEnd.x, leftEnd.z);
+ stripShape.lineTo(rightEnd.x, rightEnd.z);
+ stripShape.lineTo(rightStart.x, rightStart.z);
+ stripShape.lineTo(leftStart.x, leftStart.z);
+
+ const extrudeSettings = {
+ depth: CONSTANTS.aisleConfig.height,
+ bevelEnabled: false,
+ };
+
+ const stripGeometry = new THREE.ExtrudeGeometry(stripShape, extrudeSettings);
+ const stripMaterial = new THREE.MeshStandardMaterial({
+ color: CONSTANTS.aisleConfig.defaultColor,
+ polygonOffset: true,
+ polygonOffsetFactor: -1,
+ polygonOffsetUnits: -1,
+ });
+
+ const stripMesh = new THREE.Mesh(stripGeometry, stripMaterial);
+ stripMesh.receiveShadow = true;
+ stripMesh.castShadow = true;
+
+ stripMesh.position.y = (aisle[0][2] - 1) * CONSTANTS.wallConfig.height + 0.01;
+ stripMesh.rotateX(Math.PI / 2);
+
+ floorGroupAisle.current.add(stripMesh);
+ }
+}
diff --git a/app/src/modules/builder/geomentries/aisles/loadAisles.ts b/app/src/modules/builder/geomentries/aisles/loadAisles.ts
new file mode 100644
index 0000000..cceacb8
--- /dev/null
+++ b/app/src/modules/builder/geomentries/aisles/loadAisles.ts
@@ -0,0 +1,19 @@
+import * as Types from '../../../../types/world/worldTypes';
+import addAisleToScene from './addAilseToScene';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+export default async function loadAisles(
+ lines: Types.RefLines,
+ floorGroupAisle: Types.RefGroup
+) {
+ // console.log('lines: ', lines.current[0][0][0]);
+ if (!floorGroupAisle.current) return
+ floorGroupAisle.current.children = [];
+ const aisles = lines.current.filter((line) => line[0][3] && line[1][3] === CONSTANTS.lineConfig.aisleName);
+
+ if (aisles.length > 0) {
+ aisles.forEach((aisle: Types.Line) => {
+ addAisleToScene(aisle, floorGroupAisle)
+ })
+ }
+}
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/assets/addAssetModel.ts b/app/src/modules/builder/geomentries/assets/addAssetModel.ts
new file mode 100644
index 0000000..f211d38
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/addAssetModel.ts
@@ -0,0 +1,186 @@
+import * as THREE from 'three';
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import gsap from 'gsap';
+import { toast } from 'react-toastify';
+import TempLoader from './tempLoader';
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader';
+import * as Types from "../../../../types/world/worldTypes";
+import { retrieveGLTF, storeGLTF } from '../../../../utils/indexDB/idbUtils';
+// import { setFloorItemApi } from '../../../../services/factoryBuilder/assest/floorAsset/setFloorItemApi';
+import { Socket } from 'socket.io-client';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+async function addAssetModel(
+ raycaster: THREE.Raycaster,
+ camera: THREE.Camera,
+ pointer: THREE.Vector2,
+ floorGroup: Types.RefGroup,
+ setFloorItems: Types.setFloorItemSetState,
+ itemsGroup: Types.RefGroup,
+ isTempLoader: Types.RefBoolean,
+ tempLoader: Types.RefMesh,
+ socket: Socket,
+ selectedItem: any,
+ setSelectedItem: any,
+ plane: Types.RefMesh,
+): Promise {
+
+ ////////// Load Floor GLtf's and set the positions, rotation, type etc. in state and store in localstorage //////////
+
+ let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+
+ try {
+ isTempLoader.current = true;
+ const loader = new GLTFLoader();
+ const dracoLoader = new DRACOLoader();
+
+ dracoLoader.setDecoderPath('https://cdn.jsdelivr.net/npm/three@0.160.0/examples/jsm/libs/draco/gltf/');
+ loader.setDRACOLoader(dracoLoader);
+
+ raycaster.setFromCamera(pointer, camera);
+ const floorIntersections = raycaster.intersectObjects(floorGroup.current.children, true);
+ const intersectedFloor = floorIntersections.find(intersect => intersect.object.name.includes("Floor"));
+
+ const planeIntersections = raycaster.intersectObject(plane.current!, true);
+ const intersectedPlane = planeIntersections[0];
+
+ let intersectPoint: THREE.Vector3 | null = null;
+
+ if (intersectedFloor && intersectedPlane) {
+ intersectPoint = intersectedFloor.distance < intersectedPlane.distance ? (new THREE.Vector3(intersectedFloor.point.x, Math.round(intersectedFloor.point.y), intersectedFloor.point.z)) : (new THREE.Vector3(intersectedPlane.point.x, 0, intersectedPlane.point.z));
+ } else if (intersectedFloor) {
+ intersectPoint = new THREE.Vector3(intersectedFloor.point.x, Math.round(intersectedFloor.point.y), intersectedFloor.point.z);
+ } else if (intersectedPlane) {
+ intersectPoint = new THREE.Vector3(intersectedPlane.point.x, 0, intersectedPlane.point.z);
+ }
+
+ if (intersectPoint) {
+ if (intersectPoint.y < 0) {
+ intersectPoint = new THREE.Vector3(intersectPoint.x, 0, intersectPoint.z);
+ }
+ const cachedModel = THREE.Cache.get(selectedItem.id);
+ if (cachedModel) {
+ // console.log(`[Cache] Fetching ${selectedItem.name}`);
+ handleModelLoad(cachedModel, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, socket);
+ return;
+ } else {
+ const cachedModelBlob = await retrieveGLTF(selectedItem.id);
+
+ if (cachedModelBlob) {
+ // console.log(`Added ${selectedItem.name} from indexDB`);
+
+ const blobUrl = URL.createObjectURL(cachedModelBlob);
+ loader.load(blobUrl, (gltf) => {
+ URL.revokeObjectURL(blobUrl);
+ THREE.Cache.remove(blobUrl);
+ THREE.Cache.add(selectedItem.id, gltf);
+ handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, socket);
+ },
+ () => {
+ TempLoader(intersectPoint!, isTempLoader, tempLoader, itemsGroup);
+ });
+ } else {
+ // console.log(`Added ${selectedItem.name} from Backend`);
+
+ loader.load(`${url_Backend_dwinzo}/api/v1/AssetFile/${selectedItem.id}`, async (gltf) => {
+ const modelBlob = await fetch(`${url_Backend_dwinzo}/api/v1/AssetFile/${selectedItem.id}`).then((res) => res.blob());
+ await storeGLTF(selectedItem.id, modelBlob);
+ THREE.Cache.add(selectedItem.id, gltf);
+ await handleModelLoad(gltf, intersectPoint!, selectedItem, itemsGroup, tempLoader, isTempLoader, setFloorItems, socket);
+ },
+ () => {
+ TempLoader(intersectPoint!, isTempLoader, tempLoader, itemsGroup);
+ });
+ }
+ }
+ }
+ } catch (error) {
+ console.error('Error fetching asset model:', error);
+ } finally {
+ setSelectedItem({});
+ }
+}
+
+async function handleModelLoad(
+ gltf: any,
+ intersectPoint: THREE.Vector3,
+ selectedItem: any,
+ itemsGroup: Types.RefGroup,
+ tempLoader: Types.RefMesh,
+ isTempLoader: Types.RefBoolean,
+ setFloorItems: Types.setFloorItemSetState,
+ socket: Socket
+) {
+ const model = gltf.scene.clone();
+ model.userData = { name: selectedItem.name, modelId: selectedItem.id };
+ model.position.set(intersectPoint!.x, 3 + intersectPoint!.y, intersectPoint!.z);
+ model.scale.set(...CONSTANTS.assetConfig.defaultScaleBeforeGsap);
+
+ model.traverse((child: any) => {
+ if (child) {
+ child.castShadow = true;
+ child.receiveShadow = true;
+ }
+ });
+
+ itemsGroup.current.add(model);
+ if (tempLoader.current) {
+ (tempLoader.current.material).dispose();
+ (tempLoader.current.geometry).dispose();
+ itemsGroup.current.remove(tempLoader.current);
+ tempLoader.current = undefined;
+ }
+
+ const newFloorItem: Types.FloorItemType = {
+ modeluuid: model.uuid,
+ modelname: selectedItem.name,
+ modelfileID: selectedItem.id,
+ position: [intersectPoint!.x, intersectPoint!.y, intersectPoint!.z],
+ rotation: { x: model.rotation.x, y: model.rotation.y, z: model.rotation.z, },
+ isLocked: false,
+ isVisible: true
+ };
+
+ setFloorItems((prevItems) => {
+ const updatedItems = [...(prevItems || []), newFloorItem];
+ localStorage.setItem("FloorItems", JSON.stringify(updatedItems));
+ return updatedItems;
+ });
+
+ const email = localStorage.getItem("email");
+ const organization = email ? email.split("@")[1].split(".")[0] : "default";
+
+ //REST
+
+ // await setFloorItemApi(
+ // organization,
+ // newFloorItem.modeluuid,
+ // newFloorItem.modelname,
+ // newFloorItem.position,
+ // { "x": model.rotation.x, "y": model.rotation.y, "z": model.rotation.z },
+ // newFloorItem.modelfileID!,
+ // false,
+ // true,
+ // );
+
+ //SOCKET
+
+ const data = {
+ organization,
+ modeluuid: newFloorItem.modeluuid,
+ modelname: newFloorItem.modelname,
+ modelfileID: newFloorItem.modelfileID,
+ position: newFloorItem.position,
+ rotation: { x: model.rotation.x, y: model.rotation.y, z: model.rotation.z },
+ isLocked: false,
+ isVisible: true,
+ socketId: socket.id,
+ };
+
+ socket.emit("v1:FloorItems:set", data);
+
+ gsap.to(model.position, { y: newFloorItem.position[1], duration: 1.5, ease: "power2.out" });
+ gsap.to(model.scale, { x: 1, y: 1, z: 1, duration: 1.5, ease: "power2.out", onComplete: () => { toast.success("Model Added!"); } });
+}
+
+export default addAssetModel;
diff --git a/app/src/modules/builder/geomentries/assets/assetManager.ts b/app/src/modules/builder/geomentries/assets/assetManager.ts
new file mode 100644
index 0000000..837c4d3
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/assetManager.ts
@@ -0,0 +1,153 @@
+import * as THREE from "three";
+import gsap from "gsap";
+import * as Types from "../../../../types/world/worldTypes";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader";
+import { initializeDB, retrieveGLTF, storeGLTF } from "../../../../utils/indexDB/idbUtils";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import { toast } from 'react-toastify';
+
+let url_Backend_dwinzo = `http://${process.env.REACT_APP_SERVER_MARKETPLACE_URL}`;
+let currentTaskId = 0; // Track the active task
+let activePromises = new Map(); // Map to track task progress
+
+export default async function assetManager(
+ data: any,
+ itemsGroup: Types.RefGroup,
+ loader: GLTFLoader,
+) {
+ const taskId = ++currentTaskId; // Increment taskId for each call
+ activePromises.set(taskId, true); // Mark task as active
+
+ // console.log("Received message from worker:", data);
+
+ if (data.toRemove.length > 0) {
+ data.toRemove.forEach((uuid: string) => {
+ const item = itemsGroup.current.getObjectByProperty("uuid", uuid);
+ if (item) {
+ // Traverse and dispose of resources
+ // item.traverse((child: THREE.Object3D) => {
+ // if (child instanceof THREE.Mesh) {
+ // if (child.geometry) child.geometry.dispose();
+ // if (Array.isArray(child.material)) {
+ // child.material.forEach((material) => {
+ // if (material.map) material.map.dispose();
+ // material.dispose();
+ // });
+ // } else if (child.material) {
+ // if (child.material.map) child.material.map.dispose();
+ // child.material.dispose();
+ // }
+ // }
+ // });
+
+ // Remove the object from the scene
+ itemsGroup.current.remove(item);
+ }
+ });
+ }
+
+ if (data.toAdd.length > 0) {
+ await initializeDB();
+
+ for (const item of data.toAdd) {
+ if (!activePromises.get(taskId)) return; // Stop processing if task is canceled
+
+ await new Promise(async (resolve) => {
+ const modelUrl = `${url_Backend_dwinzo}/api/v1/AssetFile/${item.modelfileID!}`;
+
+ // Check Three.js Cache
+ const cachedModel = THREE.Cache.get(item.modelfileID!);
+ if (cachedModel) {
+ // console.log(`[Cache] Fetching ${item.modelname}`);
+ processLoadedModel(cachedModel.scene.clone(), item, itemsGroup, resolve);
+ return;
+ }
+
+ // Check IndexedDB
+ const indexedDBModel = await retrieveGLTF(item.modelfileID!);
+ if (indexedDBModel) {
+ // console.log(`[IndexedDB] Fetching ${item.modelname}`);
+ const blobUrl = URL.createObjectURL(indexedDBModel);
+ loader.load(
+ blobUrl,
+ (gltf) => {
+ URL.revokeObjectURL(blobUrl);
+ THREE.Cache.remove(blobUrl);
+ THREE.Cache.add(item.modelfileID!, gltf); // Add to cache
+ processLoadedModel(gltf.scene.clone(), item, itemsGroup, resolve);
+ },
+ undefined,
+ (error) => {
+ toast.error(`[IndexedDB] Error loading ${item.modelname}:`);
+ resolve();
+ }
+ );
+ return;
+ }
+
+ // Fetch from Backend
+ // console.log(`[Backend] Fetching ${item.modelname}`);
+ loader.load(
+ modelUrl,
+ async (gltf) => {
+ const modelBlob = await fetch(modelUrl).then((res) => res.blob());
+ await storeGLTF(item.modelfileID!, modelBlob); // Store in IndexedDB
+ THREE.Cache.add(item.modelfileID!, gltf); // Add to cache
+ processLoadedModel(gltf.scene.clone(), item, itemsGroup, resolve);
+ },
+ undefined,
+ (error) => {
+ toast.error(`[Backend] Error loading ${item.modelname}:`);
+ resolve();
+ }
+ );
+ });
+ }
+
+ function processLoadedModel(
+ gltf: any,
+ item: Types.FloorItemType,
+ itemsGroup: Types.RefGroup,
+ resolve: () => void
+ ) {
+ if (!activePromises.get(taskId)) return; // Stop processing if task is canceled
+
+ const existingModel = itemsGroup.current.getObjectByProperty("uuid", item.modeluuid);
+ if (existingModel) {
+ // console.log(`Model ${item.modelname} already exists in the scene.`);
+ resolve();
+ return;
+ }
+
+ const model = gltf;
+ model.uuid = item.modeluuid;
+ model.userData = { name: item.modelname, modelId: item.modelfileID };
+ model.scale.set(...CONSTANTS.assetConfig.defaultScaleBeforeGsap);
+ model.position.set(...item.position);
+ model.rotation.set(item.rotation.x, item.rotation.y, item.rotation.z);
+
+ model.traverse((child: any) => {
+ if (child.isMesh) {
+ // Clone the material to ensure changes are independent
+ // child.material = child.material.clone();
+
+ child.castShadow = true;
+ child.receiveShadow = true;
+ }
+ });
+
+
+ itemsGroup?.current?.add(model);
+
+ gsap.to(model.position, { y: item.position[1], duration: 1.5, ease: "power2.out" });
+ gsap.to(model.scale, { x: 1, y: 1, z: 1, duration: 0.5, ease: "power2.out", onStart: resolve, });
+ }
+ }
+
+ activePromises.delete(taskId); // Mark task as complete
+}
+
+// Cancel ongoing task when new call arrives
+export function cancelOngoingTasks() {
+ activePromises.clear(); // Clear all ongoing tasks
+}
diff --git a/app/src/modules/builder/geomentries/assets/assetVisibility.ts b/app/src/modules/builder/geomentries/assets/assetVisibility.ts
new file mode 100644
index 0000000..e2778f6
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/assetVisibility.ts
@@ -0,0 +1,25 @@
+import * as Types from "../../../../types/world/worldTypes";
+
+let lastUpdateTime = 0;
+
+export default function assetVisibility(
+ itemsGroup: Types.RefGroup,
+ cameraPosition: Types.Vector3,
+ renderDistance: Types.Number,
+ throttleTime = 100
+): void {
+ const now = performance.now();
+ if (now - lastUpdateTime < throttleTime) return;
+ lastUpdateTime = now;
+
+ if (!itemsGroup?.current || !cameraPosition) return;
+
+ itemsGroup.current.children.forEach((child) => {
+ const Distance = cameraPosition.distanceTo(child.position);
+ if (Distance <= renderDistance) {
+ child.visible = true;
+ } else {
+ child.visible = false;
+ }
+ });
+}
diff --git a/app/src/modules/builder/geomentries/assets/deletableHoveredFloorItems.ts b/app/src/modules/builder/geomentries/assets/deletableHoveredFloorItems.ts
new file mode 100644
index 0000000..9af432e
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/deletableHoveredFloorItems.ts
@@ -0,0 +1,43 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function DeletableHoveredFloorItems(
+ state: Types.ThreeState,
+ itemsGroup: Types.RefGroup,
+ hoveredDeletableFloorItem: Types.RefMesh,
+ setDeletableFloorItem: any
+): void {
+
+ ////////// Altering the color of the hovered GLTF item during the Deletion time //////////
+
+ state.raycaster.setFromCamera(state.pointer, state.camera);
+ const intersects = state.raycaster.intersectObjects(itemsGroup.current.children, true);
+
+ if (intersects.length > 0) {
+ if (intersects[0].object.name === "Pole") {
+ return;
+ }
+ if (hoveredDeletableFloorItem.current) {
+ hoveredDeletableFloorItem.current = undefined;
+ setDeletableFloorItem(null);
+ }
+ let currentObject = intersects[0].object;
+
+ while (currentObject) {
+ if (currentObject.name === "Scene") {
+ hoveredDeletableFloorItem.current = currentObject as THREE.Mesh;
+ setDeletableFloorItem(currentObject);
+ break;
+ }
+ currentObject = currentObject.parent as THREE.Object3D;
+ }
+ } else {
+ if (hoveredDeletableFloorItem.current) {
+ hoveredDeletableFloorItem.current = undefined;
+ setDeletableFloorItem(null);
+ }
+ }
+}
+
+export default DeletableHoveredFloorItems;
diff --git a/app/src/modules/builder/geomentries/assets/deleteFloorItems.ts b/app/src/modules/builder/geomentries/assets/deleteFloorItems.ts
new file mode 100644
index 0000000..65d5493
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/deleteFloorItems.ts
@@ -0,0 +1,82 @@
+import { toast } from 'react-toastify';
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+import { getFloorItems } from '../../../../services/factoryBuilder/assest/floorAsset/getFloorItemsApi';
+// import { deleteFloorItem } from '../../../../services/factoryBuilder/assest/floorAsset/deleteFloorItemApi';
+import { Socket } from 'socket.io-client';
+
+async function DeleteFloorItems(
+ itemsGroup: Types.RefGroup,
+ hoveredDeletableFloorItem: Types.RefMesh,
+ setFloorItems: Types.setFloorItemSetState,
+ socket: Socket
+): Promise {
+
+ ////////// Deleting the hovered Floor GLTF from the scene (itemsGroup.current) and from the floorItems and also update it in the localstorage //////////
+
+ if (hoveredDeletableFloorItem.current) {
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ const items = await getFloorItems(organization);
+ const removedItem = items.find(
+ (item: { modeluuid: string }) => item.modeluuid === hoveredDeletableFloorItem.current?.uuid
+ );
+
+ if (!removedItem) {
+ return
+ }
+
+ //REST
+
+ // const response = await deleteFloorItem(organization, removedItem.modeluuid, removedItem.modelname);
+
+ //SOCKET
+
+ const data = {
+ organization: organization,
+ modeluuid: removedItem.modeluuid,
+ modelname: removedItem.modelname,
+ socketId: socket.id
+ }
+
+ const response = socket.emit('v1:FloorItems:delete', data)
+
+ if (response) {
+ const updatedItems = items.filter(
+ (item: { modeluuid: string }) => item.modeluuid !== hoveredDeletableFloorItem.current?.uuid
+ );
+
+ const storedItems = JSON.parse(localStorage.getItem("FloorItems") || '[]');
+ const updatedStoredItems = storedItems.filter((item: { modeluuid: string }) => item.modeluuid !== hoveredDeletableFloorItem.current?.uuid);
+ localStorage.setItem("FloorItems", JSON.stringify(updatedStoredItems));
+
+ if (hoveredDeletableFloorItem.current) {
+ // Traverse and dispose of resources
+ hoveredDeletableFloorItem.current.traverse((child: THREE.Object3D) => {
+ if (child instanceof THREE.Mesh) {
+ if (child.geometry) child.geometry.dispose();
+ if (Array.isArray(child.material)) {
+ child.material.forEach((material) => {
+ if (material.map) material.map.dispose();
+ material.dispose();
+ });
+ } else if (child.material) {
+ if (child.material.map) child.material.map.dispose();
+ child.material.dispose();
+ }
+ }
+ });
+
+ // Remove the object from the scene
+ itemsGroup.current.remove(hoveredDeletableFloorItem.current);
+ }
+ setFloorItems(updatedItems);
+ toast.success("Model Removed!");
+ }
+ }
+}
+
+export default DeleteFloorItems;
diff --git a/app/src/modules/builder/geomentries/assets/tempLoader.ts b/app/src/modules/builder/geomentries/assets/tempLoader.ts
new file mode 100644
index 0000000..601b60a
--- /dev/null
+++ b/app/src/modules/builder/geomentries/assets/tempLoader.ts
@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function TempLoader(
+ intersectPoint: Types.Vector3,
+ isTempLoader: Types.RefBoolean,
+ tempLoader: Types.RefMesh,
+ itemsGroup: Types.RefGroup
+): void {
+
+ ////////// Temporary Loader that indicates the gltf is being loaded //////////
+
+ ////////// Bug: Can't Load More than one TempLoader if done, it won't leave the scene //////////
+
+ if (tempLoader.current) {
+ itemsGroup.current.remove(tempLoader.current);
+ }
+ if (isTempLoader.current) {
+ const cubeGeometry = new THREE.BoxGeometry(1, 1, 1);
+ const cubeMaterial = new THREE.MeshBasicMaterial({ color: "white" });
+ tempLoader.current = new THREE.Mesh(cubeGeometry, cubeMaterial);
+ tempLoader.current.position.set(intersectPoint.x, 0.5 + intersectPoint.y, intersectPoint.z);
+ itemsGroup.current.add(tempLoader.current);
+ isTempLoader.current = false;
+ }
+}
+
+export default TempLoader;
diff --git a/app/src/modules/builder/geomentries/floors/addFloorToScene.ts b/app/src/modules/builder/geomentries/floors/addFloorToScene.ts
new file mode 100644
index 0000000..acf738b
--- /dev/null
+++ b/app/src/modules/builder/geomentries/floors/addFloorToScene.ts
@@ -0,0 +1,64 @@
+import * as THREE from 'three';
+import * as Types from "../../../../types/world/worldTypes";
+import * as CONSTANTS from "../../../../types/world/worldConstants";
+
+import texturePath from "../../../../assets/textures/floor/concreteFloorWorn001Diff2k.jpg";
+import normalPath from "../../../../assets/textures/floor/concreteFloorWorn001NorGl2k.jpg";
+
+// Cache for materials
+const materialCache = new Map();
+
+export default function addFloorToScene(
+ shape: THREE.Shape,
+ layer: number,
+ floorGroup: Types.RefGroup,
+ userData: any,
+) {
+ const textureLoader = new THREE.TextureLoader();
+
+ const textureScale = CONSTANTS.floorConfig.textureScale;
+
+ const materialKey = `floorMaterial_${textureScale}`;
+
+ let material: THREE.Material;
+
+ if (materialCache.has(materialKey)) {
+ material = materialCache.get(materialKey) as THREE.Material;
+ } else {
+ const floorTexture = textureLoader.load(texturePath);
+ const normalMap = textureLoader.load(normalPath);
+
+ floorTexture.wrapS = floorTexture.wrapT = THREE.RepeatWrapping;
+ floorTexture.repeat.set(textureScale, textureScale);
+ floorTexture.colorSpace = THREE.SRGBColorSpace;
+
+ normalMap.wrapS = normalMap.wrapT = THREE.RepeatWrapping;
+ normalMap.repeat.set(textureScale, textureScale);
+
+ material = new THREE.MeshStandardMaterial({
+ map: floorTexture,
+ normalMap: normalMap,
+ side: THREE.DoubleSide,
+ });
+
+ materialCache.set(materialKey, material);
+ }
+
+ const extrudeSettings = {
+ depth: CONSTANTS.floorConfig.height,
+ bevelEnabled: false,
+ };
+
+ const geometry = new THREE.ExtrudeGeometry(shape, extrudeSettings);
+ const mesh = new THREE.Mesh(geometry, material);
+
+ mesh.receiveShadow = true;
+ mesh.position.y = layer;
+ mesh.rotateX(Math.PI / 2);
+ mesh.name = `Floor_Layer_${layer}`;
+
+ // Store UUIDs for debugging or future processing
+ mesh.userData.uuids = userData;
+
+ floorGroup.current.add(mesh);
+}
diff --git a/app/src/modules/builder/geomentries/floors/drawOnlyFloor.ts b/app/src/modules/builder/geomentries/floors/drawOnlyFloor.ts
new file mode 100644
index 0000000..90f291e
--- /dev/null
+++ b/app/src/modules/builder/geomentries/floors/drawOnlyFloor.ts
@@ -0,0 +1,179 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+import addPointToScene from '../points/addPointToScene';
+import addLineToScene from '../lines/addLineToScene';
+import splitLine from '../lines/splitLine';
+import removeReferenceLine from '../lines/removeReferenceLine';
+import getClosestIntersection from '../lines/getClosestIntersection';
+import arrayLineToObject from '../lines/lineConvertions/arrayLineToObject';
+// import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
+import { Socket } from 'socket.io-client';
+
+async function drawOnlyFloor(
+ raycaster: THREE.Raycaster,
+ state: Types.ThreeState,
+ camera: THREE.Camera,
+ plane: Types.RefMesh,
+ floorPlanGroupPoint: Types.RefGroup,
+ snappedPoint: Types.RefVector3,
+ isSnapped: Types.RefBoolean,
+ isSnappedUUID: Types.RefString,
+ line: Types.RefLine,
+ ispreSnapped: Types.RefBoolean,
+ anglesnappedPoint: Types.RefVector3,
+ isAngleSnapped: Types.RefBoolean,
+ onlyFloorline: Types.RefOnlyFloorLine,
+ onlyFloorlines: Types.RefOnlyFloorLines,
+ lines: Types.RefLines,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroup: Types.RefGroup,
+ ReferenceLineMesh: Types.RefMesh,
+ LineCreated: Types.RefBoolean,
+ currentLayerPoint: Types.RefMeshArray,
+ dragPointControls: Types.RefDragControl,
+ setNewLines: any,
+ setDeletedLines: any,
+ activeLayer: Types.Number,
+ socket: Socket
+): Promise {
+
+ ////////// Creating lines Based on the positions clicked //////////
+
+ if (!plane.current) return
+ const intersects = raycaster.intersectObject(plane.current, true);
+ const intersectsLines = raycaster.intersectObjects(floorPlanGroupLine.current.children, true);
+ const intersectsPoint = raycaster.intersectObjects(floorPlanGroupPoint.current.children, true);
+ const VisibleintersectsPoint = intersectsPoint.find(intersect => intersect.object.visible);
+ const visibleIntersect = intersectsLines.find(intersect => intersect.object.visible && intersect.object.name !== CONSTANTS.lineConfig.referenceName);
+
+ if ((intersectsPoint.length === 0 || VisibleintersectsPoint === undefined) && intersectsLines.length > 0 && !isSnapped.current && !ispreSnapped.current) {
+
+ ////////// Clicked on a preexisting Line //////////
+
+ if (visibleIntersect && (intersectsLines[0].object.userData.linePoints[0][3] === CONSTANTS.lineConfig.floorName || intersectsLines[0].object.userData.linePoints[0][3] === CONSTANTS.lineConfig.wallName)) {
+ let pointColor, lineColor;
+ if (intersectsLines[0].object.userData.linePoints[0][3] === CONSTANTS.lineConfig.wallName) {
+ pointColor = CONSTANTS.pointConfig.wallOuterColor;
+ lineColor = CONSTANTS.lineConfig.wallColor;
+ } else {
+ pointColor = CONSTANTS.pointConfig.floorOuterColor;
+ lineColor = CONSTANTS.lineConfig.floorColor;
+ }
+ let IntersectsPoint = new THREE.Vector3(intersects[0].point.x, 0.01, intersects[0].point.z);
+ if (isAngleSnapped.current && line.current.length > 0 && anglesnappedPoint.current) {
+ IntersectsPoint = anglesnappedPoint.current;
+ }
+ if (visibleIntersect.object instanceof THREE.Mesh) {
+ const ThroughPoint = (visibleIntersect.object.geometry.parameters.path).getPoints(CONSTANTS.lineConfig.lineIntersectionPoints);
+ let intersectionPoint = getClosestIntersection(ThroughPoint, IntersectsPoint);
+
+ if (intersectionPoint) {
+
+ const newLines = splitLine(visibleIntersect, intersectionPoint, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lines, setDeletedLines, floorPlanGroupLine, socket, pointColor, lineColor, intersectsLines[0].object.userData.linePoints[0][3]);
+ setNewLines([newLines[0], newLines[1]]);
+
+ (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.floorName]);
+
+ if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+ lines.current.push(line.current as Types.Line);
+ const data = arrayLineToObject(line.current as Types.Line);
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // setLine(organization, data.layer!, data.line!, data.type!);
+
+ //SOCKET
+
+ const input = {
+ organization: organization,
+ layer: data.layer,
+ line: data.line,
+ type: data.type,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:create', input);
+
+ setNewLines([newLines[0], newLines[1], line.current]);
+ onlyFloorline.current.push(line.current as Types.Line);
+ onlyFloorlines.current.push(onlyFloorline.current);
+ onlyFloorline.current = [];
+
+ addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.floorColor, line.current, floorPlanGroupLine);
+
+ removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
+ }
+ return;
+ }
+ }
+ }
+ }
+ if (intersects.length > 0 && intersectsLines.length === 0) {
+
+ ////////// Clicked on an empty place or a point //////////
+
+ let intersectionPoint = intersects[0].point;
+
+ if (isAngleSnapped.current && line.current.length > 0 && anglesnappedPoint.current) {
+ intersectionPoint = anglesnappedPoint.current;
+ }
+ if (isSnapped.current && line.current.length > 0 && snappedPoint.current) {
+ intersectionPoint = snappedPoint.current;
+ }
+ if (ispreSnapped.current && snappedPoint.current) {
+ intersectionPoint = snappedPoint.current;
+ }
+
+ if (!isSnapped.current && !ispreSnapped.current) {
+ addPointToScene(intersectionPoint, CONSTANTS.pointConfig.floorOuterColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, CONSTANTS.lineConfig.floorName);
+ } else {
+ ispreSnapped.current = false;
+ isSnapped.current = false;
+ }
+
+ (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.floorName]);
+
+ if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+ onlyFloorline.current.push(line.current as Types.Line);
+ lines.current.push(line.current as Types.Line);
+ const data = arrayLineToObject(line.current as Types.Line);
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // setLine(organization, data.layer!, data.line!, data.type!);
+
+ //SOCKET
+
+ const input = {
+ organization: organization,
+ layer: data.layer,
+ line: data.line,
+ type: data.type,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:create', input);
+
+ setNewLines([line.current]);
+ addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.floorColor, line.current, floorPlanGroupLine);
+ const lastPoint = line.current[line.current.length - 1];
+ line.current = [lastPoint];
+ }
+ if (isSnapped.current) { ////////// Add this to stop the drawing mode after snapping //////////
+ removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
+ onlyFloorlines.current.push(onlyFloorline.current);
+ onlyFloorline.current = [];
+ }
+ }
+}
+
+export default drawOnlyFloor;
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/floors/loadFloor.ts b/app/src/modules/builder/geomentries/floors/loadFloor.ts
new file mode 100644
index 0000000..30efc62
--- /dev/null
+++ b/app/src/modules/builder/geomentries/floors/loadFloor.ts
@@ -0,0 +1,50 @@
+import * as THREE from 'three';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import addRoofToScene from '../roofs/addRoofToScene';
+
+import * as Types from "../../../../types/world/worldTypes";
+import loadOnlyFloors from './loadOnlyFloors';
+import addFloorToScene from './addFloorToScene';
+import getRoomsFromLines from '../lines/getRoomsFromLines';
+
+async function loadFloor(
+ lines: Types.RefLines,
+ floorGroup: Types.RefGroup,
+): Promise {
+
+ if (!floorGroup.current) return;
+
+ floorGroup.current.children = [];
+
+ if (lines.current.length > 2) {
+ const linesByLayer = lines.current.reduce((acc: { [key: number]: any[] }, pair) => {
+ const layer = pair[0][2];
+ if (!acc[layer]) acc[layer] = [];
+ acc[layer].push(pair);
+ return acc;
+ }, {});
+
+ for (const layer in linesByLayer) {
+ // Only Floor Polygons
+ loadOnlyFloors(floorGroup, linesByLayer, layer);
+
+ const rooms: Types.Rooms = await getRoomsFromLines({ current: linesByLayer[layer] });
+
+ rooms.forEach(({ coordinates: room, layer }) => {
+ const userData = room.map(point => point.uuid);
+ const shape = new THREE.Shape();
+ shape.moveTo(room[0].position.x, room[0].position.z);
+ room.forEach(point => shape.lineTo(point.position.x, point.position.z));
+ shape.closePath();
+
+ // Floor Polygons
+ addFloorToScene(shape, (layer - 1) * CONSTANTS.wallConfig.height, floorGroup, userData);
+
+ // Roof Polygons
+ addRoofToScene(shape, (layer - 1) * CONSTANTS.wallConfig.height, userData, floorGroup);
+ });
+ }
+ }
+}
+
+export default loadFloor;
diff --git a/app/src/modules/builder/geomentries/floors/loadOnlyFloors.ts b/app/src/modules/builder/geomentries/floors/loadOnlyFloors.ts
new file mode 100644
index 0000000..ca438a2
--- /dev/null
+++ b/app/src/modules/builder/geomentries/floors/loadOnlyFloors.ts
@@ -0,0 +1,183 @@
+import * as THREE from 'three';
+import * as turf from '@turf/turf';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+function loadOnlyFloors(
+ floorGroup: Types.RefGroup,
+ linesByLayer: any,
+ layer: any,
+): void {
+
+ ////////// Creating polygon floor based on the onlyFloorlines.current which does not add roof to it, The lines are still stored in Lines.current as well //////////
+
+ let floorsInLayer = linesByLayer[layer];
+ floorsInLayer = floorsInLayer.filter((line: any) => line[0][3] && line[1][3] === CONSTANTS.lineConfig.floorName);
+ const floorResult = floorsInLayer.map((pair: [THREE.Vector3, string, number, string][]) =>
+ pair.map((point) => ({
+ position: [point[0].x, point[0].z],
+ uuid: point[1]
+ }))
+ );
+ const FloorLineFeatures = floorResult.map((line: any) => turf.lineString(line.map((p: any) => p.position)));
+
+ function identifyPolygonsAndConnectedLines(FloorLineFeatures: any) {
+ const floorpolygons = [];
+ const connectedLines = [];
+ const unprocessedLines = [...FloorLineFeatures]; // Copy the features
+
+ while (unprocessedLines.length > 0) {
+ const currentLine = unprocessedLines.pop();
+ const coordinates = currentLine.geometry.coordinates;
+
+ // Check if the line is closed (forms a polygon)
+ if (
+ coordinates[0][0] === coordinates[coordinates.length - 1][0] &&
+ coordinates[0][1] === coordinates[coordinates.length - 1][1]
+ ) {
+ floorpolygons.push(turf.polygon([coordinates])); // Add as a polygon
+ continue;
+ }
+
+ // Check if the line connects to another line
+ let connected = false;
+ for (let i = unprocessedLines.length - 1; i >= 0; i--) {
+ const otherCoordinates = unprocessedLines[i].geometry.coordinates;
+
+ // Check if lines share a start or end point
+ if (
+ coordinates[0][0] === otherCoordinates[otherCoordinates.length - 1][0] &&
+ coordinates[0][1] === otherCoordinates[otherCoordinates.length - 1][1]
+ ) {
+ // Merge lines
+ const mergedCoordinates = [...otherCoordinates, ...coordinates.slice(1)];
+ unprocessedLines[i] = turf.lineString(mergedCoordinates);
+ connected = true;
+ break;
+ } else if (
+ coordinates[coordinates.length - 1][0] === otherCoordinates[0][0] &&
+ coordinates[coordinates.length - 1][1] === otherCoordinates[0][1]
+ ) {
+ // Merge lines
+ const mergedCoordinates = [...coordinates, ...otherCoordinates.slice(1)];
+ unprocessedLines[i] = turf.lineString(mergedCoordinates);
+ connected = true;
+ break;
+ }
+ }
+
+ if (!connected) {
+ connectedLines.push(currentLine); // Add unconnected line as-is
+ }
+ }
+
+ return { floorpolygons, connectedLines };
+ }
+
+ const { floorpolygons, connectedLines } = identifyPolygonsAndConnectedLines(FloorLineFeatures);
+
+ function convertConnectedLinesToPolygons(connectedLines: any) {
+ return connectedLines.map((line: any) => {
+ const coordinates = line.geometry.coordinates;
+
+ // If the line has more than two points, close the polygon
+ if (coordinates.length > 2) {
+ const firstPoint = coordinates[0];
+ const lastPoint = coordinates[coordinates.length - 1];
+
+ // Check if already closed; if not, close it
+ if (firstPoint[0] !== lastPoint[0] || firstPoint[1] !== lastPoint[1]) {
+ coordinates.push(firstPoint);
+ }
+
+ // Convert the closed line into a polygon
+ return turf.polygon([coordinates]);
+ }
+
+ // If not enough points for a polygon, return the line unchanged
+ return line;
+ });
+ }
+
+ const convertedConnectedPolygons = convertConnectedLinesToPolygons(connectedLines);
+
+ if (convertedConnectedPolygons.length > 0) {
+ const validPolygons = convertedConnectedPolygons.filter(
+ (polygon: any) => polygon.geometry?.type === "Polygon"
+ );
+
+ if (validPolygons.length > 0) {
+ floorpolygons.push(...validPolygons);
+ }
+ }
+
+ function convertPolygonsToOriginalFormat(floorpolygons: any, originalLines: [THREE.Vector3, string, number, string][][]) {
+ return floorpolygons.map((polygon: any) => {
+ const coordinates = polygon.geometry.coordinates[0]; // Extract the coordinates array (assume it's a single polygon)
+
+ // Map each coordinate back to its original structure
+ const mappedPoints = coordinates.map((coord: [number, number]) => {
+ const [x, z] = coord;
+
+ // Find the original point matching this coordinate
+ const originalPoint = originalLines.flat().find(([point]) => point.x === x && point.z === z);
+
+ if (!originalPoint) {
+ throw new Error(`Original point for coordinate [${x}, ${z}] not found.`);
+ }
+
+ return originalPoint;
+ });
+
+ // Create pairs of consecutive points
+ const pairs: typeof originalLines = [];
+ for (let i = 0; i < mappedPoints.length - 1; i++) {
+ pairs.push([mappedPoints[i], mappedPoints[i + 1]]);
+ }
+
+ return pairs;
+ });
+ }
+
+ const convertedFloorPolygons: Types.OnlyFloorLines = convertPolygonsToOriginalFormat(floorpolygons, floorsInLayer);
+
+ convertedFloorPolygons.forEach((floor) => {
+ const points: THREE.Vector3[] = [];
+
+ floor.forEach((lineSegment) => {
+ const startPoint = lineSegment[0][0];
+ points.push(new THREE.Vector3(startPoint.x, startPoint.y, startPoint.z));
+ });
+
+ const lastLine = floor[floor.length - 1];
+ const endPoint = lastLine[1][0];
+ points.push(new THREE.Vector3(endPoint.x, endPoint.y, endPoint.z));
+
+ const shape = new THREE.Shape();
+ shape.moveTo(points[0].x, points[0].z);
+
+ points.forEach(point => shape.lineTo(point.x, point.z));
+ shape.closePath();
+
+ const extrudeSettings = {
+ depth: CONSTANTS.floorConfig.height,
+ bevelEnabled: false
+ };
+
+ const geometry = new THREE.ExtrudeGeometry(shape, extrudeSettings);
+ const material = new THREE.MeshStandardMaterial({ color: CONSTANTS.floorConfig.defaultColor, side: THREE.DoubleSide });
+ const mesh = new THREE.Mesh(geometry, material);
+
+ mesh.castShadow = true;
+ mesh.receiveShadow = true;
+
+ mesh.position.y = (floor[0][0][2] - 1) * CONSTANTS.wallConfig.height + 0.03;
+ mesh.rotateX(Math.PI / 2);
+ mesh.name = `Only_Floor_Line_${floor[0][0][2]}`;
+
+ mesh.userData = floor;
+ floorGroup?.current?.add(mesh);
+ });
+}
+
+export default loadOnlyFloors;
diff --git a/app/src/modules/builder/geomentries/floors/updateFloorLines.ts b/app/src/modules/builder/geomentries/floors/updateFloorLines.ts
new file mode 100644
index 0000000..6aa5ce8
--- /dev/null
+++ b/app/src/modules/builder/geomentries/floors/updateFloorLines.ts
@@ -0,0 +1,24 @@
+import * as Types from "../../../../types/world/worldTypes";
+
+function updateFloorLines(
+ onlyFloorlines: Types.RefOnlyFloorLines,
+ DragedPoint: Types.Mesh | { uuid: string, position: Types.Vector3 }
+): void {
+
+ ////////// Update onlyFloorlines.current if it contains the dragged point //////////
+
+ onlyFloorlines.current.forEach((floorline) => {
+ floorline.forEach((line) => {
+ line.forEach((point) => {
+ const [position, uuid] = point;
+ if (uuid === DragedPoint.uuid) {
+ position.x = DragedPoint.position.x;
+ position.y = 0.01;
+ position.z = DragedPoint.position.z;
+ }
+ });
+ });
+ });
+}
+
+export default updateFloorLines;
diff --git a/app/src/modules/builder/geomentries/layers/deleteLayer.ts b/app/src/modules/builder/geomentries/layers/deleteLayer.ts
new file mode 100644
index 0000000..c8a4e8a
--- /dev/null
+++ b/app/src/modules/builder/geomentries/layers/deleteLayer.ts
@@ -0,0 +1,89 @@
+import { toast } from 'react-toastify';
+import RemoveConnectedLines from '../lines/removeConnectedLines';
+
+import * as Types from '../../../../types/world/worldTypes';
+import { Socket } from 'socket.io-client';
+// import { deleteLayer } from '../../../../services/factoryBuilder/lines/deleteLayerApi';
+
+async function DeleteLayer(
+ removedLayer: Types.Number,
+ lines: Types.RefLines,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroupPoint: Types.RefGroup,
+ onlyFloorlines: Types.RefOnlyFloorLines,
+ floorGroup: Types.RefGroup,
+ setDeletedLines: any,
+ setRemovedLayer: Types.setRemoveLayerSetState,
+ socket: Socket
+): Promise {
+
+ ////////// Remove the Lines from the lines.current based on the removed layer and rearrange the layer number that are higher than the removed layer //////////
+
+ const removedLines: Types.Lines = lines.current.filter(line => line[0][2] === removedLayer);
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // await deleteLayer(organization, removedLayer);
+
+ //SOCKET
+
+ const data = {
+ organization: organization,
+ layer: removedLayer,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:delete:layer', data);
+
+ ////////// Remove Points and lines from the removed layer //////////
+
+ removedLines.forEach((line) => {
+ line.forEach((removedPoint) => {
+ RemoveConnectedLines(removedPoint[1], floorPlanGroupLine, floorPlanGroupPoint, setDeletedLines, lines);
+ });
+ });
+
+ ////////// Update the remaining lines layer values in the userData and in lines.current //////////
+
+ let remaining = lines.current.filter(line => line[0][2] !== removedLayer);
+ let updatedLines: Types.Lines = [];
+ remaining.forEach(line => {
+ let newLines: Types.Line = [...line];
+ if (newLines[0][2] > removedLayer) {
+ newLines[0][2] -= 1;
+ newLines[1][2] -= 1;
+ }
+
+ const matchingLine = floorPlanGroupLine.current.children.find(l => l.userData.linePoints[0][1] === line[0][1] && l.userData.linePoints[1][1] === line[1][1]);
+ if (matchingLine) {
+ const updatedUserData = matchingLine.userData;
+ updatedUserData.linePoints[0][2] = newLines[0][2];
+ updatedUserData.linePoints[1][2] = newLines[1][2];
+ }
+ updatedLines.push(newLines);
+ });
+
+ lines.current = updatedLines;
+ localStorage.setItem("Lines", JSON.stringify(lines.current));
+
+ ////////// Also remove OnlyFloorLines and update it in localstorage //////////
+
+ onlyFloorlines.current = onlyFloorlines.current.filter((floor) => {
+ return floor[0][0][2] !== removedLayer;
+ });
+ const meshToRemove: any = floorGroup.current?.children.find((mesh) =>
+ mesh.name === `Only_Floor_Line_${removedLayer}`
+ );
+ if (meshToRemove) {
+ (meshToRemove.material).dispose();
+ (meshToRemove.geometry).dispose();
+ floorGroup.current?.remove(meshToRemove);
+ }
+
+ toast.success("Layer Removed!");
+ setRemovedLayer(null);
+}
+export default DeleteLayer;
diff --git a/app/src/modules/builder/geomentries/layers/layer2DVisibility.ts b/app/src/modules/builder/geomentries/layers/layer2DVisibility.ts
new file mode 100644
index 0000000..3164de9
--- /dev/null
+++ b/app/src/modules/builder/geomentries/layers/layer2DVisibility.ts
@@ -0,0 +1,35 @@
+import * as Types from "../../../../types/world/worldTypes";
+
+function Layer2DVisibility(
+ activeLayer: Types.Number,
+ floorPlanGroup: Types.RefGroup,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroupPoint: Types.RefGroup,
+ currentLayerPoint: Types.RefMeshArray,
+ dragPointControls: Types.RefDragControl
+): void {
+
+ if (floorPlanGroup.current && dragPointControls.current) {
+ currentLayerPoint.current = [];
+ floorPlanGroupLine.current.children.forEach((line) => {
+ const linePoints = line.userData.linePoints;
+
+ const point1 = floorPlanGroupPoint.current.getObjectByProperty('uuid', linePoints[0][1]) as Types.Mesh;
+ const point2 = floorPlanGroupPoint.current.getObjectByProperty('uuid', linePoints[1][1]) as Types.Mesh;
+
+ if (linePoints[0][2] !== activeLayer && linePoints[1][2] !== activeLayer) {
+ point1.visible = false;
+ point2.visible = false;
+ line.visible = false;
+ } else {
+ point1.visible = true;
+ point2.visible = true;
+ line.visible = true;
+ currentLayerPoint.current.push(point1, point2);
+ }
+ });
+ dragPointControls.current!.objects = currentLayerPoint.current;
+ }
+}
+
+export default Layer2DVisibility;
diff --git a/app/src/modules/builder/geomentries/lines/addLineToScene.ts b/app/src/modules/builder/geomentries/lines/addLineToScene.ts
new file mode 100644
index 0000000..79f2a9a
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/addLineToScene.ts
@@ -0,0 +1,24 @@
+import * as THREE from "three";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+function addLineToScene(
+ start: Types.Vector3,
+ end: Types.Vector3,
+ colour: Types.Color,
+ userData: Types.UserData,
+ floorPlanGroupLine: Types.RefGroup
+): void {
+
+ ////////// A function that creates and adds lines based on the start, end, and colour from the params, Also adds the userData in the mesh userData //////////
+
+ const path = new THREE.CatmullRomCurve3([start, end]);
+ const geometry = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+ const material = new THREE.MeshBasicMaterial({ color: colour });
+ const mesh = new THREE.Mesh(geometry, material);
+ floorPlanGroupLine.current.add(mesh);
+
+ mesh.userData.linePoints = userData;
+}
+
+export default addLineToScene;
diff --git a/app/src/modules/builder/geomentries/lines/createAndMoveReferenceLine.ts b/app/src/modules/builder/geomentries/lines/createAndMoveReferenceLine.ts
new file mode 100644
index 0000000..bcb8e75
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/createAndMoveReferenceLine.ts
@@ -0,0 +1,98 @@
+import * as THREE from "three";
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+function createAndMoveReferenceLine(
+ point: Types.Vector3,
+ cursorPosition: Types.Vector3,
+ isSnapped: Types.RefBoolean,
+ ispreSnapped: Types.RefBoolean,
+ line: Types.RefLine,
+ setRefTextUpdate: Types.NumberIncrementState,
+ floorPlanGroup: Types.RefGroup,
+ ReferenceLineMesh: Types.RefMesh,
+ LineCreated: Types.RefBoolean,
+ Tube: Types.RefTubeGeometry,
+ anglesnappedPoint: Types.RefVector3,
+ isAngleSnapped: Types.RefBoolean
+): void {
+
+ ////////// Creating new and maintaining the old reference line and also snap the reference line based on its angle //////////
+
+ const startPoint = point;
+
+ const dx = cursorPosition.x - startPoint.x;
+ const dz = cursorPosition.z - startPoint.z;
+ let angle = Math.atan2(dz, dx);
+
+ angle = (angle * 180) / Math.PI;
+ angle = (angle + 360) % 360;
+
+ const snapAngles = [0, 90, 180, 270, 360];
+ const snapThreshold = 2.5;
+
+ const closestSnapAngle = snapAngles.reduce((prev, curr) =>
+ Math.abs(curr - angle) < Math.abs(prev - angle) ? curr : prev
+ );
+
+ if (!isSnapped.current && !ispreSnapped.current && line.current.length > 0) {
+ if (Math.abs(closestSnapAngle - angle) <= snapThreshold) {
+ const snappedAngleRad = (closestSnapAngle * Math.PI) / 180;
+ const distance = Math.sqrt(dx * dx + dz * dz);
+ const snappedX = startPoint.x + distance * Math.cos(snappedAngleRad);
+ const snappedZ = startPoint.z + distance * Math.sin(snappedAngleRad);
+
+ if (
+ cursorPosition.distanceTo(
+ new THREE.Vector3(snappedX, 0.01, snappedZ)
+ ) < 2
+ ) {
+ cursorPosition.set(snappedX, 0.01, snappedZ);
+ isAngleSnapped.current = true;
+ anglesnappedPoint.current = new THREE.Vector3(
+ snappedX,
+ 0.01,
+ snappedZ
+ );
+ } else {
+ isAngleSnapped.current = false;
+ anglesnappedPoint.current = null;
+ }
+ } else {
+ isAngleSnapped.current = false;
+ anglesnappedPoint.current = null;
+ }
+ } else {
+ isAngleSnapped.current = false;
+ anglesnappedPoint.current = null;
+ }
+
+ if (!LineCreated.current) {
+ setRefTextUpdate((prevUpdate) => prevUpdate - 1);
+ const path = new THREE.LineCurve3(startPoint, cursorPosition);
+ Tube.current = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+ const material = new THREE.MeshBasicMaterial({ color: CONSTANTS.lineConfig.helperColor });
+ ReferenceLineMesh.current = new THREE.Mesh(Tube.current, material);
+ ReferenceLineMesh.current.name = CONSTANTS.lineConfig.referenceName;
+ ReferenceLineMesh.current.userData = {
+ linePoints: { startPoint, cursorPosition },
+ };
+ floorPlanGroup.current?.add(ReferenceLineMesh.current);
+ LineCreated.current = true;
+ } else {
+ if (ReferenceLineMesh.current) {
+ const path = new THREE.LineCurve3(startPoint, new THREE.Vector3(cursorPosition.x, 0.01, cursorPosition.z));
+ Tube.current = new THREE.TubeGeometry(path, CONSTANTS.lineConfig.tubularSegments, CONSTANTS.lineConfig.radius, CONSTANTS.lineConfig.radialSegments, false);
+
+ if (ReferenceLineMesh.current) {
+ ReferenceLineMesh.current.userData = {
+ linePoints: { startPoint, cursorPosition },
+ };
+ ReferenceLineMesh.current.geometry.dispose();
+ ReferenceLineMesh.current.geometry = Tube.current;
+ }
+ }
+ }
+}
+
+export default createAndMoveReferenceLine;
diff --git a/app/src/modules/builder/geomentries/lines/deleteLine.ts b/app/src/modules/builder/geomentries/lines/deleteLine.ts
new file mode 100644
index 0000000..66b78a0
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/deleteLine.ts
@@ -0,0 +1,88 @@
+import { Socket } from "socket.io-client";
+// import { deleteLineApi } from "../../../../services/factoryBuilder/lines/deleteLineApi";
+import * as Types from "../../../../types/world/worldTypes";
+
+import { toast } from 'react-toastify';
+
+function deleteLine(
+ hoveredDeletableLine: Types.RefMesh,
+ onlyFloorlines: Types.RefOnlyFloorLines,
+ lines: Types.RefLines,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroupPoint: Types.RefGroup,
+ setDeletedLines: any,
+ socket: Socket
+): void {
+
+ ////////// Deleting a line and the points if they are not connected to any other line //////////
+
+ if (!hoveredDeletableLine.current) {
+ return;
+ }
+
+ const linePoints = hoveredDeletableLine.current.userData.linePoints;
+ const connectedpoints = [linePoints[0][1], linePoints[1][1]];
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // deleteLineApi(
+ // organization,
+ // [
+ // { "uuid": linePoints[0][1] },
+ // { "uuid": linePoints[1][1] }
+ // ]
+ // )
+
+ //SOCKET
+
+ const data = {
+ organization: organization,
+ line: [
+ { "uuid": linePoints[0][1] },
+ { "uuid": linePoints[1][1] }
+ ],
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:delete', data);
+
+
+ onlyFloorlines.current = onlyFloorlines.current.map(floorline =>
+ floorline.filter(line => line[0][1] !== connectedpoints[0] && line[1][1] !== connectedpoints[1])
+ ).filter(floorline => floorline.length > 0);
+
+ lines.current = lines.current.filter(item => item !== linePoints);
+ (hoveredDeletableLine.current.material).dispose();
+ (hoveredDeletableLine.current.geometry).dispose();
+ floorPlanGroupLine.current.remove(hoveredDeletableLine.current);
+ setDeletedLines([linePoints]);
+
+ connectedpoints.forEach((pointUUID) => {
+ let isConnected = false;
+ floorPlanGroupLine.current.children.forEach((line) => {
+ const linePoints = line.userData.linePoints;
+ const uuid1 = linePoints[0][1];
+ const uuid2 = linePoints[1][1];
+ if (uuid1 === pointUUID || uuid2 === pointUUID) {
+ isConnected = true;
+ }
+ });
+
+ if (!isConnected) {
+ floorPlanGroupPoint.current.children.forEach((point: any) => {
+ if (point.uuid === pointUUID) {
+ (point.material).dispose();
+ (point.geometry).dispose();
+ floorPlanGroupPoint.current.remove(point);
+ }
+ });
+ }
+ });
+
+ toast.success("Line Removed!");
+}
+
+export default deleteLine;
diff --git a/app/src/modules/builder/geomentries/lines/distanceText.tsx b/app/src/modules/builder/geomentries/lines/distanceText.tsx
new file mode 100644
index 0000000..028d835
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/distanceText.tsx
@@ -0,0 +1,90 @@
+import { useEffect, useState } from "react"
+import { getLines } from "../../../../services/factoryBuilder/lines/getLinesApi";
+import * as THREE from "three";
+import { useActiveLayer, useDeletedLines, useNewLines, useToggleView } from "../../../../store/store";
+import objectLinesToArray from "./lineConvertions/objectLinesToArray";
+import { Html } from "@react-three/drei";
+import * as Types from "../../../../types/world/worldTypes";
+
+const DistanceText = () => {
+ const [lines, setLines] = useState<{ distance: string; position: THREE.Vector3; userData: Types.Line; layer: string }[]>([]);
+ const { activeLayer } = useActiveLayer();
+ const { toggleView } = useToggleView();
+ const { newLines, setNewLines } = useNewLines();
+ const { deletedLines, setDeletedLines } = useDeletedLines();
+
+ useEffect(() => {
+ const email = localStorage.getItem('email')
+ if (!email) return;
+ const organization = (email.split("@")[1]).split(".")[0];
+
+ getLines(organization).then((data) => {
+ data = objectLinesToArray(data);
+
+ const lines = data.filter((line: Types.Line) => line[0][2] === activeLayer)
+ .map((line: Types.Line) => {
+ const point1 = new THREE.Vector3(line[0][0].x, line[0][0].y, line[0][0].z);
+ const point2 = new THREE.Vector3(line[1][0].x, line[1][0].y, line[1][0].z);
+ const distance = point1.distanceTo(point2);
+ const midpoint = new THREE.Vector3().addVectors(point1, point2).divideScalar(2);
+ return {
+ distance: distance.toFixed(1),
+ position: midpoint,
+ userData: line,
+ layer: activeLayer,
+ };
+ });
+ setLines(lines)
+ })
+ }, [activeLayer])
+
+ useEffect(() => {
+ if (newLines.length > 0) {
+ if (newLines[0][0][2] !== activeLayer) return;
+ const newLinesData = newLines.map((line: Types.Line) => {
+ const point1 = new THREE.Vector3(line[0][0].x, line[0][0].y, line[0][0].z);
+ const point2 = new THREE.Vector3(line[1][0].x, line[1][0].y, line[1][0].z);
+ const distance = point1.distanceTo(point2);
+ const midpoint = new THREE.Vector3().addVectors(point1, point2).divideScalar(2);
+
+ return {
+ distance: distance.toFixed(1),
+ position: midpoint,
+ userData: line,
+ layer: activeLayer,
+ };
+ });
+ setLines((prevLines) => [...prevLines, ...newLinesData]);
+ setNewLines([]);
+ }
+ }, [newLines, activeLayer]);
+
+
+ useEffect(() => {
+ if ((deletedLines as Types.Lines).length > 0) {
+ setLines((prevLines) =>
+ prevLines.filter(
+ (line) => !deletedLines.some((deletedLine: any) => deletedLine[0][1] === line.userData[0][1] && deletedLine[1][1] === line.userData[1][1])
+ )
+ );
+ setDeletedLines([]);
+ }
+ }, [deletedLines]);
+
+ return (
+ <>
+ {toggleView && (
+
+ {lines.map((text) => (
+
+ {text.distance} m
+
+ ))}
+
+ )}
+
+ )
+
+}
+
+export default DistanceText;
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/lines/drawWall.ts b/app/src/modules/builder/geomentries/lines/drawWall.ts
new file mode 100644
index 0000000..027e2e9
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/drawWall.ts
@@ -0,0 +1,167 @@
+import * as THREE from 'three';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+
+import addPointToScene from '../points/addPointToScene';
+import addLineToScene from './addLineToScene';
+import splitLine from './splitLine';
+import removeReferenceLine from './removeReferenceLine';
+import getClosestIntersection from './getClosestIntersection';
+
+import * as Types from "../../../../types/world/worldTypes";
+import arrayLineToObject from './lineConvertions/arrayLineToObject';
+// import { setLine } from '../../../../services/factoryBuilder/lines/setLineApi';
+import { Socket } from 'socket.io-client';
+
+async function drawWall(
+ raycaster: THREE.Raycaster,
+ plane: Types.RefMesh,
+ floorPlanGroupPoint: Types.RefGroup,
+ snappedPoint: Types.RefVector3,
+ isSnapped: Types.RefBoolean,
+ isSnappedUUID: Types.RefString,
+ line: Types.RefLine,
+ ispreSnapped: Types.RefBoolean,
+ anglesnappedPoint: Types.RefVector3,
+ isAngleSnapped: Types.RefBoolean,
+ lines: Types.RefLines,
+ floorPlanGroupLine: Types.RefGroup,
+ floorPlanGroup: Types.RefGroup,
+ ReferenceLineMesh: Types.RefMesh,
+ LineCreated: Types.RefBoolean,
+ currentLayerPoint: Types.RefMeshArray,
+ dragPointControls: Types.RefDragControl,
+ setNewLines: any,
+ setDeletedLines: any,
+ activeLayer: Types.Number,
+ socket: Socket
+): Promise {
+
+ ////////// Creating lines Based on the positions clicked //////////
+
+ ////////// Allows the user lines that represents walls and roof, floor if forms a polygon //////////
+
+
+ if (!plane.current) return
+ let intersects = raycaster.intersectObject(plane.current, true);
+
+ let intersectsLines = raycaster.intersectObjects(floorPlanGroupLine.current.children, true);
+ let intersectsPoint = raycaster.intersectObjects(floorPlanGroupPoint.current.children, true);
+
+ const VisibleintersectsPoint = intersectsPoint.find(intersect => intersect.object.visible);
+ const visibleIntersect = intersectsLines.find(intersect => intersect.object.visible && intersect.object.name !== CONSTANTS.lineConfig.referenceName && intersect.object.userData.linePoints[0][3] === CONSTANTS.lineConfig.wallName);
+
+ if ((intersectsPoint.length === 0 || VisibleintersectsPoint === undefined) && intersectsLines.length > 0 && !isSnapped.current && !ispreSnapped.current) {
+
+ ////////// Clicked on a preexisting Line //////////
+
+ if (visibleIntersect && intersects) {
+ let IntersectsPoint = new THREE.Vector3(intersects[0].point.x, 0.01, intersects[0].point.z);
+
+ if (isAngleSnapped.current && anglesnappedPoint.current) {
+ IntersectsPoint = anglesnappedPoint.current;
+ }
+ if (visibleIntersect.object instanceof THREE.Mesh) {
+ const ThroughPoint = (visibleIntersect.object.geometry.parameters.path).getPoints(CONSTANTS.lineConfig.lineIntersectionPoints);
+ let intersectionPoint = getClosestIntersection(ThroughPoint, IntersectsPoint);
+
+ if (intersectionPoint) {
+
+ const newLines = splitLine(visibleIntersect, intersectionPoint, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, lines, setDeletedLines, floorPlanGroupLine, socket, CONSTANTS.pointConfig.wallOuterColor, CONSTANTS.lineConfig.wallColor, CONSTANTS.lineConfig.wallName);
+ setNewLines([newLines[0], newLines[1]]);
+
+ (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
+
+ if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+ const data = arrayLineToObject(line.current as Types.Line);
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // setLine(organization, data.layer!, data.line!, data.type!);
+
+ //SOCKET
+
+ const input = {
+ organization: organization,
+ layer: data.layer,
+ line: data.line,
+ type: data.type,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:create', input);
+
+ setNewLines([newLines[0], newLines[1], line.current]);
+ lines.current.push(line.current as Types.Line);
+ addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
+ let lastPoint = line.current[line.current.length - 1];
+ line.current = [lastPoint];
+ }
+ return;
+ }
+ }
+ }
+ }
+
+ if (intersects && intersects.length > 0) {
+
+ ////////// Clicked on a emply place or a point //////////
+
+ let intersectionPoint = intersects[0].point;
+
+ if (isAngleSnapped.current && line.current.length > 0 && anglesnappedPoint.current) {
+ intersectionPoint = anglesnappedPoint.current;
+ }
+ if (isSnapped.current && line.current.length > 0 && snappedPoint.current) {
+ intersectionPoint = snappedPoint.current;
+ }
+ if (ispreSnapped.current && snappedPoint.current) {
+ intersectionPoint = snappedPoint.current;
+ }
+
+ if (!isSnapped.current && !ispreSnapped.current) {
+ addPointToScene(intersectionPoint, CONSTANTS.pointConfig.wallOuterColor, currentLayerPoint, floorPlanGroupPoint, dragPointControls, isSnappedUUID, CONSTANTS.lineConfig.wallName);
+ } else {
+ ispreSnapped.current = false;
+ isSnapped.current = false;
+ }
+
+ (line.current as Types.Line).push([new THREE.Vector3(intersectionPoint.x, 0.01, intersectionPoint.z), isSnappedUUID.current!, activeLayer, CONSTANTS.lineConfig.wallName,]);
+
+ if (line.current.length >= 2 && line.current[0] && line.current[1]) {
+ const data = arrayLineToObject(line.current as Types.Line);
+
+ const email = localStorage.getItem('email')
+ const organization = (email!.split("@")[1]).split(".")[0];
+
+ //REST
+
+ // setLine(organization, data.layer!, data.line!, data.type!);
+
+ //SOCKET
+
+ const input = {
+ organization: organization,
+ layer: data.layer,
+ line: data.line,
+ type: data.type,
+ socketId: socket.id
+ }
+
+ socket.emit('v1:Line:create', input);
+
+ setNewLines([line.current])
+ lines.current.push(line.current as Types.Line);
+ addLineToScene(line.current[0][0], line.current[1][0], CONSTANTS.lineConfig.wallColor, line.current, floorPlanGroupLine);
+ let lastPoint = line.current[line.current.length - 1];
+ line.current = [lastPoint];
+ }
+ if (isSnapped.current) {
+ removeReferenceLine(floorPlanGroup, ReferenceLineMesh, LineCreated, line);
+ }
+ }
+}
+
+export default drawWall;
diff --git a/app/src/modules/builder/geomentries/lines/getClosestIntersection.ts b/app/src/modules/builder/geomentries/lines/getClosestIntersection.ts
new file mode 100644
index 0000000..41d4ecf
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/getClosestIntersection.ts
@@ -0,0 +1,26 @@
+import * as THREE from 'three';
+
+import * as Types from "../../../../types/world/worldTypes";
+
+function getClosestIntersection(
+ intersects: Types.Vector3Array,
+ point: Types.Vector3
+): Types.Vector3 | null {
+
+ ////////// A function that finds which point is closest from the intersects points that is given, Used in finding which point in a line is closest when clicked on a line during drawing //////////
+
+ let closestNewPoint: THREE.Vector3 | null = null;
+ let minDistance = Infinity;
+
+ for (const intersect of intersects) {
+ const distance = point.distanceTo(intersect);
+ if (distance < minDistance) {
+ minDistance = distance;
+ closestNewPoint = intersect;
+ }
+ }
+
+ return closestNewPoint;
+}
+
+export default getClosestIntersection;
diff --git a/app/src/modules/builder/geomentries/lines/getRoomsFromLines.ts b/app/src/modules/builder/geomentries/lines/getRoomsFromLines.ts
new file mode 100644
index 0000000..d521252
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/getRoomsFromLines.ts
@@ -0,0 +1,86 @@
+import * as THREE from 'three';
+import * as turf from '@turf/turf';
+import * as CONSTANTS from '../../../../types/world/worldConstants';
+import * as Types from "../../../../types/world/worldTypes";
+
+async function getRoomsFromLines(lines: Types.RefLines) {
+ const rooms: Types.Rooms = [];
+
+ if (lines.current.length > 2) {
+ const linesByLayer = lines.current.reduce((acc: { [key: number]: any[] }, pair) => {
+ const layer = pair[0][2];
+ if (!acc[layer]) acc[layer] = [];
+ acc[layer].push(pair);
+ return acc;
+ }, {});
+
+ ////////// Use turf.polygonize to create polygons from the line points //////////
+
+ for (const layer in linesByLayer) {
+
+ let linesInLayer = linesByLayer[layer];
+ linesInLayer = linesInLayer.filter(line => line[0][3] && line[1][3] === CONSTANTS.lineConfig.wallName);
+ const result = linesInLayer.map((pair: [THREE.Vector3, string, number, string][]) =>
+ pair.map((point) => ({
+ position: [point[0].x, point[0].z],
+ uuid: point[1]
+ }))
+ );
+ const lineFeatures = result.map(line => turf.lineString(line.map(p => p.position)));
+ const polygons = turf.polygonize(turf.featureCollection(lineFeatures));
+
+ let union: any[] = [];
+
+ polygons.features.forEach((feature) => {
+ union.push(feature);
+ });
+
+ if (union.length > 1) {
+ const unionResult = turf.union(turf.featureCollection(union));
+ if (unionResult?.geometry.type === "MultiPolygon") {
+ unionResult?.geometry.coordinates.forEach((poly) => {
+ const Coordinates = poly[0].map(([x, z]) => {
+ const matchingPoint = result.flat().find(r =>
+ r.position[0].toFixed(10) === x.toFixed(10) &&
+ r.position[1].toFixed(10) === z.toFixed(10)
+ );
+ return {
+ position: new THREE.Vector3(x, 0, z),
+ uuid: matchingPoint ? matchingPoint.uuid : ''
+ };
+ });
+ rooms.push({ coordinates: Coordinates.reverse(), layer: parseInt(layer) });
+ });
+ } else if (unionResult?.geometry.type === "Polygon") {
+ const Coordinates = unionResult?.geometry.coordinates[0].map(([x, z]) => {
+ const matchingPoint = result.flat().find(r =>
+ r.position[0].toFixed(10) === x.toFixed(10) &&
+ r.position[1].toFixed(10) === z.toFixed(10)
+ );
+ return {
+ position: new THREE.Vector3(x, 0, z),
+ uuid: matchingPoint ? matchingPoint.uuid : ''
+ };
+ });
+ rooms.push({ coordinates: Coordinates.reverse(), layer: parseInt(layer) });
+ }
+ } else if (union.length === 1) {
+ const Coordinates = union[0].geometry.coordinates[0].map(([x, z]: [number, number]) => {
+ const matchingPoint = result.flat().find(r =>
+ r.position[0].toFixed(10) === x.toFixed(10) &&
+ r.position[1].toFixed(10) === z.toFixed(10)
+ );
+ return {
+ position: new THREE.Vector3(x, 0, z),
+ uuid: matchingPoint ? matchingPoint.uuid : ''
+ };
+ });
+ rooms.push({ coordinates: Coordinates, layer: parseInt(layer) });
+ }
+ }
+ }
+
+ return rooms;
+}
+
+export default getRoomsFromLines;
diff --git a/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLineToObject.ts b/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLineToObject.ts
new file mode 100644
index 0000000..d38b18a
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLineToObject.ts
@@ -0,0 +1,24 @@
+import * as Types from "../../../../../types/world/worldTypes";
+
+export default function arrayLineToObject(array: Types.Line) {
+ if (!Array.isArray(array)) {
+ return {};
+ }
+
+ // Extract common properties from the first point
+ const commonLayer = array[0][2];
+ const commonType = array[0][3];
+
+ // Map points into a structured format
+ const line = array.map(([position, uuid]) => ({
+ position,
+ uuid,
+ }));
+
+ // Create the final structured object
+ return {
+ layer: commonLayer,
+ type: commonType,
+ line,
+ };
+}
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLinesToObject.ts b/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLinesToObject.ts
new file mode 100644
index 0000000..e41cf4c
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/lineConvertions/arrayLinesToObject.ts
@@ -0,0 +1,30 @@
+import * as Types from "../../../../../types/world/worldTypes";
+
+export default function arrayLinesToObject(array: Array) {
+ if (!Array.isArray(array)) {
+ return [];
+ }
+
+ return array.map((lineArray) => {
+ if (!Array.isArray(lineArray)) {
+ return null;
+ }
+
+ // Extract common properties from the first point
+ const commonLayer = lineArray[0][2];
+ const commonType = lineArray[0][3];
+
+ // Map points into a structured format
+ const line = lineArray.map(([position, uuid]) => ({
+ position,
+ uuid,
+ }));
+
+ // Create the final structured object
+ return {
+ layer: commonLayer,
+ type: commonType,
+ line,
+ };
+ }).filter((item) => item !== null); // Filter out invalid entries
+}
diff --git a/app/src/modules/builder/geomentries/lines/lineConvertions/objectLineToArray.ts b/app/src/modules/builder/geomentries/lines/lineConvertions/objectLineToArray.ts
new file mode 100644
index 0000000..a6ee7ea
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/lineConvertions/objectLineToArray.ts
@@ -0,0 +1,13 @@
+import * as THREE from 'three';
+
+export default function objectLineToArray(structuredObject: any) {
+ if (!structuredObject || !structuredObject.line) {
+ return [];
+ }
+
+ // Destructure common properties
+ const { layer, type, line } = structuredObject;
+
+ // Map points back to the original array format
+ return line.map(({ position, uuid }: any) => [new THREE.Vector3(position.x, position.y, position.z), uuid, layer, type]);
+}
\ No newline at end of file
diff --git a/app/src/modules/builder/geomentries/lines/lineConvertions/objectLinesToArray.ts b/app/src/modules/builder/geomentries/lines/lineConvertions/objectLinesToArray.ts
new file mode 100644
index 0000000..7f84195
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/lineConvertions/objectLinesToArray.ts
@@ -0,0 +1,20 @@
+import * as THREE from 'three';
+
+export default function objectLinesToArray(structuredObjects: any): any {
+ if (!Array.isArray(structuredObjects)) {
+ return [];
+ }
+
+ return structuredObjects.map((structuredObject) => {
+ if (!structuredObject || !structuredObject.line) {
+ return [];
+ }
+
+ const { layer, type, line } = structuredObject;
+
+ return line.map(({ position, uuid }: any) => {
+ const vector = new THREE.Vector3(position.x, position.y, position.z);
+ return [vector, uuid, layer, type];
+ });
+ });
+}
diff --git a/app/src/modules/builder/geomentries/lines/referenceDistanceText.tsx b/app/src/modules/builder/geomentries/lines/referenceDistanceText.tsx
new file mode 100644
index 0000000..b1ea8db
--- /dev/null
+++ b/app/src/modules/builder/geomentries/lines/referenceDistanceText.tsx
@@ -0,0 +1,48 @@
+import * as THREE from 'three';
+import { Html } from '@react-three/drei';
+import { useState, useEffect } from 'react';
+import { useActiveLayer } from '../../../../store/store';
+
+const ReferenceDistanceText = ({ line }: { line: any }) => {
+ interface TextState {
+ distance: string;
+ position: THREE.Vector3;
+ userData: any;
+ layer: any;
+ }
+
+ const [text, setTexts] = useState(null);
+ const { activeLayer } = useActiveLayer();
+
+ useEffect(() => {
+ if (line) {
+ if (line.parent === null) {
+ setTexts(null);
+ return;
+ }
+ const distance = line.userData.linePoints.cursorPosition.distanceTo(line.userData.linePoints.startPoint);
+ const midpoint = new THREE.Vector3().addVectors(line.userData.linePoints.cursorPosition, line.userData.linePoints.startPoint).divideScalar(2);
+ const newTexts = {
+ distance: distance.toFixed(1),
+ position: midpoint,
+ userData: line,
+ layer: activeLayer
+ };
+ setTexts(newTexts);
+ }
+ });
+
+ return (
+
+
+ {text !== null &&
+ < Html transform sprite key={text.distance} userData={text.userData} scale={5} position={[text.position.x, 1, text.position.z]} style={{ pointerEvents: 'none' }}>
+ {text.distance} m
+