kitchen-simulator
Version:
It is a kitchen simulator (self-contained micro-frontend).
1,088 lines (1,074 loc) • 55 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var _typeof = require("@babel/runtime/helpers/typeof");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _immutable = require("immutable");
var _export = require("./export");
var _export2 = require("../utils/export");
var Three = _interopRequireWildcard(require("three"));
var _constants = require("../constants");
var _helper = require("../utils/helper");
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
var timeGlobal = 0;
var TimeRecorder = /*#__PURE__*/function () {
function TimeRecorder(name) {
(0, _classCallCheck2["default"])(this, TimeRecorder);
this.name = name;
if (name === 'beginDrawingLine') {
console.log('time__ Start Drawing');
}
}
return (0, _createClass2["default"])(TimeRecorder, [{
key: "start",
value: function start() {
this.first = Date.now();
}
}, {
key: "end",
value: function end() {
this.second = Date.now();
var elapsed = this.second - this.first;
console.log('time__ ', this.name, ' : ', elapsed, 'ms');
if (['beginDrawingLine', 'updateDrawingLine', 'endDrawingLine'].includes(this.name)) timeGlobal += elapsed;
if (this.name === 'endDrawingLine') {
console.log('time__ Drawing Ended. Passed Time : ', timeGlobal, 'ms');
timeGlobal = 0;
}
}
}]);
}();
var Line = exports["default"] = /*#__PURE__*/function () {
function Line() {
(0, _classCallCheck2["default"])(this, Line);
}
return (0, _createClass2["default"])(Line, null, [{
key: "create",
value: function create(state, layerID, type, x0, y0, x1, y1, properties) {
var lineCreatedDateTime = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : new Date().getTime();
// if end drawing by created area
// if (state.mode == MODE_IDLE) {
// return { updatedState: state };
// }
// ///////////////
var lineID = _export2.IDBroker.acquireID();
var _Vertex$add = _export.Vertex.add(state, layerID, x0, y0, 'lines', lineID),
stateV0 = _Vertex$add.updatedState,
v0 = _Vertex$add.vertex;
var _Vertex$add2 = _export.Vertex.add(stateV0, layerID, x1, y1, 'lines', lineID),
stateV1 = _Vertex$add2.updatedState,
v1 = _Vertex$add2.vertex;
state = stateV1;
var line = state.catalog.factoryElement(type, {
id: lineID,
name: _export2.NameGenerator.generateName('lines', state.catalog.getIn(['elements', type, 'info', 'title'])),
vertices: new _immutable.List([v0.id, v1.id]),
type: type
}, properties);
line = line.set('createdDateTime', lineCreatedDateTime !== undefined ? lineCreatedDateTime : new Date().getTime());
state = state.setIn(['scene', 'layers', layerID, 'lines', lineID], line);
// set default texture//
var defaultTexture = {
textureA: 'plaster',
textureB: 'plaster'
};
state = this.setJsProperties(state, layerID, lineID, defaultTexture).updatedState;
// /////////////////////
return {
updatedState: state,
line: line
};
}
}, {
key: "select",
value: function select(state, layerID, lineID) {
var _line$toJS, _line$vertices, _line$vertices$get, _line$vertices2, _line$vertices2$get;
// Try selecting the layer first
var layerResult = _export.Layer.select(state, layerID);
if (!layerResult || !layerResult.updatedState) {
return {
updatedState: state
}; // no update if layer not found
}
state = layerResult.updatedState;
// Try getting the line
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if (!line || (0, _helper.isEmpty)((_line$toJS = line.toJS) === null || _line$toJS === void 0 ? void 0 : _line$toJS.call(line))) {
return {
updatedState: state
}; // no update if line not found
}
// Select the line element
var lineSelectResult = _export.Layer.selectElement(state, layerID, 'lines', lineID);
if (lineSelectResult !== null && lineSelectResult !== void 0 && lineSelectResult.updatedState) {
state = lineSelectResult.updatedState;
}
// Select the first vertex (if available)
var firstVertex = (_line$vertices = line.vertices) === null || _line$vertices === void 0 || (_line$vertices$get = _line$vertices.get) === null || _line$vertices$get === void 0 ? void 0 : _line$vertices$get.call(_line$vertices, 0);
if (firstVertex !== undefined) {
var v1Result = _export.Layer.selectElement(state, layerID, 'vertices', firstVertex);
if (v1Result !== null && v1Result !== void 0 && v1Result.updatedState) {
state = v1Result.updatedState;
}
}
// Select the second vertex (if available)
var secondVertex = (_line$vertices2 = line.vertices) === null || _line$vertices2 === void 0 || (_line$vertices2$get = _line$vertices2.get) === null || _line$vertices2$get === void 0 ? void 0 : _line$vertices2$get.call(_line$vertices2, 1);
if (secondVertex !== undefined) {
var v2Result = _export.Layer.selectElement(state, layerID, 'vertices', secondVertex);
if (v2Result !== null && v2Result !== void 0 && v2Result.updatedState) {
state = v2Result.updatedState;
}
}
return {
updatedState: state
};
}
}, {
key: "remove",
value: function remove(state, layerID, lineID) {
var _line$toJS2;
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if (line && !(0, _helper.isEmpty)((_line$toJS2 = line.toJS) === null || _line$toJS2 === void 0 ? void 0 : _line$toJS2.call(line))) {
state = this.unselect(state, layerID, lineID).updatedState;
line.holes.forEach(function (holeID) {
return state = _export.Hole.remove(state, layerID, holeID).updatedState;
});
state = _export.Layer.removeElement(state, layerID, 'lines', lineID).updatedState;
line.vertices.forEach(function (vertexID) {
return state = _export.Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
});
state.getIn(['scene', 'groups']).forEach(function (group) {
return state = _export.Group.removeElement(state, group.id, layerID, 'lines', lineID).updatedState;
});
}
return {
updatedState: state
};
}
}, {
key: "setRelatedLine",
value: function setRelatedLine(state, layerID, lineID, intersection) {
var curIntersection = state.getIn(['scene', 'layers', layerID, 'lines', lineID, 'relatedVertices']);
if (curIntersection == undefined) return {
updatedState: state
};
var isEqualIntersection = function isEqualIntersection(a, b) {
return a.index == b.index && a.point.x == b.point.x && a.point.y == b.point.y;
};
var equal = curIntersection.size == intersection.length && curIntersection.every(function (curint, index) {
return isEqualIntersection(curint, intersection[index]);
});
if (!equal) state = state.mergeIn(['scene', 'layers', layerID, 'lines', lineID, 'relatedVertices'], intersection);
return {
updatedState: state
};
}
}, {
key: "unselect",
value: function unselect(state, layerID, lineID) {
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if (line) {
state = _export.Layer.unselect(state, layerID, 'vertices', line.vertices.get(0)).updatedState;
state = _export.Layer.unselect(state, layerID, 'vertices', line.vertices.get(1)).updatedState;
state = _export.Layer.unselect(state, layerID, 'lines', lineID).updatedState;
}
return {
updatedState: state
};
}
}, {
key: "split",
value: function split(state, layerID, lineID, x, y) {
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
var v0 = state.getIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0)]);
var v1 = state.getIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1)]);
var x0 = v0.x,
y0 = v0.y;
var x1 = v1.x,
y1 = v1.y;
var _Line$create = Line.create(state, layerID, line.type, x0, y0, x, y, line.get('properties'), line.createdDateTime !== undefined ? line.createdDateTime - 2 : new Date().getTime()),
stateL1 = _Line$create.updatedState,
line0 = _Line$create.line;
var _Line$create2 = Line.create(stateL1, layerID, line.type, x1, y1, x, y, line.get('properties'), line.createdDateTime !== undefined ? line.createdDateTime - 1 : new Date().getTime()),
stateL2 = _Line$create2.updatedState,
line1 = _Line$create2.line;
state = stateL2;
var splitPointOffset = _export2.GeometryUtils.pointPositionOnLineSegment(x0, y0, x1, y1, x, y);
var minVertex = _export2.GeometryUtils.minVertex(v0, v1);
line.holes.forEach(function (holeID) {
var hole = state.getIn(['scene', 'layers', layerID, 'holes', holeID]);
var holeOffset = hole.offset;
if (minVertex.x === x1 && minVertex.y === y1) {
splitPointOffset = 1 - splitPointOffset;
holeOffset = 1 - hole.offset;
}
if (holeOffset < splitPointOffset) {
var offset = holeOffset / splitPointOffset;
/*
if (minVertex.x === x1 && minVertex.y === y1) {
offset = 1 - offset;
}
*/
state = _export.Hole.create(state, layerID, hole.type, line0.id, offset, hole.properties).updatedState;
} else {
var _offset = (holeOffset - splitPointOffset) / (1 - splitPointOffset);
/*
if (minVertex.x === x1 && minVertex.y === y1) {
offset = 1 - offset;
}
*/
state = _export.Hole.create(state, layerID, hole.type, line1.id, _offset, hole.properties).updatedState;
}
});
//add splitted lines to the original line's group
var lineGroups = state.getIn(['scene', 'groups']).filter(function (group) {
var lines = group.getIn(['elements', layerID, 'lines']);
return lines && lines.contains(lineID);
});
lineGroups.forEach(function (group) {
state = _export.Group.addElement(state, group.id, layerID, 'lines', line0.id).updatedState;
state = _export.Group.addElement(state, group.id, layerID, 'lines', line1.id).updatedState;
});
state = Line.remove(state, layerID, lineID).updatedState;
return {
updatedState: state,
lines: new _immutable.List([line0, line1])
};
}
}, {
key: "addFromPoints",
value: function addFromPoints(state, layerID, type, points, properties, holes) {
var _this = this;
var lineCreatedDateTime = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : new Date().getTime();
points = new _immutable.List(points).sort(function (_ref, _ref2) {
var x1 = _ref.x,
y1 = _ref.y;
var x2 = _ref2.x,
y2 = _ref2.y;
return x1 === x2 ? y1 - y2 : x1 - x2;
});
var pointsPair = points.zip(points.skip(1)).filterNot(function (_ref3) {
var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
_ref4$ = _ref4[0],
x1 = _ref4$.x,
y1 = _ref4$.y,
_ref4$2 = _ref4[1],
x2 = _ref4$2.x,
y2 = _ref4$2.y;
return x1 === x2 && y1 === y2;
});
var lines = [];
pointsPair.forEach(function (_ref5) {
var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
_ref6$ = _ref6[0],
x1 = _ref6$.x,
y1 = _ref6$.y,
_ref6$2 = _ref6[1],
x2 = _ref6$2.x,
y2 = _ref6$2.y;
var _this$create = _this.create(state, layerID, type, x1, y1, x2, y2, properties, lineCreatedDateTime),
stateL = _this$create.updatedState,
line = _this$create.line;
state = stateL;
var lineLength = _export2.GeometryUtils.pointsDistance(x1, y1, x2, y2);
var alpha = _export2.GeometryUtils.absAngleBetweenTwoPoints(x1, y1, x2, y2);
var cosAlpha = _export2.GeometryUtils.cosWithThreshold(Math.abs(alpha), 0.0000001);
var sinAlpha = _export2.GeometryUtils.sinWithThreshold(Math.abs(alpha), 0.0000001);
if (holes) {
holes.forEach(function (holeWithOffsetPoint) {
var offset = holeWithOffsetPoint.hole.toJS().offset;
// if (invert) offset = 1 - offset;
var _holeWithOffsetPoint$ = holeWithOffsetPoint.offsetPosition,
xp = _holeWithOffsetPoint$.x,
yp = _holeWithOffsetPoint$.y;
if (_export2.GeometryUtils.isPointOnLineSegment(x1, y1, x2, y2, xp, yp)) {
var newOffset = _export2.GeometryUtils.pointPositionOnLineSegment(x1, y1, x2, y2, xp, yp);
if (newOffset >= 0 && newOffset <= 1) {
//add the position of hole
var temp = _export.Hole.create(state, layerID, holeWithOffsetPoint.hole.type, line.id, newOffset, holeWithOffsetPoint.hole.properties, xp, yp);
state = temp.updatedState;
var holeX = 0,
holeY = 0,
holeID = temp.hole.id;
if (_export2.GeometryUtils.almostEqual(y1, y2)) {
if (x1 > x2) {
holeX = x1 - lineLength * newOffset;
holeY = y1;
} else {
holeX = x1 + lineLength * newOffset;
holeY = y1;
}
} else if (_export2.GeometryUtils.almostEqual(x1, x2)) {
if (y1 > y2) {
holeX = x1;
holeY = y1 - lineLength * newOffset;
} else {
holeX = x1;
holeY = y1 + lineLength * newOffset;
}
} else if (x1 > x2) {
if (y1 > y2) {
holeX = x1 - lineLength * newOffset * cosAlpha;
holeY = y1 - lineLength * newOffset * sinAlpha;
} else if (y1 < y2) {
holeX = x1 - lineLength * newOffset * cosAlpha;
holeY = y1 + lineLength * newOffset * sinAlpha;
}
} else if (x1 < x2) {
if (y1 > y2) {
holeX = x1 + lineLength * newOffset * cosAlpha;
holeY = y1 - lineLength * newOffset * sinAlpha;
} else if (y1 < y2) {
holeX = x1 + lineLength * newOffset * cosAlpha;
holeY = y1 + lineLength * newOffset * sinAlpha;
}
}
state = state.setIn(['scene', 'layers', layerID, 'holes', holeID, 'x'], holeX);
state = state.setIn(['scene', 'layers', layerID, 'holes', holeID, 'y'], holeY);
}
}
});
}
lines.push(line);
});
return {
updatedState: state,
lines: new _immutable.List(lines),
newline: lines[0]
};
}
}, {
key: "createAvoidingIntersections",
value: function createAvoidingIntersections(state, layerID, type, x0, y0, x1, y1, oldProperties, oldHoles) {
var _this2 = this;
var lineCreatedDateTime = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : new Date().getTime();
var points = [{
x: x0,
y: y0
}, {
x: x1,
y: y1
}];
state = state.getIn(['scene', 'layers', layerID, 'lines']).reduce(function (reducedState, line) {
var _line$vertices$map$to = line.vertices.map(function (vertexID) {
return reducedState.getIn(['scene', 'layers', layerID, 'vertices']).get(vertexID);
}).toArray(),
_line$vertices$map$to2 = (0, _slicedToArray2["default"])(_line$vertices$map$to, 2),
v0 = _line$vertices$map$to2[0],
v1 = _line$vertices$map$to2[1];
var hasCommonEndpoint = _export2.GeometryUtils.samePoints(v0, points[0]) || _export2.GeometryUtils.samePoints(v0, points[1]) || _export2.GeometryUtils.samePoints(v1, points[0]) || _export2.GeometryUtils.samePoints(v1, points[1]);
var intersection = _export2.GeometryUtils.twoLineSegmentsIntersection(points[0], points[1], v0, v1);
if (intersection.type === 'colinear') {
if (!oldHoles) {
oldHoles = [];
}
var orderedVertices = _export2.GeometryUtils.orderVertices(points);
reducedState.getIn(['scene', 'layers', layerID, 'lines', line.id, 'holes']).forEach(function (holeID) {
var hole = reducedState.getIn(['scene', 'layers', layerID, 'holes', holeID]);
var oldLineLength = _export2.GeometryUtils.pointsDistance(v0.x, v0.y, v1.x, v1.y);
var offset = _export2.GeometryUtils.samePoints(orderedVertices[1], line.vertices.get(1)) ? 1 - hole.offset : hole.offset;
var offsetPosition = _export2.GeometryUtils.extendLine(v0.x, v0.y, v1.x, v1.y, oldLineLength * offset);
oldHoles.push({
hole: hole,
offsetPosition: offsetPosition
});
});
reducedState = _this2.remove(reducedState, layerID, line.id).updatedState;
points.push(v0, v1);
}
if (intersection.type === 'intersecting' && !hasCommonEndpoint) {
reducedState = _this2.split(reducedState, layerID, line.id, intersection.point.x, intersection.point.y).updatedState;
points.push(intersection.point);
}
return reducedState;
}, state);
var _Line$addFromPoints = Line.addFromPoints(state, layerID, type, points, oldProperties, oldHoles, lineCreatedDateTime),
updatedState = _Line$addFromPoints.updatedState,
lines = _Line$addFromPoints.lines,
newline = _Line$addFromPoints.newline;
return {
updatedState: updatedState,
lines: lines,
newline: newline
};
}
}, {
key: "replaceVertex",
value: function replaceVertex(state, layerID, lineID, vertexIndex, x, y) {
var vertexID = state.getIn(['scene', 'layers', layerID, 'lines', lineID, 'vertices', vertexIndex]);
state = _export.Vertex.remove(state, layerID, vertexID, 'lines', lineID).updatedState;
var _Vertex$add3 = _export.Vertex.add(state, layerID, x, y, 'lines', lineID),
stateV = _Vertex$add3.updatedState,
vertex = _Vertex$add3.vertex;
state = stateV;
state = state.setIn(['scene', 'layers', layerID, 'lines', lineID, 'vertices', vertexIndex], vertex.id);
state = state.setIn(['scene', 'layers', layerID, 'lines', lineID], state.getIn(['scene', 'layers', layerID, 'lines', lineID]));
return {
updatedState: state,
line: state.getIn(['scene', 'layers', layerID, 'lines', lineID]),
vertex: vertex
};
}
}, {
key: "selectToolDrawingLine",
value: function selectToolDrawingLine(state, sceneComponentType) {
state = state.merge({
mode: _constants.MODE_WAITING_DRAWING_LINE,
drawingSupport: new _immutable.Map({
type: sceneComponentType
})
});
return {
updatedState: state
};
}
}, {
key: "beginDrawingLine",
value: function beginDrawingLine(state, layerID, x, y) {
// if end drawing by created area
if (state.mode == _constants.MODE_IDLE) {
return {
updatedState: state
};
}
// ///////////////
var snapElements = _export2.SnapSceneUtils.sceneSnapElements(state.scene, new _immutable.List(), state.snapMask);
var snap = null;
if (state.snapMask && !state.snapMask.isEmpty()) {
snap = _export2.SnapUtils.nearestSnap(snapElements, x, y, state.snapMask);
if (snap) {
var _snap$point = snap.point;
x = _snap$point.x;
y = _snap$point.y;
}
snapElements = snapElements.withMutations(function (snapElements) {
var a, b, c;
var _GeometryUtils$horizo = _export2.GeometryUtils.horizontalLine(y);
a = _GeometryUtils$horizo.a;
b = _GeometryUtils$horizo.b;
c = _GeometryUtils$horizo.c;
_export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
var _GeometryUtils$vertic = _export2.GeometryUtils.verticalLine(x);
a = _GeometryUtils$vertic.a;
b = _GeometryUtils$vertic.b;
c = _GeometryUtils$vertic.c;
_export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
var _GeometryUtils$upcros = _export2.GeometryUtils.upcrossLine(x, y);
a = _GeometryUtils$upcros.a;
b = _GeometryUtils$upcros.b;
c = _GeometryUtils$upcros.c;
_export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
var _GeometryUtils$downcr = _export2.GeometryUtils.downcrossLine(x, y);
a = _GeometryUtils$downcr.a;
b = _GeometryUtils$downcr.b;
c = _GeometryUtils$downcr.c;
_export2.SnapUtils.addLineSnap(snapElements, a, b, c, 10, 3, null);
});
}
var drawingSupport = state.get('drawingSupport').set('layerID', layerID);
state = _export.Layer.unselectAll(state, layerID).updatedState;
var _Line$create3 = Line.create(state, layerID, drawingSupport.get('type'), x, y, x, y),
stateL = _Line$create3.updatedState,
line = _Line$create3.line;
state = Line.select(stateL, layerID, line.id).updatedState;
state = state.merge({
mode: _constants.MODE_DRAWING_LINE,
snapElements: snapElements,
activeSnapElement: snap ? snap.snap : null,
drawingSupport: drawingSupport
});
return {
updatedState: state
};
}
}, {
key: "updateDrawingLine",
value: function updateDrawingLine(state, x, y, relatedLines) {
var snap = null;
if (state.snapMask && !state.snapMask.isEmpty()) {
snap = _export2.SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
if (snap) {
var _snap$point2 = snap.point;
x = _snap$point2.x;
y = _snap$point2.y;
}
}
var layerID = state.getIn(['drawingSupport', 'layerID']);
var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
// let relatedLines = [];
var vertices = state.getIn(['scene', 'layers', layerID, 'vertices']).toJS();
var drawingLine = state.getIn(['scene', 'layers', layerID, 'lines', lineID]).toJS();
var moveFlag = true;
var tx = vertices[drawingLine.vertices[1]].x;
var ty = vertices[drawingLine.vertices[1]].y;
if (!(0, _helper.isEmpty)(relatedLines)) {
vertices[drawingLine.vertices[1]].x = x;
vertices[drawingLine.vertices[1]].y = y;
}
var absAngle, lineAngle;
// get the angle of two lines and check the angle
if (drawingLine.vertices[0] !== drawingLine.vertices[1]) {
if (!(0, _helper.isEmpty)(relatedLines)) {
relatedLines.forEach(function (line) {
// get the points of two lines(drawing line and related line)
if (!(0, _helper.isEmpty)(line)) {
// the angle between two lines(line, drawingLine)
lineAngle = _export2.GeometryUtils.angleBetweenTwoLines(line, drawingLine, vertices);
// check whether the angle is less than or bigger than specific value.
absAngle = Math.abs(lineAngle);
if (absAngle < _constants.MIN_ANGLE_DISALLOW_DRAW_WALL || absAngle > 360 - _constants.MIN_ANGLE_DISALLOW_DRAW_WALL) {
moveFlag = false;
} else moveFlag = true;
}
});
} else {
var px = vertices[drawingLine.vertices[0]].x;
var py = vertices[drawingLine.vertices[0]].y;
lineAngle = _export2.GeometryUtils.angleBetweenTwoPointsAndOrigin(px, py, x, y);
absAngle = Math.abs(lineAngle);
}
}
// if the angle is bigger or less than specific value, the wall mustn't be drawn at new position
if (moveFlag) {
tx = x;
ty = y;
} else {
var rest = _constants.MIN_ANGLE_DISALLOW_DRAW_WALL - absAngle;
// the origin point of rotation(snapping)
var ox = vertices[drawingLine.vertices[0]].x;
var oy = vertices[drawingLine.vertices[0]].y;
// determine the direction of rotation.
rest = lineAngle > 0 ? -rest : rest;
// rotate the current point to last point around the first point of drawing line.
var res = _export2.GeometryUtils.rotatePointAroundPoint(x, y, ox, oy, rest);
tx = res.x;
ty = res.y;
}
// angle snapping as a value of UNIT_ANGLE
if (moveFlag && !(0, _helper.isEmpty)(absAngle) && absAngle % _constants.UNIT_ANGLE !== 0) {
var result = _export2.GeometryUtils.snapAngleByUnit(lineAngle, vertices, drawingLine, tx, ty, drawingLine.vertices[1]);
tx = result.x;
ty = result.y;
}
var _Line$replaceVertex = Line.replaceVertex(state, layerID, lineID, 1, tx, ty),
stateLV = _Line$replaceVertex.updatedState,
vertex = _Line$replaceVertex.vertex;
state = stateLV;
state = this.select(state, layerID, lineID).updatedState;
state = state.merge({
activeSnapElement: snap ? snap.snap : null
});
state = state.setIn(['scene', 'setLineAttributes'], false);
return {
updatedState: state
};
}
}, {
key: "stopDrawingLine",
value: function stopDrawingLine(state) {
console.log('line aCtion');
}
// Recalculate the hole position
}, {
key: "getHolePosition",
value: function getHolePosition(layer, lineID, nv0, nv1) {
var _layer$lines$get;
var holeOffset = [];
(_layer$lines$get = layer.lines.get(lineID)) === null || _layer$lines$get === void 0 || _layer$lines$get.holes.forEach(function (holeID) {
var lineLength = _export2.GeometryUtils.pointsDistance(nv0.x, nv0.y, nv1.x, nv1.y);
var minV = _export2.GeometryUtils.minVertex(nv0, nv1);
var maxV = _export2.GeometryUtils.maxVertex(nv0, nv1);
var alpha = Math.atan2(maxV.y - minV.y, maxV.x - minV.x);
var hole = layer.holes.get(holeID);
var pointOnLine = lineLength * hole.offset;
// Calculate the hole position
var offsetPosition = {
x: pointOnLine * Math.cos(alpha) + minV.x,
y: pointOnLine * Math.sin(alpha) + minV.y
};
holeOffset.push({
hole: hole,
offsetPosition: offsetPosition
});
});
return holeOffset;
}
/**
*
* @param {state} state
* @param {selectedLineInfo} selectedLineInfo
* @param {layerID} layerID
* @returns selectedLineInfo {
* mergelines: [line1, line2,...], // lines that will be merged
* points: [stpoint, edpoint] // start and end point of new line that merged.
* }
*/
}, {
key: "mergeAllLines",
value: function mergeAllLines(state, selectedLineInfo, layerID) {
var _this3 = this;
var layer = state.getIn(['scene', 'layers', layerID]);
var allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']);
selectedLineInfo.points.forEach(function (tvertex, index) {
var _tvertex$toJS, _vertex$lines;
var vertex = tvertex === null || tvertex === void 0 || (_tvertex$toJS = tvertex.toJS) === null || _tvertex$toJS === void 0 ? void 0 : _tvertex$toJS.call(tvertex);
if (vertex && !(0, _helper.isEmpty)(vertex) && ((_vertex$lines = vertex.lines) === null || _vertex$lines === void 0 ? void 0 : _vertex$lines.length) === 2) {
var relatedLineID = vertex.lines.filter(function (lineID) {
return !selectedLineInfo.mergelines.some(function (mgline) {
return mgline.id === lineID;
});
});
if (!(0, _helper.isEmpty)(relatedLineID)) {
var relatedLine = layer.lines.get(relatedLineID[0]);
if (!(0, _helper.isEmpty)(relatedLine)) {
var intersectionPoint = vertex;
var startPoint, endPoint;
var tstPoint = allVertices.get(relatedLine.vertices.get(0)).toJS();
var tedPoint = allVertices.get(relatedLine.vertices.get(1)).toJS();
if (!(0, _helper.isEmpty)(tstPoint) && !(0, _helper.isEmpty)(tedPoint)) {
if (relatedLine.vertices.get(0) === intersectionPoint.id) {
endPoint = allVertices.get(relatedLine.vertices.get(1));
startPoint = selectedLineInfo.points[1 - index];
} else {
startPoint = allVertices.get(relatedLine.vertices.get(0));
endPoint = selectedLineInfo.points[1 - index];
}
var tline1 = {
vertices: [startPoint.id, intersectionPoint.id]
};
var tline2 = {
vertices: [intersectionPoint.id, endPoint.id]
};
var angle = Math.abs(_export2.GeometryUtils.angleBetweenTwoLines(tline1, tline2, allVertices.toJS()));
if (Math.abs(angle - 180) <= _constants.EPSILON) {
selectedLineInfo.mergelines.push(relatedLine);
selectedLineInfo.points[0] = startPoint;
selectedLineInfo.points[1] = endPoint;
return _this3.mergeAllLines(state, selectedLineInfo, layerID);
}
}
}
}
}
});
return selectedLineInfo;
}
}, {
key: "mergeLines",
value: function mergeLines(state) {
var layerID = state.getIn(['scene', 'selectedLayer']);
var allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']);
var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if ((0, _helper.isEmpty)(line)) {
return null;
}
var tmpStPoint = allVertices.get(line.vertices.get(0));
var tmpEdPoint = allVertices.get(line.vertices.get(1));
var selectedLineInfo = {
mergelines: [line],
points: [tmpStPoint, tmpEdPoint]
};
var mergeInfo = this.mergeAllLines(state, selectedLineInfo, layerID);
return mergeInfo;
}
/**
*
* @param {mode} mode
* @param {state} state
* @returns updatedState
*/
}, {
key: "createLines",
value: function createLines(state, actionType, mergeInfo) {
var _this4 = this,
_ret2;
if ((0, _helper.isEmpty)(mergeInfo)) {
return {
updatedState: state
};
}
var layerID = state.getIn(['scene', 'selectedLayer']);
var layer = state.getIn(['scene', 'layers', layerID]);
var lineGroups = [];
var holesWithOffsetPosition = [];
var lineID = layer.getIn(['selected', 'lines']).first(); // lines : [id]
var line = layer.getIn(['lines', lineID]);
if ((0, _helper.isEmpty)(line)) {
return {
updatedState: state
};
}
mergeInfo.mergelines.forEach(function (line) {
var _nv0$toJS, _nv1$toJS;
if ([_constants.END_DRAGGING_LINE, _constants.END_DRAGGING_VERTEX].includes(actionType)) {
var tmpGroups = state //get groups membership if present
.getIn(['scene', 'groups']).filter(function (group) {
var lines = group.getIn(['elements', layerID, 'lines']);
return lines && lines.contains(line.id);
});
tmpGroups.forEach(function (group) {
return lineGroups.push(group);
});
}
var nv0 = layer.getIn(['vertices', line.vertices.get(0)]);
var nv1 = layer.getIn(['vertices', line.vertices.get(1)]);
if (!(0, _helper.isEmpty)(nv0 === null || nv0 === void 0 || (_nv0$toJS = nv0.toJS) === null || _nv0$toJS === void 0 ? void 0 : _nv0$toJS.call(nv0)) && !(0, _helper.isEmpty)(nv1 === null || nv1 === void 0 || (_nv1$toJS = nv1.toJS) === null || _nv1$toJS === void 0 ? void 0 : _nv1$toJS.call(nv1))) {
var tmpholeposition = _this4.getHolePosition(layer, line.id, nv0, nv1);
tmpholeposition.forEach(function (holeInfo) {
return holesWithOffsetPosition.push(holeInfo);
});
}
state = Line.remove(state, layerID, line.id).updatedState;
});
var ret;
if (!_export2.GeometryUtils.samePoints(mergeInfo.points[0], mergeInfo.points[1])) {
ret = Line.createAvoidingIntersections(state, layerID, line.type, mergeInfo.points[0].x, mergeInfo.points[0].y, mergeInfo.points[1].x, mergeInfo.points[1].y, line.properties, holesWithOffsetPosition, line.createdDateTime);
state = ret.updatedState;
}
if ([_constants.END_DRAGGING_LINE, _constants.END_DRAGGING_VERTEX].includes(actionType)) {
var _ret;
//re-add to old line's groups if present
(_ret = ret) === null || _ret === void 0 || _ret.lines.forEach(function (addedLine) {
lineGroups.forEach(function (oldLineGroup) {
state = _export.Group.addElement(state, oldLineGroup.id, layerID, 'lines', addedLine.id).updatedState;
});
});
}
state = _export.Layer.removeZeroLengthLines(state, layerID).updatedState;
if (!(0, _helper.isEmpty)((_ret2 = ret) === null || _ret2 === void 0 ? void 0 : _ret2.newline)) {
var _ret3;
state = this.select(state, layerID, (_ret3 = ret) === null || _ret3 === void 0 ? void 0 : _ret3.newline.get('id')).updatedState;
}
return {
updatedState: state
};
}
}, {
key: "updateArea",
value: function updateArea(state) {
var layerID = state.getIn(['scene', 'selectedLayer']);
var layer = state.getIn(['scene', 'layers', layerID]);
var lineID = layer.getIn(['selected', 'lines']).first(); // lines : [id]
var line = layer.getIn(['lines', lineID]);
var drawingInfo = {};
if (!(0, _helper.isEmpty)(line)) {
drawingInfo.drawingLine = line;
}
state = _export.Layer.detectAndUpdateAreas(state, layerID, drawingInfo).updatedState;
return {
updatedState: state
};
}
}, {
key: "applyWallChanges",
value: function applyWallChanges(state, actionType) {
var mergeInfo = this.mergeLines(state); // merge lines
state = this.createLines(state, actionType, mergeInfo).updatedState; // creating lines
state = this.updateArea(state).updatedState; // detecting areas
return {
updatedState: state
};
}
}, {
key: "prepareApplyWallChanges",
value: function prepareApplyWallChanges(v0, v1, state) {
var oldMode = state.getIn(['mode']);
var layerID = state.getIn(['scene', 'selectedLayer']);
var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
var line = state.getIn(['scene', 'layers', layerID, 'lines', lineID]);
if ((0, _helper.isEmpty)(line)) {
return {
updatedState: state
};
}
var tv0 = state.getIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0)]).toJS();
var tv1 = state.getIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1)]).toJS();
if (!(0, _helper.isEmpty)(v0) && !(0, _helper.isEmpty)(tv0)) {
state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0), 'x'], v0.x);
state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(0), 'y'], v0.y);
}
if (!(0, _helper.isEmpty)(v1) && !(0, _helper.isEmpty)(tv1)) {
state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1), 'x'], v1.x);
state = state.setIn(['scene', 'layers', layerID, 'vertices', line.vertices.get(1), 'y'], v1.y);
}
state = this.select(state, layerID, lineID).updatedState;
state = state.setIn(['mode'], oldMode);
return {
updatedState: state
};
}
}, {
key: "endDrawingLine",
value: function endDrawingLine(state, x, y) {
if (state.snapMask && !state.snapMask.isEmpty()) {
var snap = _export2.SnapUtils.nearestSnap(state.snapElements, x, y, state.snapMask);
if (snap) {
var _snap$point3 = snap.point;
x = _snap$point3.x;
y = _snap$point3.y;
}
}
var layerID = state.getIn(['drawingSupport', 'layerID']);
var lineID = state.getIn(['scene', 'layers', layerID, 'selected', 'lines']).first();
var drawingLine = state.getIn(['scene', 'layers', layerID, 'lines', lineID]).toJS();
if ((0, _helper.isEmpty)(drawingLine)) {
return {
updatedState: state
};
}
if (drawingLine.vertices[0] === drawingLine.vertices[1]) {
state = Line.remove(state, layerID, lineID).updatedState;
state = state.merge({
mode: _constants.MODE_IDLE,
snapElements: new _immutable.List(),
activeSnapElement: null
});
return {
updatedState: state
};
}
state = this.prepareApplyWallChanges({}, {
x: x,
y: y
}, state).updatedState;
state = this.applyWallChanges(state, _constants.END_DRAWING_LINE).updatedState;
state = state.merge({
mode: _constants.MODE_WAITING_DRAWING_LINE,
snapElements: new _immutable.List(),
activeSnapElement: null
});
return {
updatedState: state
};
}
}, {
key: "beginDraggingLine",
value: function beginDraggingLine(state, layerID, lineID, x, y) {
var snapElements = _export2.SnapSceneUtils.sceneSnapElements(state.scene, new _immutable.List(), state.snapMask);
var layer = state.scene.layers.get(layerID);
var line = layer.lines.get(lineID);
var vertex0 = layer.vertices.get(line.vertices.get(0));
var vertex1 = layer.vertices.get(line.vertices.get(1));
state = state.merge({
mode: _constants.MODE_DRAGGING_LINE,
snapElements: snapElements,
draggingSupport: (0, _immutable.Map)({
layerID: layerID,
lineID: lineID,
startPointX: x,
startPointY: y,
startVertex0X: vertex0.x,
startVertex0Y: vertex0.y,
startVertex1X: vertex1.x,
startVertex1Y: vertex1.y
})
});
return {
updatedState: state
};
}
}, {
key: "getNewDraggedPoints",
value: function getNewDraggedPoints(newPoints, allVertices, draggingLine, relatedLines) {
if (!newPoints || !allVertices || !draggingLine || !Array.isArray(relatedLines)) {
return newPoints; // Invalid input, just return
}
var draggingVertices = Array.isArray(draggingLine.vertices) ? draggingLine.vertices : [];
var mvFlag = [];
relatedLines.forEach(function (relLine) {
if (!relLine || !Array.isArray(relLine.vertices)) return;
relLine.vertices.forEach(function (vertexId, i) {
var _newPoints$newVertex, _newPoints$newVertex2, _newPoints$newVertex3, _newPoints$newVertex4, _vData$x, _vData$y, _newPoints$newVertex5, _newPoints$newVertex6, _newPoints$newVertex7, _newPoints$newVertex8;
if (draggingVertices.includes(vertexId)) return; // skip shared vertices
var vData = allVertices[vertexId];
if (!vData) return; // guard: vertex missing
var center = i === 0 ? new Three.Vector2((_newPoints$newVertex = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex0X) !== null && _newPoints$newVertex !== void 0 ? _newPoints$newVertex : 0, (_newPoints$newVertex2 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex0Y) !== null && _newPoints$newVertex2 !== void 0 ? _newPoints$newVertex2 : 0) : new Three.Vector2((_newPoints$newVertex3 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex1X) !== null && _newPoints$newVertex3 !== void 0 ? _newPoints$newVertex3 : 0, (_newPoints$newVertex4 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex1Y) !== null && _newPoints$newVertex4 !== void 0 ? _newPoints$newVertex4 : 0);
var pos1 = new Three.Vector2((_vData$x = vData.x) !== null && _vData$x !== void 0 ? _vData$x : 0, (_vData$y = vData.y) !== null && _vData$y !== void 0 ? _vData$y : 0);
var pos2 = i === 0 ? new Three.Vector2((_newPoints$newVertex5 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex1X) !== null && _newPoints$newVertex5 !== void 0 ? _newPoints$newVertex5 : 0, (_newPoints$newVertex6 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex1Y) !== null && _newPoints$newVertex6 !== void 0 ? _newPoints$newVertex6 : 0) : new Three.Vector2((_newPoints$newVertex7 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex0X) !== null && _newPoints$newVertex7 !== void 0 ? _newPoints$newVertex7 : 0, (_newPoints$newVertex8 = newPoints === null || newPoints === void 0 ? void 0 : newPoints.newVertex0Y) !== null && _newPoints$newVertex8 !== void 0 ? _newPoints$newVertex8 : 0);
var cen = center.clone();
var vec1 = pos1.clone().sub(cen).normalize();
var vec2 = pos2.clone().sub(cen).normalize();
var angle = Math.floor(vec1.angle() * 180 / Math.PI - vec2.angle() * 180 / Math.PI + 0.5);
if (Math.abs(angle) < _constants.MIN_ANGLE_DISALLOW_DRAW_WALL || Math.abs(angle) > 360 - _constants.MIN_ANGLE_DISALLOW_DRAW_WALL) {
mvFlag.push(false);
} else {
mvFlag.push(true);
}
});
});
// If any flag is false, revert newPoints to original dragging line positions
if (mvFlag.includes(false) && draggingVertices.length >= 2) {
var v0 = allVertices[draggingVertices[0]];
var v1 = allVertices[draggingVertices[1]];
if (v0 && v1) {
newPoints.newVertex0X = v0.x;
newPoints.newVertex0Y = v0.y;
newPoints.newVertex1X = v1.x;
newPoints.newVertex1Y = v1.y;
}
}
return newPoints;
}
}, {
key: "updateDraggingLine",
value: function updateDraggingLine(state, x, y, relatedLines) {
var draggingSupport = state.draggingSupport;
var snapElements = state.snapElements;
var layerID = draggingSupport.get('layerID');
var lineID = draggingSupport.get('lineID');
var diffX = x - draggingSupport.get('startPointX');
var diffY = y - draggingSupport.get('startPointY');
var newVertex0X = draggingSupport.get('startVertex0X') + diffX;
var newVertex0Y = draggingSupport.get('startVertex0Y') + diffY;
var newVertex1X = draggingSupport.get('startVertex1X') + diffX;
var newVertex1Y = draggingSupport.get('startVertex1Y') + diffY;
var drawingLine = state.getIn(['scene', 'layers', layerID, 'lines', lineID]).toJS();
var allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']).toJS();
var activeSnapElement = null;
var curSnap0 = null,
curSnap1 = null;
if (state.snapMask && !state.snapMask.isEmpty()) {
curSnap0 = _export2.SnapUtils.nearestSnap(snapElements, newVertex0X, newVertex0Y, state.snapMask);
curSnap1 = _export2.SnapUtils.nearestSnap(snapElements, newVertex1X, newVertex1Y, state.snapMask);
}
var deltaX = 0,
deltaY = 0;
if (curSnap0 && curSnap1) {
if (curSnap0.point.distance < curSnap1.point.distance) {
deltaX = curSnap0.point.x - newVertex0X;
deltaY = curSnap0.point.y - newVertex0Y;
activeSnapElement = curSnap0.snap;
} else {
deltaX = curSnap1.point.x - newVertex1X;
deltaY = curSnap1.point.y - newVertex1Y;
activeSnapElement = curSnap1.snap;
}
} else {
if (curSnap0) {
deltaX = curSnap0.point.x - newVertex0X;
deltaY = curSnap0.point.y - newVertex0Y;
activeSnapElement = curSnap0.snap;
}
if (curSnap1) {
deltaX = curSnap1.point.x - newVertex1X;
deltaY = curSnap1.point.y - newVertex1Y;
activeSnapElement = curSnap1.snap;
}
}
newVertex0X += deltaX;
newVertex0Y += deltaY;
newVertex1X += deltaX;
newVertex1Y += deltaY;
var newPoints = {
newVertex0X: newVertex0X,
newVertex0Y: newVertex0Y,
newVertex1X: newVertex1X,
newVertex1Y: newVertex1Y
};
var newResult = this.getNewDraggedPoints(newPoints, allVertices, drawingLine, relatedLines);
newVertex0X = newResult.newVertex0X;
newVertex0Y = newResult.newVertex0Y;
newVertex1X = newResult.newVertex1X;
newVertex1Y = newResult.newVertex1Y;
state = state.merge({
activeSnapElement: activeSnapElement,
scene: state.scene.updateIn(['layers', layerID], function (layer) {
return layer.withMutations(function (layer) {
var lineVertices = layer.getIn(['lines', lineID, 'vertices']);
layer.updateIn(['vertices', lineVertices.get(0)], function (vertex) {
return vertex.merge({
x: newVertex0X,
y: newVertex0Y
});
});
layer.updateIn(['vertices', lineVertices.get(1)], function (vertex) {
return vertex.merge({
x: newVertex1X,
y: newVertex1Y
});
});
return layer;
});
})
});
return {
updatedState: state
};
}
}, {
key: "endDraggingLine",
value: function endDraggingLine(state, x, y, relatedLines) {
var _state = state,
draggingSupport = _state.draggingSupport;
var layerID = draggingSupport.get('layerID');
var layer = state.scene.layers.get(layerID);
var lineID = draggingSupport.get('lineID');
var line = layer.lines.get(lineID);
var drawedLine = line.toJS();
var allVertices = state.getIn(['scene', 'layers', layerID, 'vertices']).toJS();
if ((0, _helper.isEmpty)(drawedLine)) {
return {
updatedState: state
};
}
var diffX = x - draggingSupport.get('startPointX');
var diffY = y - draggingSupport.get('startPointY');
var newVertex0X = draggingSupport.get('startVertex0X') + diffX;
var newVertex0Y = draggingSupport.get('startVertex0Y') + diffY;
var newVertex1X = draggingSupport.get('startVertex1X') + diffX;
var newVertex1Y = draggingSupport.get('startVertex1Y') + diffY;
if (state.snapMask && !state.snapMask.isEmpty()) {
var curSnap0 = _export2.SnapUtils.nearestSnap(state.snapElements, newVertex0X, newVertex0Y, state.snapMask);
var curSnap1 = _export2.SnapUtils.nearestSnap(state.snapElements, newVertex1X, newVertex1Y, state.snapMask);
var deltaX = 0,
deltaY = 0;
if (curSnap0 && curSnap1) {
if (curSnap0.point.distance < curSnap1.point.distance) {
deltaX = curSnap0.point.x - newVertex0X;
deltaY = curSnap0.point.y - newVertex0Y;
} else {
deltaX = curSnap1.point.x - newVertex1X;
deltaY = curSnap1.point.y - newVertex1Y;
}
} else {
if (curSnap0) {
deltaX = curSnap0.point.x - newVertex0X;
deltaY = curSnap0.point.y - newVertex0Y;
}
if (curSnap1) {
deltaX = curSnap1.point.x - newVertex1X;
deltaY = curSnap1.point.y - newVertex1Y;
}
}
newVertex0X += deltaX;
newVertex0Y += deltaY;
newVertex1X += deltaX;
newVertex1Y += deltaY;
}
var newPoints = {
newVertex0X: newVertex0X,
newVertex0Y: newVertex0Y,
newVertex1X: newVertex1X,
newVertex1Y: newVertex1Y
};
var newResult = this.getNewDraggedPoints(newPoints, allVertices, drawedLine, relatedLines);
newVertex0X = newResult.newVertex0X;
newVertex0Y = newResult.newVertex0Y;
newVertex1X = newResult.newVertex1X;
newVertex1Y = newResult.newVertex1Y;
state = _export.Layer.mergeEqualsVertices(state, layerID, line.vertices.get(0)).updatedState;
state = _export.Layer.mergeEqualsVertices(state, layerID, line.vertices.get(1)).updatedState;
if (_export2.GeometryUtils.samePoints({
newVertex0X: newVertex0X,
newVertex0Y: newVertex0Y
}, {
newVertex1X: newVertex1X,
newVertex1Y: newVertex1Y
})) {
state = Line.remove(state, layerID,