@openhps/core
Version:
Open Hybrid Positioning System - Core component
245 lines (228 loc) • 8.69 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Line = void 0;
var _Sphere = require("../math/Sphere.js");
var _Ray = require("../math/Ray.js");
var _Matrix = require("../math/Matrix4.js");
var _Object3D = require("../core/Object3D.js");
var _Vector = require("../math/Vector3.js");
var _LineBasicMaterial = require("../materials/LineBasicMaterial.js");
var _BufferGeometry = require("../core/BufferGeometry.js");
var _BufferAttribute = require("../core/BufferAttribute.js");
const _vStart = /*@__PURE__*/new _Vector.Vector3();
const _vEnd = /*@__PURE__*/new _Vector.Vector3();
const _inverseMatrix = /*@__PURE__*/new _Matrix.Matrix4();
const _ray = /*@__PURE__*/new _Ray.Ray();
const _sphere = /*@__PURE__*/new _Sphere.Sphere();
const _intersectPointOnRay = /*@__PURE__*/new _Vector.Vector3();
const _intersectPointOnSegment = /*@__PURE__*/new _Vector.Vector3();
/**
* A continuous line. The line are rendered by connecting consecutive
* vertices with straight lines.
*
* ```js
* const material = new THREE.LineBasicMaterial( { color: 0x0000ff } );
*
* const points = [];
* points.push( new THREE.Vector3( - 10, 0, 0 ) );
* points.push( new THREE.Vector3( 0, 10, 0 ) );
* points.push( new THREE.Vector3( 10, 0, 0 ) );
*
* const geometry = new THREE.BufferGeometry().setFromPoints( points );
*
* const line = new THREE.Line( geometry, material );
* scene.add( line );
* ```
*
* @augments Object3D
*/
class Line extends _Object3D.Object3D {
/**
* Constructs a new line.
*
* @param {BufferGeometry} [geometry] - The line geometry.
* @param {Material|Array<Material>} [material] - The line material.
*/
constructor(geometry = new _BufferGeometry.BufferGeometry(), material = new _LineBasicMaterial.LineBasicMaterial()) {
super();
/**
* This flag can be used for type testing.
*
* @type {boolean}
* @readonly
* @default true
*/
this.isLine = true;
this.type = 'Line';
/**
* The line geometry.
*
* @type {BufferGeometry}
*/
this.geometry = geometry;
/**
* The line material.
*
* @type {Material|Array<Material>}
* @default LineBasicMaterial
*/
this.material = material;
/**
* A dictionary representing the morph targets in the geometry. The key is the
* morph targets name, the value its attribute index. This member is `undefined`
* by default and only set when morph targets are detected in the geometry.
*
* @type {Object<String,number>|undefined}
* @default undefined
*/
this.morphTargetDictionary = undefined;
/**
* An array of weights typically in the range `[0,1]` that specify how much of the morph
* is applied. This member is `undefined` by default and only set when morph targets are
* detected in the geometry.
*
* @type {Array<number>|undefined}
* @default undefined
*/
this.morphTargetInfluences = undefined;
this.updateMorphTargets();
}
copy(source, recursive) {
super.copy(source, recursive);
this.material = Array.isArray(source.material) ? source.material.slice() : source.material;
this.geometry = source.geometry;
return this;
}
/**
* Computes an array of distance values which are necessary for rendering dashed lines.
* For each vertex in the geometry, the method calculates the cumulative length from the
* current point to the very beginning of the line.
*
* @return {Line} A reference to this line.
*/
computeLineDistances() {
const geometry = this.geometry;
// we assume non-indexed geometry
if (geometry.index === null) {
const positionAttribute = geometry.attributes.position;
const lineDistances = [0];
for (let i = 1, l = positionAttribute.count; i < l; i++) {
_vStart.fromBufferAttribute(positionAttribute, i - 1);
_vEnd.fromBufferAttribute(positionAttribute, i);
lineDistances[i] = lineDistances[i - 1];
lineDistances[i] += _vStart.distanceTo(_vEnd);
}
geometry.setAttribute('lineDistance', new _BufferAttribute.Float32BufferAttribute(lineDistances, 1));
} else {
console.warn('THREE.Line.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.');
}
return this;
}
/**
* Computes intersection points between a casted ray and this line.
*
* @param {Raycaster} raycaster - The raycaster.
* @param {Array<Object>} intersects - The target array that holds the intersection points.
*/
raycast(raycaster, intersects) {
const geometry = this.geometry;
const matrixWorld = this.matrixWorld;
const threshold = raycaster.params.Line.threshold;
const drawRange = geometry.drawRange;
// Checking boundingSphere distance to ray
if (geometry.boundingSphere === null) geometry.computeBoundingSphere();
_sphere.copy(geometry.boundingSphere);
_sphere.applyMatrix4(matrixWorld);
_sphere.radius += threshold;
if (raycaster.ray.intersectsSphere(_sphere) === false) return;
//
_inverseMatrix.copy(matrixWorld).invert();
_ray.copy(raycaster.ray).applyMatrix4(_inverseMatrix);
const localThreshold = threshold / ((this.scale.x + this.scale.y + this.scale.z) / 3);
const localThresholdSq = localThreshold * localThreshold;
const step = this.isLineSegments ? 2 : 1;
const index = geometry.index;
const attributes = geometry.attributes;
const positionAttribute = attributes.position;
if (index !== null) {
const start = Math.max(0, drawRange.start);
const end = Math.min(index.count, drawRange.start + drawRange.count);
for (let i = start, l = end - 1; i < l; i += step) {
const a = index.getX(i);
const b = index.getX(i + 1);
const intersect = checkIntersection(this, raycaster, _ray, localThresholdSq, a, b, i);
if (intersect) {
intersects.push(intersect);
}
}
if (this.isLineLoop) {
const a = index.getX(end - 1);
const b = index.getX(start);
const intersect = checkIntersection(this, raycaster, _ray, localThresholdSq, a, b, end - 1);
if (intersect) {
intersects.push(intersect);
}
}
} else {
const start = Math.max(0, drawRange.start);
const end = Math.min(positionAttribute.count, drawRange.start + drawRange.count);
for (let i = start, l = end - 1; i < l; i += step) {
const intersect = checkIntersection(this, raycaster, _ray, localThresholdSq, i, i + 1, i);
if (intersect) {
intersects.push(intersect);
}
}
if (this.isLineLoop) {
const intersect = checkIntersection(this, raycaster, _ray, localThresholdSq, end - 1, start, end - 1);
if (intersect) {
intersects.push(intersect);
}
}
}
}
/**
* Sets the values of {@link Line#morphTargetDictionary} and {@link Line#morphTargetInfluences}
* to make sure existing morph targets can influence this 3D object.
*/
updateMorphTargets() {
const geometry = this.geometry;
const morphAttributes = geometry.morphAttributes;
const keys = Object.keys(morphAttributes);
if (keys.length > 0) {
const morphAttribute = morphAttributes[keys[0]];
if (morphAttribute !== undefined) {
this.morphTargetInfluences = [];
this.morphTargetDictionary = {};
for (let m = 0, ml = morphAttribute.length; m < ml; m++) {
const name = morphAttribute[m].name || String(m);
this.morphTargetInfluences.push(0);
this.morphTargetDictionary[name] = m;
}
}
}
}
}
exports.Line = Line;
function checkIntersection(object, raycaster, ray, thresholdSq, a, b, i) {
const positionAttribute = object.geometry.attributes.position;
_vStart.fromBufferAttribute(positionAttribute, a);
_vEnd.fromBufferAttribute(positionAttribute, b);
const distSq = ray.distanceSqToSegment(_vStart, _vEnd, _intersectPointOnRay, _intersectPointOnSegment);
if (distSq > thresholdSq) return;
_intersectPointOnRay.applyMatrix4(object.matrixWorld); // Move back to world space for distance calculation
const distance = raycaster.ray.origin.distanceTo(_intersectPointOnRay);
if (distance < raycaster.near || distance > raycaster.far) return;
return {
distance: distance,
// What do we want? intersection point on the ray or on the segment??
// point: raycaster.ray.at( distance ),
point: _intersectPointOnSegment.clone().applyMatrix4(object.matrixWorld),
index: i,
face: null,
faceIndex: null,
barycoord: null,
object: object
};
}