t3d-3dtiles 0.1.0

package/src/materials/InstancedBasicMaterial.js

@@ -0,0 +1,32 @@
+import { BasicMaterial, ShaderLib, MATERIAL_TYPE } from 't3d';
+import { instancingParsVert, instancingPositionVert, instancingNormalVert } from './InstancedShaderChunks.js';
+
+export class InstancedBasicMaterial extends BasicMaterial {
+
+	constructor() {
+		super();
+		this.type = MATERIAL_TYPE.SHADER;
+		this.shaderName = 'TILE_I_BASIC';
+		this.vertexShader = vertexShader;
+		this.fragmentShader = ShaderLib.basic_frag;
+		this.defines.USE_INSTANCING = true;
+	}
+
+}
+
+InstancedBasicMaterial.prototype.isInstancedBasicMaterial = true;
+
+let vertexShader = ShaderLib.basic_vert;
+
+vertexShader = vertexShader.replace('#include <logdepthbuf_pars_vert>', `
+    #include <logdepthbuf_pars_vert>
+    ${instancingParsVert}
+`);
+vertexShader = vertexShader.replace('#include <pvm_vert>', `
+    ${instancingPositionVert}
+    #include <pvm_vert>
+`);
+vertexShader = vertexShader.replace('#include <normal_vert>', `
+    ${instancingNormalVert}
+    #include <normal_vert>
+`);

package/src/materials/InstancedPBRMaterial.js

@@ -0,0 +1,32 @@
+import { PBRMaterial, ShaderLib, MATERIAL_TYPE } from 't3d';
+import { instancingParsVert, instancingPositionVert, instancingNormalVert } from './InstancedShaderChunks.js';
+
+export class InstancedPBRMaterial extends PBRMaterial {
+
+	constructor() {
+		super();
+		this.type = MATERIAL_TYPE.SHADER;
+		this.shaderName = 'TILE_I_PBR';
+		this.vertexShader = vertexShader;
+		this.fragmentShader = ShaderLib.pbr_frag;
+		this.defines.USE_INSTANCING = true;
+	}
+
+}
+
+InstancedPBRMaterial.prototype.isInstancedPBRMaterial = true;
+
+let vertexShader = ShaderLib.pbr_vert;
+
+vertexShader = vertexShader.replace('#include <logdepthbuf_pars_vert>', `
+    #include <logdepthbuf_pars_vert>
+    ${instancingParsVert}
+`);
+vertexShader = vertexShader.replace('#include <pvm_vert>', `
+    ${instancingPositionVert}
+    #include <pvm_vert>
+`);
+vertexShader = vertexShader.replace('#include <normal_vert>', `
+    ${instancingNormalVert}
+    #include <normal_vert>
+`);

package/src/materials/InstancedShaderChunks.js

@@ -0,0 +1,23 @@
+export const instancingParsVert = `
+    #ifdef USE_INSTANCING
+        attribute mat4 instanceMatrix;
+    #endif
+`;
+
+export const instancingPositionVert = `
+    #ifdef USE_INSTANCING
+        transformed = (instanceMatrix * vec4(transformed, 1.0)).xyz;
+    #endif
+`;
+
+export const instancingNormalVert = `
+    #ifdef USE_INSTANCING
+        #ifdef USE_INSTANCING
+            objectNormal = (transposeMat4(inverseMat4(instanceMatrix)) * vec4(objectNormal, 0.0)).xyz;
+        #endif
+
+        #ifdef USE_TANGENT
+            objectTangent = (transposeMat4(inverseMat4(instanceMatrix)) * vec4(objectTangent, 0.0)).xyz;
+        #endif
+    #endif
+`;

package/src/math/Ellipsoid.js

@@ -0,0 +1,41 @@
+import { Spherical, Vector3 } from 't3d';
+import { swapToGeoFrame, latitudeToSphericalPhi } from './GeoUtils.js';
+
+export class Ellipsoid {
+
+	constructor(radius = new Vector3(1, 1, 1)) {
+		this.radius = radius;
+	}
+
+	getCartographicToPosition(lat, lon, height, target) {
+		// From Cesium function Ellipsoid.cartographicToCartesian
+		// https://github.com/CesiumGS/cesium/blob/665ec32e813d5d6fe906ec3e87187f6c38ed5e49/packages/engine/Source/Core/Ellipsoid.js#L396
+		this.getCartographicToNormal(lat, lon, _norm);
+
+		const radius = this.radius;
+		_vec3_1.copy(_norm);
+		_vec3_1.x *= radius.x ** 2;
+		_vec3_1.y *= radius.y ** 2;
+		_vec3_1.z *= radius.z ** 2;
+
+		const gamma = Math.sqrt(_norm.dot(_vec3_1));
+		_vec3_1.multiplyScalar(1 / gamma);
+
+		return target.copy(_vec3_1).addScaledVector(_norm, height);
+	}
+
+	getCartographicToNormal(lat, lon, target) {
+		_spherical.set(1, latitudeToSphericalPhi(lat), lon);
+		target.setFromSpherical(_spherical).normalize();
+
+		// swap frame from the t3d.js frame to the geo coord frame
+		swapToGeoFrame(target);
+		return target;
+	}
+
+}
+
+const _norm = new Vector3();
+const _spherical = new Spherical();
+
+const _vec3_1 = new Vector3();

package/src/math/EllipsoidRegion.js

@@ -0,0 +1,160 @@
+import { Matrix4, Vector2, Vector3 } from 't3d';
+import { Ellipsoid } from './Ellipsoid.js';
+
+export class EllipsoidRegion extends Ellipsoid {
+
+	constructor(
+		radius = new Vector3(1, 1, 1),
+		latRange = new Vector2(-HALF_PI, HALF_PI),
+		lonRange = new Vector2(0, 2 * PI),
+		heightRange = new Vector2(0, 1)
+	) {
+		super(radius);
+
+		this.latRange = latRange;
+		this.lonRange = lonRange;
+		this.heightRange = heightRange;
+	}
+
+	// refer to https://github.com/CesiumGS/cesium/blob/1.119/packages/engine/Source/Core/OrientedBoundingBox.js#L343
+	// refer to https://github.com/NASA-AMMOS/3DTilesRendererJS/blob/c46d59c674e9ac1e652b9e9b65849bf02a645a6a/src/three/math/EllipsoidRegion.js#L120
+	getOrientedBoundingBox(target) {
+		resetPool();
+
+		const { latRange, lonRange } = this;
+
+		const latRangeValue = latRange.y - latRange.x;
+
+		if (latRangeValue < PI / 2) {
+			// get the midway point for the region
+			const midLat = mapLinear(0.5, 0, 1, latRange.x, latRange.y);
+			const midLon = mapLinear(0.5, 0, 1, lonRange.x, lonRange.y);
+
+			// get the frame matrix for the box - works well for smaller regions
+			this.getCartographicToNormal(midLat, midLon, _orthoZ);
+			_orthoY.set(0, 0, 1);
+			_orthoX.crossVectors(_orthoY, _orthoZ);
+			_orthoY.crossVectors(_orthoX, _orthoZ);
+		} else {
+			_orthoX.set(1, 0, 0);
+			_orthoY.set(0, 1, 0);
+			_orthoZ.set(0, 0, 1);
+		}
+
+		target.rotation.set(
+			_orthoX.x, _orthoY.x, _orthoZ.x,
+			_orthoX.y, _orthoY.y, _orthoZ.y,
+			_orthoX.z, _orthoY.z, _orthoZ.z
+		);
+
+		// transform the points into the local frame
+		_invMatrix.setFromMatrix3(target.rotation).inverse();
+
+		const points = this._getPoints(true);
+
+		// get the center of the region
+		_center.set(0, 0, 0);
+		for (let i = 0, l = points.length; i < l; i++) {
+			_center.add(points[i]);
+		}
+		_center.multiplyScalar(1 / points.length);
+
+		for (let i = 0, l = points.length; i < l; i++) {
+			points[i].sub(_center).applyMatrix4(_invMatrix).add(_center);
+		}
+
+		target.box.makeEmpty();
+		target.box.setFromPoints(points);
+	}
+
+	getBoundingSphere(target) {
+		resetPool();
+
+		const points = this._getPoints(true);
+		target.makeEmpty();
+		target.setFromPoints(points);
+	}
+
+	_getPoints(usePool = false) {
+		const { latRange, lonRange, heightRange } = this;
+
+		const midLat = mapLinear(0.5, 0, 1, latRange.x, latRange.y);
+		const midLon = mapLinear(0.5, 0, 1, lonRange.x, lonRange.y);
+
+		const lonOffset = Math.floor(lonRange.x / HALF_PI) * HALF_PI;
+
+		const latlon = [
+			[-PI / 2, 0],
+			[PI / 2, 0],
+			[0, lonOffset],
+			[0, lonOffset + PI / 2],
+			[0, lonOffset + PI],
+			[0, lonOffset + 3 * PI / 2],
+
+			[latRange.x, lonRange.y],
+			[latRange.y, lonRange.y],
+			[latRange.x, lonRange.x],
+			[latRange.y, lonRange.x],
+
+			[0, lonRange.x],
+			[0, lonRange.y],
+
+			[midLat, midLon],
+			[latRange.x, midLon],
+			[latRange.y, midLon],
+			[midLat, lonRange.x],
+			[midLat, lonRange.y]
+		];
+
+		const target = [];
+		const total = latlon.length;
+
+		for (let z = 0; z <= 1; z++) {
+			const height = mapLinear(z, 0, 1, heightRange.x, heightRange.y);
+			for (let i = 0, l = total; i < l; i++) {
+				const [lat, lon] = latlon[i];
+				if (lat >= latRange.x && lat <= latRange.y && lon >= lonRange.x && lon <= lonRange.y) {
+					const v = getVector(usePool);
+					target.push(v);
+					this.getCartographicToPosition(lat, lon, height, v);
+				}
+			}
+		}
+
+		return target;
+	}
+
+}
+
+const _orthoX = new Vector3();
+const _orthoY = new Vector3();
+const _orthoZ = new Vector3();
+const _center = new Vector3();
+const _invMatrix = new Matrix4();
+
+const PI = Math.PI;
+const HALF_PI = PI / 2;
+
+// Linear mapping from range <a1, a2> to range <b1, b2>
+function mapLinear(x, a1, a2, b1, b2) {
+	return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
+}
+
+let _poolIndex = 0;
+const _pointsPool = [];
+function getVector(usePool = false) {
+	if (!usePool) {
+		return new Vector3();
+	}
+
+	if (!_pointsPool[_poolIndex]) {
+		_pointsPool[_poolIndex] = new Vector3();
+	}
+
+	_poolIndex++;
+	return _pointsPool[_poolIndex - 1];
+}
+
+function resetPool() {
+	_poolIndex = 0;
+}

package/src/math/FastFrustum.js

@@ -0,0 +1,49 @@
+import { Frustum, Matrix3, Vector3 } from 't3d';
+
+export class FastFrustum extends Frustum {
+
+	constructor() {
+		super();
+
+		this.points = new Array(8).fill().map(() => new Vector3());
+	}
+
+	updateCache() {
+		const { planes, points } = this;
+		const planeIntersections = [
+			[planes[0], planes[3], planes[4]], // Near top left
+			[planes[1], planes[3], planes[4]], // Near top right
+			[planes[0], planes[2], planes[4]], // Near bottom left
+			[planes[1], planes[2], planes[4]], // Near bottom right
+			[planes[0], planes[3], planes[5]], // Far top left
+			[planes[1], planes[3], planes[5]], // Far top right
+			[planes[0], planes[2], planes[5]], // Far bottom left
+			[planes[1], planes[2], planes[5]] // Far bottom right
+		];
+
+		planeIntersections.forEach((planes, index) => {
+			findIntersectionPoint(planes[0], planes[1], planes[2], points[index]);
+		});
+	}
+
+}
+
+const _mat3_1 = new Matrix3();
+
+// Solve a system of equations to find the point where the three planes intersect
+function findIntersectionPoint(plane1, plane2, plane3, target) {
+	// Create the matrix A using the normals of the planes as rows
+	const A = _mat3_1.set(
+		plane1.normal.x, plane1.normal.y, plane1.normal.z,
+		plane2.normal.x, plane2.normal.y, plane2.normal.z,
+		plane3.normal.x, plane3.normal.y, plane3.normal.z
+	);
+
+	// Create the vector B using the constants of the planes
+	target.set(-plane1.constant, -plane2.constant, -plane3.constant);
+
+	// Solve for X by applying the inverse matrix to B
+	target.applyMatrix3(A.inverse());
+
+	return target;
+}

package/src/math/GeoUtils.js

@@ -0,0 +1,31 @@
+// Cesium / 3D tiles Spheroid:
+// - Up is Z at 90 degrees latitude
+// - 0, 0 latitude, longitude is X axis
+//      Z
+//      |
+//      |
+//      .----- Y
+//     /
+//   X
+
+
+// t3d.js Spherical Coordinates
+// - Up is Y at 90 degrees latitude
+// - 0, 0 latitude, longitude is Z
+//      Y
+//      |
+//      |
+//      .----- X
+//     /
+//   Z
+
+export function swapToGeoFrame(target) {
+	const { x, y, z } = target;
+	target.x = z;
+	target.y = x;
+	target.z = y;
+}
+
+export function latitudeToSphericalPhi(latitude) {
+	return -latitude + Math.PI / 2;
+}