awv3/plugins/sketcher/snaputils.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.getSnappedPointWrap = getSnappedPointWrap;

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function getClosestGeomPoint(sketch, newPoint, maxDistance, ignoreFilter) {
    if (!ignoreFilter) ignoreFilter = function ignoreFilter(obj) {
        return false;
    };

    var distance = maxDistance;
    var closestPoint = newPoint.clone();
    var isSnapped = false;
    sketch.getObjectsOnSketch().forEach(function (obj) {
        Sketch.ForObjectsWithChildren(obj, function (child) {
            if (ignoreFilter(child)) return;
            if (child instanceof Point) {
                var point = child;
                var currentDistance = point.position.distanceTo(newPoint);
                if (currentDistance < distance) {
                    distance = currentDistance;
                    closestPoint = point.position.clone();
                    isSnapped = true;
                }
            }
        });
    });

    return {
        snappedPosition: closestPoint,
        snappingShift: closestPoint.clone().sub(newPoint),
        isSnapped: isSnapped
    };
}

function getClosestGridPoint(sketch, newPoint, maxDistance, ignoreFilter) {
    var closestPoint = newPoint.clone();
    var isSnapped = false;
    if (sketch.gridStep > 0.0) {
        var distance = Math.min(maxDistance, sketch.gridStep / 3.0);
        var x = Math.round(newPoint.x / sketch.gridStep) * sketch.gridStep;
        var y = Math.round(newPoint.y / sketch.gridStep) * sketch.gridStep;
        if ((x - newPoint.x) * (x - newPoint.x) + (y - newPoint.y) * (y - newPoint.y) < distance * distance) {
            closestPoint.x = x;
            closestPoint.y = y;
            isSnapped = true;
        }
    }

    return {
        snappedPosition: closestPoint,
        snappingShift: closestPoint.clone().sub(newPoint),
        isSnapped: isSnapped
    };
}

function getClosestSnapPoint(sketch, position, maxDistance, ignoreFilter) {
    var toReturn = position.clone();
    var gridClosestPoint = getClosestGridPoint(sketch, toReturn, maxDistance, ignoreFilter);
    var geomClosestPoint = getClosestGeomPoint(sketch, toReturn, maxDistance, ignoreFilter);

    if (geomClosestPoint.isSnapped && gridClosestPoint.isSnapped) return geomClosestPoint.snappingShift.length() < gridClosestPoint.snappingShift.length() ? geomClosestPoint : gridClosestPoint;else return geomClosestPoint.isSnapped ? geomClosestPoint : gridClosestPoint;
}

function getSnappedPointWrap(sketch, mousePosition, obj, lastDragPoint) {
    return mousePosition.clone(); // TODO
    if (!obj) return mousePosition;

    var maxDistance = obj.points[0].mesh.scale.x * 1.5;

    function snapToDirection() {
        var toReturn = mousePosition.clone();

        var line = obj.parent;
        var idx = line.points[0] == obj ? 0 : 1;
        var neighbourPoint = line.points[1 - idx].position;

        var delta = new THREE.Vector3();
        delta.subVectors(toReturn, neighbourPoint);
        delta.z = 0.0;

        var len = delta.length();
        if (len > 0.001) {
            var oX = new THREE.Vector3(1.0, 0.0, 0.0);
            var angleDeltaToOX = delta.angleTo(oX);
            angleDeltaToOX = delta.y < -1e-6 ? 2 * Math.PI - angleDeltaToOX : angleDeltaToOX;
            var axis = oX;
            var angleAxisToOX = axis.angleTo(oX);
            angleAxisToOX = axis.y < -1e-6 ? 2 * Math.PI - angleAxisToOX : angleAxisToOX;

            var diff = angleDeltaToOX > angleAxisToOX ? angleDeltaToOX - angleAxisToOX : 2 * Math.PI + angleDeltaToOX - angleAxisToOX;
            var round = Math.round(diff * nbShiftDirections / (2 * Math.PI));
            var angle = 2 * Math.PI * round / nbShiftDirections;
            angle += angleAxisToOX;
            var dir = new THREE.Vector3(Math.cos(angle), Math.sin(angle), 0.0);
            dir.multiplyScalar(dir.dot(delta));
            toReturn.addVectors(neighbourPoint, dir);
        }

        return toReturn;
    }

    var nbShiftDirections = 0; // TODO sketcher.view.interaction.shiftKey ? sketcher.__sketchControlsHandler.shiftDirections : 0;
    if (nbShiftDirections && obj.parent instanceof Line) return snapToDirection();

    var toReturn = mousePosition.clone();

    var pointsToSnap = [];
    if (obj instanceof Point) pointsToSnap = [obj];else
        ///return toReturn;
        Sketch.ForObjectsWithChildren(obj, function (arg) {
            if (arg instanceof Point) pointsToSnap.push(arg);
        });

    var fromMousePositionToPoint = new THREE.Vector3(0, 0, 0);

    var distance = maxDistance;
    pointsToSnap.forEach(function (geomPoint) {
        if (lastDragPoint !== undefined) fromMousePositionToPoint = geomPoint.position.clone().sub(lastDragPoint);
        var snapPosition = mousePosition.clone();
        if (obj.name !== 'center') snapPosition.add(fromMousePositionToPoint);
        var snappedPoint = getClosestSnapPoint(sketch, snapPosition, maxDistance, function (arg) {
            return Sketch.ForObjectsWithChildren(arg).indexOf(geomPoint) !== -1;
        });

        if (snappedPoint.isSnapped && snappedPoint.snappingShift.length() < distance) {
            distance = snappedPoint.snappingShift.length();
            toReturn = snappedPoint.snappedPosition;
            if (!(obj instanceof Point)) toReturn.sub(fromMousePositionToPoint);
        }
    });

    return toReturn;
}