780 lines
30 KiB
JavaScript
780 lines
30 KiB
JavaScript
defineSuite([
|
|
'Scene/ClippingPlaneCollection',
|
|
'Core/AttributeCompression',
|
|
'Core/BoundingSphere',
|
|
'Core/Cartesian2',
|
|
'Core/Cartesian3',
|
|
'Core/Cartesian4',
|
|
'Core/Color',
|
|
'Core/Intersect',
|
|
'Core/Math',
|
|
'Core/Matrix4',
|
|
'Core/PixelFormat',
|
|
'Core/Plane',
|
|
'Renderer/PixelDatatype',
|
|
'Renderer/TextureMagnificationFilter',
|
|
'Renderer/TextureMinificationFilter',
|
|
'Renderer/TextureWrap',
|
|
'Scene/ClippingPlane',
|
|
'Specs/createScene'
|
|
], function(
|
|
ClippingPlaneCollection,
|
|
AttributeCompression,
|
|
BoundingSphere,
|
|
Cartesian2,
|
|
Cartesian3,
|
|
Cartesian4,
|
|
Color,
|
|
Intersect,
|
|
CesiumMath,
|
|
Matrix4,
|
|
PixelFormat,
|
|
Plane,
|
|
PixelDatatype,
|
|
TextureMagnificationFilter,
|
|
TextureMinificationFilter,
|
|
TextureWrap,
|
|
ClippingPlane,
|
|
createScene) {
|
|
'use strict';
|
|
|
|
var clippingPlanes;
|
|
var planes = [
|
|
new ClippingPlane(Cartesian3.UNIT_X, 1.0),
|
|
new ClippingPlane(Cartesian3.UNIT_Y, 2.0)
|
|
];
|
|
|
|
var transform = new Matrix4.fromTranslation(new Cartesian3(1.0, 3.0, 2.0));
|
|
var boundingVolume = new BoundingSphere(Cartesian3.ZERO, 1.0);
|
|
|
|
function decodeUint8Plane(pixel1, pixel2) {
|
|
// expect pixel1 to be the normal
|
|
var normal = AttributeCompression.octDecodeFromCartesian4(pixel1, new Cartesian3());
|
|
|
|
// expect pixel2 to be the distance
|
|
var distance = Cartesian4.unpackFloat(pixel2);
|
|
return new Plane(normal, distance);
|
|
}
|
|
|
|
it('default constructor', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
expect(clippingPlanes._planes).toEqual([]);
|
|
expect(clippingPlanes.enabled).toEqual(true);
|
|
expect(clippingPlanes.modelMatrix).toEqual(Matrix4.IDENTITY);
|
|
expect(clippingPlanes.edgeColor).toEqual(Color.WHITE);
|
|
expect(clippingPlanes.edgeWidth).toEqual(0.0);
|
|
expect(clippingPlanes.unionClippingRegions).toEqual(false);
|
|
expect(clippingPlanes._testIntersection).not.toBeUndefined();
|
|
});
|
|
|
|
it('gets the length of the list of planes in the collection', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
|
|
expect(clippingPlanes.length).toBe(0);
|
|
|
|
clippingPlanes._planes = planes.slice();
|
|
|
|
expect(clippingPlanes.length).toBe(2);
|
|
|
|
clippingPlanes._planes.push(new ClippingPlane(Cartesian3.UNIT_Z, -1.0));
|
|
|
|
expect(clippingPlanes.length).toBe(3);
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
expect(clippingPlanes.length).toBe(2);
|
|
});
|
|
|
|
it('add adds a plane to the collection', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
clippingPlanes.add(planes[0]);
|
|
|
|
expect(clippingPlanes.length).toBe(1);
|
|
expect(clippingPlanes._planes[0]).toBe(planes[0]);
|
|
});
|
|
|
|
it('fires the planeAdded event when a plane is added', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
var spy = jasmine.createSpy();
|
|
clippingPlanes.planeAdded.addEventListener(spy);
|
|
clippingPlanes.add(planes[0]);
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('gets the plane at an index', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
var plane = clippingPlanes.get(0);
|
|
expect(plane).toBe(planes[0]);
|
|
|
|
plane = clippingPlanes.get(1);
|
|
expect(plane).toBe(planes[1]);
|
|
|
|
plane = clippingPlanes.get(2);
|
|
expect(plane).toBeUndefined();
|
|
});
|
|
|
|
it('contain checks if the collection contains a plane', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
expect(clippingPlanes.contains(planes[0])).toBe(true);
|
|
expect(clippingPlanes.contains(new ClippingPlane(Cartesian3.UNIT_Y, 2.0))).toBe(true);
|
|
expect(clippingPlanes.contains(new ClippingPlane(Cartesian3.UNIT_Z, 3.0))).toBe(false);
|
|
});
|
|
|
|
it('remove removes and the first occurrence of a plane', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
expect(clippingPlanes.contains(planes[0])).toBe(true);
|
|
|
|
var result = clippingPlanes.remove(planes[0]);
|
|
|
|
expect(clippingPlanes.contains(planes[0])).toBe(false);
|
|
expect(clippingPlanes.length).toBe(1);
|
|
expect(clippingPlanes.get(0)).toEqual(planes[1]);
|
|
expect(result).toBe(true);
|
|
|
|
result = clippingPlanes.remove(planes[0]);
|
|
expect(result).toBe(false);
|
|
});
|
|
|
|
it('remove fires planeRemoved event', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
var spy = jasmine.createSpy();
|
|
clippingPlanes.planeRemoved.addEventListener(spy);
|
|
|
|
clippingPlanes.remove(planes[0]);
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
|
|
it('removeAll removes all of the planes in the collection', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
expect(clippingPlanes.length).toEqual(planes.length);
|
|
|
|
clippingPlanes.removeAll();
|
|
|
|
expect(clippingPlanes.length).toBe(0);
|
|
});
|
|
|
|
it('removeAll fires planeRemoved event', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes
|
|
});
|
|
|
|
var spy = jasmine.createSpy();
|
|
clippingPlanes.planeRemoved.addEventListener(spy);
|
|
|
|
clippingPlanes.removeAll();
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
});
|
|
|
|
describe('uint8 texture mode', function() {
|
|
beforeEach(function() {
|
|
spyOn(ClippingPlaneCollection, 'useFloatTexture').and.returnValue(false);
|
|
});
|
|
|
|
it('update creates a RGBA ubyte texture with no filtering or wrapping to house packed clipping planes', function() {
|
|
var scene = createScene();
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
var packedTexture = clippingPlanes.texture;
|
|
expect(packedTexture).toBeDefined();
|
|
|
|
// Two RGBA uint8 clipping planes consume 4 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(4);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
expect(packedTexture.pixelFormat).toEqual(PixelFormat.RGBA);
|
|
expect(packedTexture.pixelDatatype).toEqual(PixelDatatype.UNSIGNED_BYTE);
|
|
|
|
var sampler = packedTexture.sampler;
|
|
expect(sampler.wrapS).toEqual(TextureWrap.CLAMP_TO_EDGE);
|
|
expect(sampler.wrapT).toEqual(TextureWrap.CLAMP_TO_EDGE);
|
|
expect(sampler.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
|
|
expect(sampler.magnificationFilter).toEqual(TextureMinificationFilter.NEAREST);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('only creates texture when planes are added', function() {
|
|
var scene = createScene();
|
|
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(clippingPlanes.texture).toBeUndefined();
|
|
|
|
clippingPlanes.add(planes[0]);
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(clippingPlanes.texture).toBeDefined();
|
|
expect(isNaN(clippingPlanes.texture.width)).toBe(false);
|
|
expect(isNaN(clippingPlanes.texture.height)).toBe(false);
|
|
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('update fills the clipping plane texture with packed planes', function() {
|
|
var scene = createScene();
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
var rgba;
|
|
var gl = scene.frameState.context._gl;
|
|
spyOn(gl, 'texImage2D').and.callFake(function(target, level, xoffset, yoffset, width, height, format, type, arrayBufferView) {
|
|
rgba = arrayBufferView;
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(rgba).toBeDefined();
|
|
expect(rgba.length).toEqual(32);
|
|
|
|
// Expect two clipping planes to use 4 pixels in the texture, so the first 16 bytes
|
|
for (var i = 16; i < rgba.length; i++) {
|
|
expect(rgba[i]).toEqual(0);
|
|
}
|
|
var pixel1 = Cartesian4.fromArray(rgba, 0);
|
|
var pixel2 = Cartesian4.fromArray(rgba, 4);
|
|
var pixel3 = Cartesian4.fromArray(rgba, 8);
|
|
var pixel4 = Cartesian4.fromArray(rgba, 12);
|
|
|
|
var plane1 = decodeUint8Plane(pixel1, pixel2);
|
|
var plane2 = decodeUint8Plane(pixel3, pixel4);
|
|
|
|
expect(Cartesian3.equalsEpsilon(plane1.normal, planes[0].normal, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(Cartesian3.equalsEpsilon(plane2.normal, planes[1].normal, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(CesiumMath.equalsEpsilon(plane1.distance, planes[0].distance, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(CesiumMath.equalsEpsilon(plane2.distance, planes[1].distance, CesiumMath.EPSILON3)).toEqual(true);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('reallocates textures when above capacity or below 1/4 capacity', function() {
|
|
var scene = createScene();
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
var packedTexture = clippingPlanes.texture;
|
|
|
|
// Two RGBA uint8 clipping planes consume 4 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(4);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
// Reach capacity
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
|
|
// Exceed capacity
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(true);
|
|
packedTexture = clippingPlanes.texture;
|
|
|
|
// Five RGBA uint8 clipping planes consume 10 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(10);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
clippingPlanes.removeAll();
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(true);
|
|
packedTexture = clippingPlanes.texture;
|
|
|
|
// One RGBA uint8 clipping plane consume 2 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(2);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('performs partial updates when only a single plane has changed and full texture updates otherwise', function() {
|
|
var scene = createScene();
|
|
var gl = scene.frameState.context._gl;
|
|
var copyWidth;
|
|
var copyHeight;
|
|
spyOn(gl, 'texSubImage2D').and.callFake(function(target, level, xoffset, yoffset, width, height, format, type, arrayBufferView) {
|
|
copyWidth = width;
|
|
copyHeight = height;
|
|
});
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
// Two RGBA uint8 clipping planes consume 4 pixels of texture, allocation to be double that
|
|
var packedTexture = clippingPlanes.texture;
|
|
expect(packedTexture.width).toEqual(4);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
var targetPlane = new ClippingPlane(Cartesian3.UNIT_X, 1.0);
|
|
clippingPlanes.add(targetPlane);
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
// Haven't hit limit yet
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
|
|
// Addition of two planes, expect a full texture update
|
|
expect(gl.texSubImage2D.calls.count()).toEqual(1);
|
|
expect(copyWidth).toEqual(packedTexture.width);
|
|
expect(copyHeight).toEqual(packedTexture.height);
|
|
|
|
// Move target plane for partial update
|
|
targetPlane.distance += 1.0;
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
expect(gl.texSubImage2D.calls.count()).toEqual(2);
|
|
expect(copyWidth).toEqual(2);
|
|
expect(copyHeight).toEqual(1);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
});
|
|
|
|
describe('float texture mode', function() {
|
|
it('update creates a float texture with no filtering or wrapping to house packed clipping planes', function() {
|
|
var scene = createScene();
|
|
|
|
if (!ClippingPlaneCollection.useFloatTexture(scene.context)) {
|
|
// Don't fail just because float textures aren't supported
|
|
scene.destroyForSpecs();
|
|
return;
|
|
}
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
var packedTexture = clippingPlanes.texture;
|
|
expect(packedTexture).toBeDefined();
|
|
expect(packedTexture.width).toEqual(2);
|
|
expect(packedTexture.height).toEqual(2);
|
|
expect(packedTexture.pixelFormat).toEqual(PixelFormat.RGBA);
|
|
expect(packedTexture.pixelDatatype).toEqual(PixelDatatype.FLOAT);
|
|
|
|
var sampler = packedTexture.sampler;
|
|
expect(sampler.wrapS).toEqual(TextureWrap.CLAMP_TO_EDGE);
|
|
expect(sampler.wrapT).toEqual(TextureWrap.CLAMP_TO_EDGE);
|
|
expect(sampler.minificationFilter).toEqual(TextureMinificationFilter.NEAREST);
|
|
expect(sampler.magnificationFilter).toEqual(TextureMinificationFilter.NEAREST);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('only creates texture when planes are added', function() {
|
|
var scene = createScene();
|
|
|
|
if (!ClippingPlaneCollection.useFloatTexture(scene.context)) {
|
|
// Don't fail just because float textures aren't supported
|
|
scene.destroyForSpecs();
|
|
return;
|
|
}
|
|
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(clippingPlanes.texture).toBeUndefined();
|
|
|
|
clippingPlanes.add(planes[0]);
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(clippingPlanes.texture).toBeDefined();
|
|
expect(isNaN(clippingPlanes.texture.width)).toBe(false);
|
|
expect(isNaN(clippingPlanes.texture.height)).toBe(false);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('update fills the clipping plane texture with packed planes', function() {
|
|
var scene = createScene();
|
|
|
|
if (!ClippingPlaneCollection.useFloatTexture(scene.context)) {
|
|
// Don't fail just because float textures aren't supported
|
|
scene.destroyForSpecs();
|
|
return;
|
|
}
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
var rgba;
|
|
var gl = scene.frameState.context._gl;
|
|
spyOn(gl, 'texImage2D').and.callFake(function(target, level, xoffset, yoffset, width, height, format, type, arrayBufferView) {
|
|
rgba = arrayBufferView;
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(rgba).toBeDefined();
|
|
expect(rgba.length).toEqual(16);
|
|
|
|
// Expect two clipping planes to use 2 pixels in the texture, so the first 8 floats.
|
|
for (var i = 8; i < rgba.length; i++) {
|
|
expect(rgba[i]).toEqual(0);
|
|
}
|
|
var plane1 = Plane.fromCartesian4(Cartesian4.fromArray(rgba, 0));
|
|
var plane2 = Plane.fromCartesian4(Cartesian4.fromArray(rgba, 4));
|
|
|
|
expect(Cartesian3.equalsEpsilon(plane1.normal, planes[0].normal, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(Cartesian3.equalsEpsilon(plane2.normal, planes[1].normal, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(CesiumMath.equalsEpsilon(plane1.distance, planes[0].distance, CesiumMath.EPSILON3)).toEqual(true);
|
|
expect(CesiumMath.equalsEpsilon(plane2.distance, planes[1].distance, CesiumMath.EPSILON3)).toEqual(true);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('reallocates textures when above capacity or below 1/4 capacity', function() {
|
|
var scene = createScene();
|
|
|
|
if (!ClippingPlaneCollection.useFloatTexture(scene.context)) {
|
|
// Don't fail just because float textures aren't supported
|
|
scene.destroyForSpecs();
|
|
return;
|
|
}
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
var packedTexture = clippingPlanes.texture;
|
|
|
|
// Two RGBA float clipping planes consume 2 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(2);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
// Reach capacity
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
|
|
// Exceed capacity
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(true);
|
|
packedTexture = clippingPlanes.texture;
|
|
|
|
// Five RGBA float clipping planes consume 5 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(5);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
clippingPlanes.removeAll();
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(true);
|
|
packedTexture = clippingPlanes.texture;
|
|
|
|
// One RGBA float clipping plane consume 1 pixels of texture, allocation to be double that
|
|
expect(packedTexture.width).toEqual(1);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('performs partial updates when only a single plane has changed and full texture updates otherwise', function() {
|
|
var scene = createScene();
|
|
|
|
if (!ClippingPlaneCollection.useFloatTexture(scene.context)) {
|
|
// Don't fail just because float textures aren't supported
|
|
scene.destroyForSpecs();
|
|
return;
|
|
}
|
|
|
|
var gl = scene.frameState.context._gl;
|
|
var copyWidth;
|
|
var copyHeight;
|
|
spyOn(gl, 'texSubImage2D').and.callFake(function(target, level, xoffset, yoffset, width, height, format, type, arrayBufferView) {
|
|
copyWidth = width;
|
|
copyHeight = height;
|
|
});
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
// Two RGBA Float clipping planes consume 2 pixels of texture, allocation to be double that
|
|
var packedTexture = clippingPlanes.texture;
|
|
expect(packedTexture.width).toEqual(2);
|
|
expect(packedTexture.height).toEqual(2);
|
|
|
|
var targetPlane = new ClippingPlane(Cartesian3.UNIT_X, 1.0);
|
|
clippingPlanes.add(targetPlane);
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 1.0));
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
// Haven't hit limit yet
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
|
|
// Addition of two planes, expect a full texture update
|
|
expect(gl.texSubImage2D.calls.count()).toEqual(1);
|
|
expect(copyWidth).toEqual(packedTexture.width);
|
|
expect(copyHeight).toEqual(packedTexture.height);
|
|
|
|
// Move target plane for partial update
|
|
targetPlane.distance += 1.0;
|
|
clippingPlanes.update(scene.frameState);
|
|
|
|
expect(packedTexture.isDestroyed()).toBe(false);
|
|
expect(gl.texSubImage2D.calls.count()).toEqual(2);
|
|
expect(copyWidth).toEqual(1);
|
|
expect(copyHeight).toEqual(1);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
});
|
|
|
|
it('does not perform texture updates if the planes are unchanged', function() {
|
|
var scene = createScene();
|
|
|
|
var gl = scene.frameState.context._gl;
|
|
spyOn(gl, 'texImage2D').and.callThrough();
|
|
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
expect(gl.texImage2D.calls.count()).toEqual(0);
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(gl.texImage2D.calls.count()).toEqual(2);
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
expect(gl.texImage2D.calls.count()).toEqual(2);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
|
|
it('provides a function for attaching the ClippingPlaneCollection to objects', function() {
|
|
var clippedObject1 = {
|
|
clippingPlanes : undefined
|
|
};
|
|
var clippedObject2 = {
|
|
clippingPlanes : undefined
|
|
};
|
|
|
|
var clippingPlanes1 = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
ClippingPlaneCollection.setOwner(clippingPlanes1, clippedObject1, 'clippingPlanes');
|
|
expect(clippedObject1.clippingPlanes).toBe(clippingPlanes1);
|
|
expect(clippingPlanes1._owner).toBe(clippedObject1);
|
|
|
|
var clippingPlanes2 = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
// Expect detached clipping planes to be destroyed
|
|
ClippingPlaneCollection.setOwner(clippingPlanes2, clippedObject1, 'clippingPlanes');
|
|
expect(clippingPlanes1.isDestroyed()).toBe(true);
|
|
|
|
// Expect setting the same ClippingPlaneCollection again to not destroy the ClippingPlaneCollection
|
|
ClippingPlaneCollection.setOwner(clippingPlanes2, clippedObject1, 'clippingPlanes');
|
|
expect(clippingPlanes2.isDestroyed()).toBe(false);
|
|
|
|
// Expect failure when attaching one ClippingPlaneCollection to two objects
|
|
expect(function() {
|
|
ClippingPlaneCollection.setOwner(clippingPlanes2, clippedObject2, 'clippingPlanes');
|
|
}).toThrowDeveloperError();
|
|
});
|
|
|
|
it('setting unionClippingRegions updates testIntersection function', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
var originalIntersectFunction = clippingPlanes._testIntersection;
|
|
|
|
expect(clippingPlanes._testIntersection).not.toBeUndefined();
|
|
|
|
clippingPlanes.unionClippingRegions = true;
|
|
|
|
expect(clippingPlanes._testIntersection).not.toBe(originalIntersectFunction);
|
|
});
|
|
|
|
it('computes intersections with bounding volumes when clipping regions are combined with an intersect operation', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
|
|
var intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, -2.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.OUTSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_Y, 0.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INTERSECTING);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_Z, 1.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_Z, 0.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
});
|
|
|
|
it('computes intersections with bounding volumes when clipping planes are combined with a union operation', function() {
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
unionClippingRegions : true
|
|
});
|
|
|
|
var intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_Z, 1.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
|
|
var temp = new ClippingPlane(Cartesian3.UNIT_Y, -2.0);
|
|
clippingPlanes.add(temp);
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.OUTSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, 0.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.OUTSIDE);
|
|
|
|
clippingPlanes.remove(temp);
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume);
|
|
expect(intersect).toEqual(Intersect.INTERSECTING);
|
|
});
|
|
|
|
it('compute intersections applies optional transform to planes', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
|
|
var intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume, transform);
|
|
expect(intersect).toEqual(Intersect.INSIDE);
|
|
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, -1.0));
|
|
intersect = clippingPlanes.computeIntersectionWithBoundingVolume(boundingVolume, transform);
|
|
expect(intersect).not.toEqual(Intersect.INSIDE);
|
|
});
|
|
|
|
it('computes a description of the current shader for comparison', function() {
|
|
clippingPlanes = new ClippingPlaneCollection();
|
|
clippingPlanes.add(new ClippingPlane(Cartesian3.UNIT_X, -1.0));
|
|
|
|
expect(clippingPlanes.clippingPlanesState).toEqual(-1);
|
|
|
|
var holdThisPlane = new ClippingPlane(Cartesian3.UNIT_X, -1.0);
|
|
clippingPlanes.add(holdThisPlane);
|
|
expect(clippingPlanes.clippingPlanesState).toEqual(-2);
|
|
|
|
clippingPlanes.unionClippingRegions = true;
|
|
expect(clippingPlanes.clippingPlanesState).toEqual(2);
|
|
|
|
clippingPlanes.remove(holdThisPlane);
|
|
expect(clippingPlanes.clippingPlanesState).toEqual(1);
|
|
});
|
|
|
|
it('provides a function for checking the texture resolution', function() {
|
|
spyOn(ClippingPlaneCollection, 'useFloatTexture').and.returnValue(false);
|
|
|
|
var scene = createScene();
|
|
clippingPlanes = new ClippingPlaneCollection({
|
|
planes : planes,
|
|
enabled : false,
|
|
edgeColor : Color.RED,
|
|
modelMatrix : transform
|
|
});
|
|
|
|
// Predicted resolution before texture has been allocated
|
|
var predictedResolution = ClippingPlaneCollection.getTextureResolution(clippingPlanes, scene.frameState.context, new Cartesian2());
|
|
|
|
expect(predictedResolution.x).toEqual(4);
|
|
expect(predictedResolution.y).toEqual(2);
|
|
|
|
clippingPlanes.update(scene.frameState);
|
|
var actualResolution = ClippingPlaneCollection.getTextureResolution(clippingPlanes, scene.frameState.context, new Cartesian2());
|
|
|
|
expect(predictedResolution.x).toEqual(actualResolution.x);
|
|
expect(predictedResolution.y).toEqual(actualResolution.y);
|
|
|
|
clippingPlanes.destroy();
|
|
scene.destroyForSpecs();
|
|
});
|
|
});
|