import BoundingSphere from './BoundingSphere.js';
|
import Cartesian3 from './Cartesian3.js';
|
import Cartesian4 from './Cartesian4.js';
|
import Check from './Check.js';
|
import ComponentDatatype from './ComponentDatatype.js';
|
import defaultValue from './defaultValue.js';
|
import defined from './defined.js';
|
import Geometry from './Geometry.js';
|
import GeometryAttribute from './GeometryAttribute.js';
|
import GeometryAttributes from './GeometryAttributes.js';
|
import Matrix3 from './Matrix3.js';
|
import Matrix4 from './Matrix4.js';
|
import OrthographicFrustum from './OrthographicFrustum.js';
|
import PerspectiveFrustum from './PerspectiveFrustum.js';
|
import PrimitiveType from './PrimitiveType.js';
|
import Quaternion from './Quaternion.js';
|
import VertexFormat from './VertexFormat.js';
|
|
var PERSPECTIVE = 0;
|
var ORTHOGRAPHIC = 1;
|
|
/**
|
* Describes a frustum at the given the origin and orientation.
|
*
|
* @alias FrustumGeometry
|
* @constructor
|
*
|
* @param {Object} options Object with the following properties:
|
* @param {PerspectiveFrustum|OrthographicFrustum} options.frustum The frustum.
|
* @param {Cartesian3} options.origin The origin of the frustum.
|
* @param {Quaternion} options.orientation The orientation of the frustum.
|
* @param {VertexFormat} [options.vertexFormat=VertexFormat.DEFAULT] The vertex attributes to be computed.
|
*/
|
function FrustumGeometry(options) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.typeOf.object('options', options);
|
Check.typeOf.object('options.frustum', options.frustum);
|
Check.typeOf.object('options.origin', options.origin);
|
Check.typeOf.object('options.orientation', options.orientation);
|
//>>includeEnd('debug');
|
|
var frustum = options.frustum;
|
var orientation = options.orientation;
|
var origin = options.origin;
|
var vertexFormat = defaultValue(options.vertexFormat, VertexFormat.DEFAULT);
|
|
// This is private because it is used by DebugCameraPrimitive to draw a multi-frustum by
|
// creating multiple FrustumGeometrys. This way the near plane of one frustum doesn't overlap
|
// the far plane of another.
|
var drawNearPlane = defaultValue(options._drawNearPlane, true);
|
|
var frustumType;
|
var frustumPackedLength;
|
if (frustum instanceof PerspectiveFrustum) {
|
frustumType = PERSPECTIVE;
|
frustumPackedLength = PerspectiveFrustum.packedLength;
|
} else if (frustum instanceof OrthographicFrustum) {
|
frustumType = ORTHOGRAPHIC;
|
frustumPackedLength = OrthographicFrustum.packedLength;
|
}
|
|
this._frustumType = frustumType;
|
this._frustum = frustum.clone();
|
this._origin = Cartesian3.clone(origin);
|
this._orientation = Quaternion.clone(orientation);
|
this._drawNearPlane = drawNearPlane;
|
this._vertexFormat = vertexFormat;
|
this._workerName = 'createFrustumGeometry';
|
|
/**
|
* The number of elements used to pack the object into an array.
|
* @type {Number}
|
*/
|
this.packedLength = 2 + frustumPackedLength + Cartesian3.packedLength + Quaternion.packedLength + VertexFormat.packedLength;
|
}
|
|
/**
|
* Stores the provided instance into the provided array.
|
*
|
* @param {FrustumGeometry} value The value to pack.
|
* @param {Number[]} array The array to pack into.
|
* @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
|
*
|
* @returns {Number[]} The array that was packed into
|
*/
|
FrustumGeometry.pack = function(value, array, startingIndex) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.typeOf.object('value', value);
|
Check.defined('array', array);
|
//>>includeEnd('debug');
|
|
startingIndex = defaultValue(startingIndex, 0);
|
|
var frustumType = value._frustumType;
|
var frustum = value._frustum;
|
|
array[startingIndex++] = frustumType;
|
|
if (frustumType === PERSPECTIVE) {
|
PerspectiveFrustum.pack(frustum, array, startingIndex);
|
startingIndex += PerspectiveFrustum.packedLength;
|
} else {
|
OrthographicFrustum.pack(frustum, array, startingIndex);
|
startingIndex += OrthographicFrustum.packedLength;
|
}
|
|
Cartesian3.pack(value._origin, array, startingIndex);
|
startingIndex += Cartesian3.packedLength;
|
Quaternion.pack(value._orientation, array, startingIndex);
|
startingIndex += Quaternion.packedLength;
|
VertexFormat.pack(value._vertexFormat, array, startingIndex);
|
startingIndex += VertexFormat.packedLength;
|
array[startingIndex] = value._drawNearPlane ? 1.0 : 0.0;
|
|
return array;
|
};
|
|
var scratchPackPerspective = new PerspectiveFrustum();
|
var scratchPackOrthographic = new OrthographicFrustum();
|
var scratchPackQuaternion = new Quaternion();
|
var scratchPackorigin = new Cartesian3();
|
var scratchVertexFormat = new VertexFormat();
|
|
/**
|
* Retrieves an instance from a packed array.
|
*
|
* @param {Number[]} array The packed array.
|
* @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
|
* @param {FrustumGeometry} [result] The object into which to store the result.
|
*/
|
FrustumGeometry.unpack = function(array, startingIndex, result) {
|
//>>includeStart('debug', pragmas.debug);
|
Check.defined('array', array);
|
//>>includeEnd('debug');
|
|
startingIndex = defaultValue(startingIndex, 0);
|
|
var frustumType = array[startingIndex++];
|
|
var frustum;
|
if (frustumType === PERSPECTIVE) {
|
frustum = PerspectiveFrustum.unpack(array, startingIndex, scratchPackPerspective);
|
startingIndex += PerspectiveFrustum.packedLength;
|
} else {
|
frustum = OrthographicFrustum.unpack(array, startingIndex, scratchPackOrthographic);
|
startingIndex += OrthographicFrustum.packedLength;
|
}
|
|
var origin = Cartesian3.unpack(array, startingIndex, scratchPackorigin);
|
startingIndex += Cartesian3.packedLength;
|
var orientation = Quaternion.unpack(array, startingIndex, scratchPackQuaternion);
|
startingIndex += Quaternion.packedLength;
|
var vertexFormat = VertexFormat.unpack(array, startingIndex, scratchVertexFormat);
|
startingIndex += VertexFormat.packedLength;
|
var drawNearPlane = array[startingIndex] === 1.0;
|
|
if (!defined(result)) {
|
return new FrustumGeometry({
|
frustum : frustum,
|
origin : origin,
|
orientation : orientation,
|
vertexFormat : vertexFormat,
|
_drawNearPlane : drawNearPlane
|
});
|
}
|
|
var frustumResult = frustumType === result._frustumType ? result._frustum : undefined;
|
result._frustum = frustum.clone(frustumResult);
|
|
result._frustumType = frustumType;
|
result._origin = Cartesian3.clone(origin, result._origin);
|
result._orientation = Quaternion.clone(orientation, result._orientation);
|
result._vertexFormat = VertexFormat.clone(vertexFormat, result._vertexFormat);
|
result._drawNearPlane = drawNearPlane;
|
|
return result;
|
};
|
|
function getAttributes(offset, normals, tangents, bitangents, st, normal, tangent, bitangent) {
|
var stOffset = offset / 3 * 2;
|
|
for (var i = 0; i < 4; ++i) {
|
if (defined(normals)) {
|
normals[offset] = normal.x;
|
normals[offset + 1] = normal.y;
|
normals[offset + 2] = normal.z;
|
}
|
if (defined(tangents)) {
|
tangents[offset] = tangent.x;
|
tangents[offset + 1] = tangent.y;
|
tangents[offset + 2] = tangent.z;
|
}
|
if (defined(bitangents)) {
|
bitangents[offset] = bitangent.x;
|
bitangents[offset + 1] = bitangent.y;
|
bitangents[offset + 2] = bitangent.z;
|
}
|
offset += 3;
|
}
|
|
st[stOffset] = 0.0;
|
st[stOffset + 1] = 0.0;
|
st[stOffset + 2] = 1.0;
|
st[stOffset + 3] = 0.0;
|
st[stOffset + 4] = 1.0;
|
st[stOffset + 5] = 1.0;
|
st[stOffset + 6] = 0.0;
|
st[stOffset + 7] = 1.0;
|
}
|
|
var scratchRotationMatrix = new Matrix3();
|
var scratchViewMatrix = new Matrix4();
|
var scratchInverseMatrix = new Matrix4();
|
|
var scratchXDirection = new Cartesian3();
|
var scratchYDirection = new Cartesian3();
|
var scratchZDirection = new Cartesian3();
|
var scratchNegativeX = new Cartesian3();
|
var scratchNegativeY = new Cartesian3();
|
var scratchNegativeZ = new Cartesian3();
|
|
var frustumSplits = new Array(3);
|
|
var frustumCornersNDC = new Array(4);
|
frustumCornersNDC[0] = new Cartesian4(-1.0, -1.0, 1.0, 1.0);
|
frustumCornersNDC[1] = new Cartesian4(1.0, -1.0, 1.0, 1.0);
|
frustumCornersNDC[2] = new Cartesian4(1.0, 1.0, 1.0, 1.0);
|
frustumCornersNDC[3] = new Cartesian4(-1.0, 1.0, 1.0, 1.0);
|
|
var scratchFrustumCorners = new Array(4);
|
for (var i = 0; i < 4; ++i) {
|
scratchFrustumCorners[i] = new Cartesian4();
|
}
|
|
FrustumGeometry._computeNearFarPlanes = function(origin, orientation, frustumType, frustum, positions, xDirection, yDirection, zDirection) {
|
var rotationMatrix = Matrix3.fromQuaternion(orientation, scratchRotationMatrix);
|
var x = defaultValue(xDirection, scratchXDirection);
|
var y = defaultValue(yDirection, scratchYDirection);
|
var z = defaultValue(zDirection, scratchZDirection);
|
|
x = Matrix3.getColumn(rotationMatrix, 0, x);
|
y = Matrix3.getColumn(rotationMatrix, 1, y);
|
z = Matrix3.getColumn(rotationMatrix, 2, z);
|
|
Cartesian3.normalize(x, x);
|
Cartesian3.normalize(y, y);
|
Cartesian3.normalize(z, z);
|
|
Cartesian3.negate(x, x);
|
|
var view = Matrix4.computeView(origin, z, y, x, scratchViewMatrix);
|
|
var inverseView;
|
var inverseViewProjection;
|
if (frustumType === PERSPECTIVE) {
|
var projection = frustum.projectionMatrix;
|
var viewProjection = Matrix4.multiply(projection, view, scratchInverseMatrix);
|
inverseViewProjection = Matrix4.inverse(viewProjection, scratchInverseMatrix);
|
} else {
|
inverseView = Matrix4.inverseTransformation(view, scratchInverseMatrix);
|
}
|
|
if (defined(inverseViewProjection)) {
|
frustumSplits[0] = frustum.near;
|
frustumSplits[1] = frustum.far;
|
} else {
|
frustumSplits[0] = 0.0;
|
frustumSplits[1] = frustum.near;
|
frustumSplits[2] = frustum.far;
|
}
|
|
for (var i = 0; i < 2; ++i) {
|
for (var j = 0; j < 4; ++j) {
|
var corner = Cartesian4.clone(frustumCornersNDC[j], scratchFrustumCorners[j]);
|
|
if (!defined(inverseViewProjection)) {
|
if (defined(frustum._offCenterFrustum)) {
|
frustum = frustum._offCenterFrustum;
|
}
|
|
var near = frustumSplits[i];
|
var far = frustumSplits[i + 1];
|
|
corner.x = (corner.x * (frustum.right - frustum.left) + frustum.left + frustum.right) * 0.5;
|
corner.y = (corner.y * (frustum.top - frustum.bottom) + frustum.bottom + frustum.top) * 0.5;
|
corner.z = (corner.z * (near - far) - near - far) * 0.5;
|
corner.w = 1.0;
|
|
Matrix4.multiplyByVector(inverseView, corner, corner);
|
} else {
|
corner = Matrix4.multiplyByVector(inverseViewProjection, corner, corner);
|
|
// Reverse perspective divide
|
var w = 1.0 / corner.w;
|
Cartesian3.multiplyByScalar(corner, w, corner);
|
|
Cartesian3.subtract(corner, origin, corner);
|
Cartesian3.normalize(corner, corner);
|
|
var fac = Cartesian3.dot(z, corner);
|
Cartesian3.multiplyByScalar(corner, frustumSplits[i] / fac, corner);
|
Cartesian3.add(corner, origin, corner);
|
}
|
|
positions[12 * i + j * 3] = corner.x;
|
positions[12 * i + j * 3 + 1] = corner.y;
|
positions[12 * i + j * 3 + 2] = corner.z;
|
}
|
}
|
};
|
|
/**
|
* Computes the geometric representation of a frustum, including its vertices, indices, and a bounding sphere.
|
*
|
* @param {FrustumGeometry} frustumGeometry A description of the frustum.
|
* @returns {Geometry|undefined} The computed vertices and indices.
|
*/
|
FrustumGeometry.createGeometry = function(frustumGeometry) {
|
var frustumType = frustumGeometry._frustumType;
|
var frustum = frustumGeometry._frustum;
|
var origin = frustumGeometry._origin;
|
var orientation = frustumGeometry._orientation;
|
var drawNearPlane = frustumGeometry._drawNearPlane;
|
var vertexFormat = frustumGeometry._vertexFormat;
|
|
var numberOfPlanes = drawNearPlane ? 6 : 5;
|
var positions = new Float64Array(3 * 4 * 6);
|
FrustumGeometry._computeNearFarPlanes(origin, orientation, frustumType, frustum, positions);
|
|
// -x plane
|
var offset = 3 * 4 * 2;
|
positions[offset] = positions[3 * 4];
|
positions[offset + 1] = positions[3 * 4 + 1];
|
positions[offset + 2] = positions[3 * 4 + 2];
|
positions[offset + 3] = positions[0];
|
positions[offset + 4] = positions[1];
|
positions[offset + 5] = positions[2];
|
positions[offset + 6] = positions[3 * 3];
|
positions[offset + 7] = positions[3 * 3 + 1];
|
positions[offset + 8] = positions[3 * 3 + 2];
|
positions[offset + 9] = positions[3 * 7];
|
positions[offset + 10] = positions[3 * 7 + 1];
|
positions[offset + 11] = positions[3 * 7 + 2];
|
|
// -y plane
|
offset += 3 * 4;
|
positions[offset] = positions[3 * 5];
|
positions[offset + 1] = positions[3 * 5 + 1];
|
positions[offset + 2] = positions[3 * 5 + 2];
|
positions[offset + 3] = positions[3];
|
positions[offset + 4] = positions[3 + 1];
|
positions[offset + 5] = positions[3 + 2];
|
positions[offset + 6] = positions[0];
|
positions[offset + 7] = positions[1];
|
positions[offset + 8] = positions[2];
|
positions[offset + 9] = positions[3 * 4];
|
positions[offset + 10] = positions[3 * 4 + 1];
|
positions[offset + 11] = positions[3 * 4 + 2];
|
|
// +x plane
|
offset += 3 * 4;
|
positions[offset] = positions[3];
|
positions[offset + 1] = positions[3 + 1];
|
positions[offset + 2] = positions[3 + 2];
|
positions[offset + 3] = positions[3 * 5];
|
positions[offset + 4] = positions[3 * 5 + 1];
|
positions[offset + 5] = positions[3 * 5 + 2];
|
positions[offset + 6] = positions[3 * 6];
|
positions[offset + 7] = positions[3 * 6 + 1];
|
positions[offset + 8] = positions[3 * 6 + 2];
|
positions[offset + 9] = positions[3 * 2];
|
positions[offset + 10] = positions[3 * 2 + 1];
|
positions[offset + 11] = positions[3 * 2 + 2];
|
|
// +y plane
|
offset += 3 * 4;
|
positions[offset] = positions[3 * 2];
|
positions[offset + 1] = positions[3 * 2 + 1];
|
positions[offset + 2] = positions[3 * 2 + 2];
|
positions[offset + 3] = positions[3 * 6];
|
positions[offset + 4] = positions[3 * 6 + 1];
|
positions[offset + 5] = positions[3 * 6 + 2];
|
positions[offset + 6] = positions[3 * 7];
|
positions[offset + 7] = positions[3 * 7 + 1];
|
positions[offset + 8] = positions[3 * 7 + 2];
|
positions[offset + 9] = positions[3 * 3];
|
positions[offset + 10] = positions[3 * 3 + 1];
|
positions[offset + 11] = positions[3 * 3 + 2];
|
|
if (!drawNearPlane) {
|
positions = positions.subarray(3 * 4);
|
}
|
|
var attributes = new GeometryAttributes({
|
position : new GeometryAttribute({
|
componentDatatype : ComponentDatatype.DOUBLE,
|
componentsPerAttribute : 3,
|
values : positions
|
})
|
});
|
|
if (defined(vertexFormat.normal) || defined(vertexFormat.tangent) || defined(vertexFormat.bitangent) || defined(vertexFormat.st)) {
|
var normals = defined(vertexFormat.normal) ? new Float32Array(3 * 4 * numberOfPlanes) : undefined;
|
var tangents = defined(vertexFormat.tangent) ? new Float32Array(3 * 4 * numberOfPlanes) : undefined;
|
var bitangents = defined(vertexFormat.bitangent) ? new Float32Array(3 * 4 * numberOfPlanes) : undefined;
|
var st = defined(vertexFormat.st) ? new Float32Array(2 * 4 * numberOfPlanes) : undefined;
|
|
var x = scratchXDirection;
|
var y = scratchYDirection;
|
var z = scratchZDirection;
|
|
var negativeX = Cartesian3.negate(x, scratchNegativeX);
|
var negativeY = Cartesian3.negate(y, scratchNegativeY);
|
var negativeZ = Cartesian3.negate(z, scratchNegativeZ);
|
|
offset = 0;
|
if (drawNearPlane) {
|
getAttributes(offset, normals, tangents, bitangents, st, negativeZ, x, y); // near
|
offset += 3 * 4;
|
}
|
getAttributes(offset, normals, tangents, bitangents, st, z, negativeX, y); // far
|
offset += 3 * 4;
|
getAttributes(offset, normals, tangents, bitangents, st, negativeX, negativeZ, y); // -x
|
offset += 3 * 4;
|
getAttributes(offset, normals, tangents, bitangents, st, negativeY, negativeZ, negativeX); // -y
|
offset += 3 * 4;
|
getAttributes(offset, normals, tangents, bitangents, st, x, z, y); // +x
|
offset += 3 * 4;
|
getAttributes(offset, normals, tangents, bitangents, st, y, z, negativeX); // +y
|
|
if (defined(normals)) {
|
attributes.normal = new GeometryAttribute({
|
componentDatatype : ComponentDatatype.FLOAT,
|
componentsPerAttribute : 3,
|
values : normals
|
});
|
}
|
if (defined(tangents)) {
|
attributes.tangent = new GeometryAttribute({
|
componentDatatype : ComponentDatatype.FLOAT,
|
componentsPerAttribute : 3,
|
values : tangents
|
});
|
}
|
if (defined(bitangents)) {
|
attributes.bitangent = new GeometryAttribute({
|
componentDatatype : ComponentDatatype.FLOAT,
|
componentsPerAttribute : 3,
|
values : bitangents
|
});
|
}
|
if (defined(st)) {
|
attributes.st = new GeometryAttribute({
|
componentDatatype : ComponentDatatype.FLOAT,
|
componentsPerAttribute : 2,
|
values : st
|
});
|
}
|
}
|
|
var indices = new Uint16Array(6 * numberOfPlanes);
|
for (var i = 0; i < numberOfPlanes; ++i) {
|
var indexOffset = i * 6;
|
var index = i * 4;
|
|
indices[indexOffset] = index;
|
indices[indexOffset + 1] = index + 1;
|
indices[indexOffset + 2] = index + 2;
|
indices[indexOffset + 3] = index;
|
indices[indexOffset + 4] = index + 2;
|
indices[indexOffset + 5] = index + 3;
|
}
|
|
return new Geometry({
|
attributes : attributes,
|
indices : indices,
|
primitiveType : PrimitiveType.TRIANGLES,
|
boundingSphere : BoundingSphere.fromVertices(positions)
|
});
|
};
|
export default FrustumGeometry;
|
