3445 lines
126 KiB
JavaScript
3445 lines
126 KiB
JavaScript
|
defineSuite([
|
||
|
|
'Scene/Model',
|
||
|
|
'Core/Cartesian2',
|
||
|
|
'Core/Cartesian3',
|
||
|
|
'Core/Cartesian4',
|
||
|
|
'Core/CesiumTerrainProvider',
|
||
|
|
'Core/Color',
|
||
|
|
'Core/combine',
|
||
|
|
'Core/defaultValue',
|
||
|
|
'Core/defined',
|
||
|
|
'Core/defineProperties',
|
||
|
|
'Core/DistanceDisplayCondition',
|
||
|
|
'Core/Ellipsoid',
|
||
|
|
'Core/Event',
|
||
|
|
'Core/FeatureDetection',
|
||
|
|
'Core/HeadingPitchRange',
|
||
|
|
'Core/JulianDate',
|
||
|
|
'Core/Math',
|
||
|
|
'Core/Matrix3',
|
||
|
|
'Core/Matrix4',
|
||
|
|
'Core/PerspectiveFrustum',
|
||
|
|
'Core/PrimitiveType',
|
||
|
|
'Core/Resource',
|
||
|
|
'Core/Transforms',
|
||
|
|
'Core/WebGLConstants',
|
||
|
|
'Renderer/Pass',
|
||
|
|
'Renderer/RenderState',
|
||
|
|
'Renderer/ShaderSource',
|
||
|
|
'Scene/Axis',
|
||
|
|
'Scene/ClippingPlane',
|
||
|
|
'Scene/ClippingPlaneCollection',
|
||
|
|
'Scene/ColorBlendMode',
|
||
|
|
'Scene/DracoLoader',
|
||
|
|
'Scene/HeightReference',
|
||
|
|
'Scene/ModelAnimationLoop',
|
||
|
|
'Specs/createScene',
|
||
|
|
'Specs/pollToPromise',
|
||
|
|
'ThirdParty/when'
|
||
|
|
], function(
|
||
|
|
Model,
|
||
|
|
Cartesian2,
|
||
|
|
Cartesian3,
|
||
|
|
Cartesian4,
|
||
|
|
CesiumTerrainProvider,
|
||
|
|
Color,
|
||
|
|
combine,
|
||
|
|
defaultValue,
|
||
|
|
defined,
|
||
|
|
defineProperties,
|
||
|
|
DistanceDisplayCondition,
|
||
|
|
Ellipsoid,
|
||
|
|
Event,
|
||
|
|
FeatureDetection,
|
||
|
|
HeadingPitchRange,
|
||
|
|
JulianDate,
|
||
|
|
CesiumMath,
|
||
|
|
Matrix3,
|
||
|
|
Matrix4,
|
||
|
|
PerspectiveFrustum,
|
||
|
|
PrimitiveType,
|
||
|
|
Resource,
|
||
|
|
Transforms,
|
||
|
|
WebGLConstants,
|
||
|
|
Pass,
|
||
|
|
RenderState,
|
||
|
|
ShaderSource,
|
||
|
|
Axis,
|
||
|
|
ClippingPlane,
|
||
|
|
ClippingPlaneCollection,
|
||
|
|
ColorBlendMode,
|
||
|
|
DracoLoader,
|
||
|
|
HeightReference,
|
||
|
|
ModelAnimationLoop,
|
||
|
|
createScene,
|
||
|
|
pollToPromise,
|
||
|
|
when) {
|
||
|
|
'use strict';
|
||
|
|
|
||
|
|
var boxUrl = './Data/Models/Box/CesiumBoxTest.gltf';
|
||
|
|
var boxNoTechniqueUrl = './Data/Models/Box/CesiumBoxTest-NoTechnique.gltf';
|
||
|
|
var boxNoIndicesUrl = './Data/Models/Box-NoIndices/box-noindices.gltf';
|
||
|
|
var texturedBoxUrl = './Data/Models/Box-Textured/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxSeparateUrl = './Data/Models/Box-Textured-Separate/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxBasePathUrl = './Data/Models/Box-Textured-BasePath/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxKTXUrl = './Data/Models/Box-Textured-KTX/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxKTXBinaryUrl = './Data/Models/Box-Textured-KTX-Binary/CesiumTexturedBoxTest.glb';
|
||
|
|
var texturedBoxKTXEmbeddedUrl = './Data/Models/Box-Textured-KTX-Embedded/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxCRNUrl = './Data/Models/Box-Textured-CRN/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxCRNBinaryUrl = './Data/Models/Box-Textured-CRN-Binary/CesiumTexturedBoxTest.glb';
|
||
|
|
var texturedBoxCRNEmbeddedUrl = './Data/Models/Box-Textured-CRN-Embedded/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxCustomUrl = './Data/Models/Box-Textured-Custom/CesiumTexturedBoxTest.gltf';
|
||
|
|
var texturedBoxKhrBinaryUrl = './Data/Models/Box-Textured-Binary/CesiumTexturedBoxTest.glb';
|
||
|
|
var boxRtcUrl = './Data/Models/Box-RTC/Box.gltf';
|
||
|
|
var boxEcefUrl = './Data/Models/Box-ECEF/ecef.gltf';
|
||
|
|
var boxWithUnusedMaterial = './Data/Models/BoxWithUnusedMaterial/Box.gltf';
|
||
|
|
|
||
|
|
var cesiumAirUrl = './Data/Models/CesiumAir/Cesium_Air.gltf';
|
||
|
|
var cesiumAir_0_8Url = './Data/Models/CesiumAir/Cesium_Air_0_8.gltf';
|
||
|
|
var animBoxesUrl = './Data/Models/anim-test-1-boxes/anim-test-1-boxes.gltf';
|
||
|
|
var riggedFigureUrl = './Data/Models/rigged-figure-test/rigged-figure-test.gltf';
|
||
|
|
var riggedSimpleUrl = './Data/Models/rigged-simple/rigged-simple.gltf';
|
||
|
|
var boxConstantUrl = './Data/Models/MaterialsCommon/BoxConstant.gltf';
|
||
|
|
var boxLambertUrl = './Data/Models/MaterialsCommon/BoxLambert.gltf';
|
||
|
|
var boxBlinnUrl = './Data/Models/MaterialsCommon/BoxBlinn.gltf';
|
||
|
|
var boxPhongUrl = './Data/Models/MaterialsCommon/BoxPhong.gltf';
|
||
|
|
var boxNoLightUrl = './Data/Models/MaterialsCommon/BoxNoLight.gltf';
|
||
|
|
var boxAmbientLightUrl = './Data/Models/MaterialsCommon/BoxAmbientLight.gltf';
|
||
|
|
var boxDirectionalLightUrl = './Data/Models/MaterialsCommon/BoxDirectionalLight.gltf';
|
||
|
|
var boxPointLightUrl = './Data/Models/MaterialsCommon/BoxPointLight.gltf';
|
||
|
|
var boxSpotLightUrl = './Data/Models/MaterialsCommon/BoxSpotLight.gltf';
|
||
|
|
var boxTransparentUrl = './Data/Models/MaterialsCommon/BoxTransparent.gltf';
|
||
|
|
var boxColorUrl = './Data/Models/Box-Color/Box-Color.gltf';
|
||
|
|
var boxUint32Indices = './Data/Models/Box-Uint32Indices/Box-Uint32Indices.gltf';
|
||
|
|
var boxQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/Box-Quantized.gltf';
|
||
|
|
var boxColorQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/Box-Color-Quantized.gltf';
|
||
|
|
var boxScalarQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/Box-Scalar-Quantized.gltf';
|
||
|
|
var milkTruckQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/CesiumMilkTruck-Quantized.gltf';
|
||
|
|
var milkTruckQuantizedMismatchUrl = './Data/Models/WEB3DQuantizedAttributes/CesiumMilkTruck-Mismatch-Quantized.gltf';
|
||
|
|
var duckQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/Duck-Quantized.gltf';
|
||
|
|
var riggedSimpleQuantizedUrl = './Data/Models/WEB3DQuantizedAttributes/RiggedSimple-Quantized.gltf';
|
||
|
|
var CesiumManUrl = './Data/Models/MaterialsCommon/Cesium_Man.gltf';
|
||
|
|
|
||
|
|
var boomBoxUrl = './Data/Models/PBR/BoomBox/BoomBox.gltf';
|
||
|
|
var boomBoxPbrSpecularGlossinessUrl = './Data/Models/PBR/BoomBoxSpecularGlossiness/BoomBox.gltf';
|
||
|
|
var boomBoxPbrSpecularGlossinessDefaultsUrl = './Data/Models/PBR/BoomBoxSpecularGlossiness/BoomBox-Default.gltf';
|
||
|
|
var boomBoxPbrSpecularGlossinessNoTextureUrl = './Data/Models/PBR/BoomBoxSpecularGlossiness/BoomBox-NoTexture.gltf';
|
||
|
|
var boxPbrUrl = './Data/Models/PBR/Box/Box.gltf';
|
||
|
|
var boxPbrUnlitUrl = './Data/Models/PBR/BoxUnlit/BoxUnlit.gltf';
|
||
|
|
var boxAnimatedPbrUrl = './Data/Models/PBR/BoxAnimated/BoxAnimated.gltf';
|
||
|
|
var boxInterleavedPbrUrl = './Data/Models/PBR/BoxInterleaved/BoxInterleaved.gltf';
|
||
|
|
var riggedSimplePbrUrl = './Data/Models/PBR/RiggedSimple/RiggedSimple.gltf';
|
||
|
|
var animatedMorphCubeUrl = './Data/Models/PBR/AnimatedMorphCube/AnimatedMorphCube.gltf';
|
||
|
|
var twoSidedPlaneUrl = './Data/Models/PBR/TwoSidedPlane/TwoSidedPlane.gltf';
|
||
|
|
var vertexColorTestUrl = './Data/Models/PBR/VertexColorTest/VertexColorTest.gltf';
|
||
|
|
var emissiveUrl = './Data/Models/PBR/BoxEmissive/BoxEmissive.gltf';
|
||
|
|
var dracoCompressedModelUrl = './Data/Models/DracoCompression/CesiumMilkTruck/CesiumMilkTruck.gltf';
|
||
|
|
var dracoCompressedModelWithAnimationUrl = './Data/Models/DracoCompression/CesiumMan/CesiumMan.gltf';
|
||
|
|
|
||
|
|
var boxGltf2Url = './Data/Models/Box-Gltf-2/Box.gltf';
|
||
|
|
var boxGltf2WithTechniquesUrl = './Data/Models/Box-Gltf-2-Techniques/Box.gltf';
|
||
|
|
|
||
|
|
var texturedBoxModel;
|
||
|
|
var cesiumAirModel;
|
||
|
|
var animBoxesModel;
|
||
|
|
var riggedFigureModel;
|
||
|
|
|
||
|
|
var scene;
|
||
|
|
var primitives;
|
||
|
|
|
||
|
|
beforeAll(function() {
|
||
|
|
scene = createScene();
|
||
|
|
primitives = scene.primitives;
|
||
|
|
|
||
|
|
var modelPromises = [];
|
||
|
|
modelPromises.push(loadModel(texturedBoxUrl).then(function(model) {
|
||
|
|
texturedBoxModel = model;
|
||
|
|
}));
|
||
|
|
modelPromises.push(loadModel(cesiumAirUrl, {
|
||
|
|
minimumPixelSize : 1,
|
||
|
|
maximumScale : 200,
|
||
|
|
asynchronous : false
|
||
|
|
}).then(function(model) {
|
||
|
|
cesiumAirModel = model;
|
||
|
|
}));
|
||
|
|
modelPromises.push(loadModel(animBoxesUrl, {
|
||
|
|
scale : 2.0
|
||
|
|
}).then(function(model) {
|
||
|
|
animBoxesModel = model;
|
||
|
|
}));
|
||
|
|
modelPromises.push(loadModel(riggedFigureUrl).then(function(model) {
|
||
|
|
riggedFigureModel = model;
|
||
|
|
}));
|
||
|
|
|
||
|
|
return when.all(modelPromises);
|
||
|
|
});
|
||
|
|
|
||
|
|
afterAll(function() {
|
||
|
|
scene.destroyForSpecs();
|
||
|
|
});
|
||
|
|
|
||
|
|
beforeEach(function() {
|
||
|
|
scene.morphTo3D(0.0);
|
||
|
|
|
||
|
|
var camera = scene.camera;
|
||
|
|
camera.frustum = new PerspectiveFrustum();
|
||
|
|
camera.frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
||
|
|
camera.frustum.fov = CesiumMath.toRadians(60.0);
|
||
|
|
});
|
||
|
|
|
||
|
|
function addZoomTo(model) {
|
||
|
|
model.zoomTo = function(zoom) {
|
||
|
|
zoom = defaultValue(zoom, 4.0);
|
||
|
|
|
||
|
|
var camera = scene.camera;
|
||
|
|
var center = Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cartesian3());
|
||
|
|
var r = zoom * Math.max(model.boundingSphere.radius, camera.frustum.near);
|
||
|
|
camera.lookAt(center, new HeadingPitchRange(0.0, 0.0, r));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function loadModel(url, options) {
|
||
|
|
options = combine(options, {
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
url : url,
|
||
|
|
id : url,
|
||
|
|
show : false
|
||
|
|
});
|
||
|
|
|
||
|
|
var model = primitives.add(Model.fromGltf(options));
|
||
|
|
addZoomTo(model);
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
return model.ready;
|
||
|
|
}, { timeout: 10000 }).then(function() {
|
||
|
|
return model;
|
||
|
|
}).otherwise(function() {
|
||
|
|
return when.reject(model);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
function loadModelJson(gltf, options) {
|
||
|
|
options = defaultValue(options, defaultValue.EMPTY_OBJECT);
|
||
|
|
options = combine(options, {
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
gltf : gltf,
|
||
|
|
show : defaultValue(options.show, false)
|
||
|
|
});
|
||
|
|
|
||
|
|
var model = primitives.add(new Model(options));
|
||
|
|
addZoomTo(model);
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
return model.ready;
|
||
|
|
}, { timeout: 10000 }).then(function() {
|
||
|
|
return model;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
function verifyRender(model) {
|
||
|
|
expect(model.ready).toBe(true);
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
expect(scene).notToRender([0, 0, 0, 255]);
|
||
|
|
model.show = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
it('fromGltf throws without options', function() {
|
||
|
|
expect(function() {
|
||
|
|
Model.fromGltf();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('fromGltf throws without options.url', function() {
|
||
|
|
expect(function() {
|
||
|
|
Model.fromGltf({});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('sets model properties', function() {
|
||
|
|
var modelMatrix = Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0));
|
||
|
|
|
||
|
|
expect(texturedBoxModel.gltf).toBeDefined();
|
||
|
|
expect(texturedBoxModel.basePath).toEqual('./Data/Models/Box-Textured/CesiumTexturedBoxTest.gltf');
|
||
|
|
expect(texturedBoxModel.show).toEqual(false);
|
||
|
|
expect(texturedBoxModel.modelMatrix).toEqual(modelMatrix);
|
||
|
|
expect(texturedBoxModel.scale).toEqual(1.0);
|
||
|
|
expect(texturedBoxModel.minimumPixelSize).toEqual(0.0);
|
||
|
|
expect(texturedBoxModel.maximumScale).toBeUndefined();
|
||
|
|
expect(texturedBoxModel.id).toEqual(texturedBoxUrl);
|
||
|
|
expect(texturedBoxModel.allowPicking).toEqual(true);
|
||
|
|
expect(texturedBoxModel.activeAnimations).toBeDefined();
|
||
|
|
expect(texturedBoxModel.ready).toEqual(true);
|
||
|
|
expect(texturedBoxModel.asynchronous).toEqual(true);
|
||
|
|
expect(texturedBoxModel.releaseGltfJson).toEqual(false);
|
||
|
|
expect(texturedBoxModel.cacheKey).toBeDefined();
|
||
|
|
expect(texturedBoxModel.cacheKey).not.toContain('Data/Models/Box-Textured/CesiumTexturedBoxTest.gltf');
|
||
|
|
expect(texturedBoxModel.debugShowBoundingVolume).toEqual(false);
|
||
|
|
expect(texturedBoxModel.debugWireframe).toEqual(false);
|
||
|
|
expect(texturedBoxModel.distanceDisplayCondition).toBeUndefined();
|
||
|
|
expect(texturedBoxModel.silhouetteColor).toEqual(Color.RED);
|
||
|
|
expect(texturedBoxModel.silhouetteSize).toEqual(0.0);
|
||
|
|
expect(texturedBoxModel.color).toEqual(Color.WHITE);
|
||
|
|
expect(texturedBoxModel.colorBlendMode).toEqual(ColorBlendMode.HIGHLIGHT);
|
||
|
|
expect(texturedBoxModel.colorBlendAmount).toEqual(0.5);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('preserves query string in url', function() {
|
||
|
|
var params = '?param1=1¶m2=2';
|
||
|
|
var url = texturedBoxUrl + params;
|
||
|
|
var model = Model.fromGltf({
|
||
|
|
url: url
|
||
|
|
});
|
||
|
|
expect(model.basePath).toEndWith(params);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('fromGltf takes a base path', function() {
|
||
|
|
var url = texturedBoxBasePathUrl;
|
||
|
|
var basePath = './Data/Models/Box-Textured-Separate/';
|
||
|
|
var model = Model.fromGltf({
|
||
|
|
url: url,
|
||
|
|
basePath: basePath
|
||
|
|
});
|
||
|
|
expect(model.basePath).toEndWith(basePath);
|
||
|
|
expect(model._cacheKey).toEndWith(basePath);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('fromGltf takes Resource as url and basePath parameters', function() {
|
||
|
|
spyOn(Resource._Implementations, 'loadWithXhr').and.callThrough();
|
||
|
|
|
||
|
|
var url = new Resource({
|
||
|
|
url: texturedBoxUrl
|
||
|
|
});
|
||
|
|
var basePath = new Resource({
|
||
|
|
url: './Data/Models/Box-Textured-Separate/'
|
||
|
|
});
|
||
|
|
var model = Model.fromGltf({
|
||
|
|
url: url,
|
||
|
|
basePath: basePath
|
||
|
|
});
|
||
|
|
expect(model._resource).toEqual(basePath);
|
||
|
|
expect(Resource._Implementations.loadWithXhr.calls.argsFor(0)[0]).toEqual(url.url);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders', function() {
|
||
|
|
verifyRender(texturedBoxModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders in CV', function() {
|
||
|
|
scene.morphToColumbusView(0.0);
|
||
|
|
verifyRender(texturedBoxModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders in 2D', function() {
|
||
|
|
scene.morphTo2D(0.0);
|
||
|
|
verifyRender(texturedBoxModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders in 2D over the IDL', function() {
|
||
|
|
return when(loadModel(texturedBoxUrl)).then(function(model) {
|
||
|
|
model.modelMatrix = Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(180.0, 0.0, 100.0));
|
||
|
|
scene.morphTo2D(0.0);
|
||
|
|
verifyRender(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders RTC in 2D', function() {
|
||
|
|
return loadModel(boxRtcUrl, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
minimumPixelSize : 1
|
||
|
|
}).then(function(m) {
|
||
|
|
scene.morphTo2D(0.0);
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders ECEF in 2D', function() {
|
||
|
|
return loadModel(boxEcefUrl, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
minimumPixelSize : undefined
|
||
|
|
}).then(function(m) {
|
||
|
|
scene.morphTo2D(0.0);
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders RTC in CV', function() {
|
||
|
|
return loadModel(boxRtcUrl, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
minimumPixelSize : 1
|
||
|
|
}).then(function(m) {
|
||
|
|
scene.morphToColumbusView(0.0);
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders ECEF in CV', function() {
|
||
|
|
return loadModel(boxEcefUrl, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
minimumPixelSize : undefined
|
||
|
|
}).then(function(m) {
|
||
|
|
scene.morphToColumbusView(0.0);
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('does not render during morph', function() {
|
||
|
|
var commandList = scene.frameState.commandList;
|
||
|
|
var model = texturedBoxModel;
|
||
|
|
model.show = true;
|
||
|
|
model.cull = false;
|
||
|
|
expect(model.ready).toBe(true);
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commandList.length).toBeGreaterThan(0);
|
||
|
|
|
||
|
|
scene.morphTo2D(1.0);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commandList.length).toBe(0);
|
||
|
|
scene.completeMorph();
|
||
|
|
model.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders x-up model', function() {
|
||
|
|
return Resource.fetchJson(boxEcefUrl).then(function(gltf) {
|
||
|
|
// Model data is z-up. Edit the transform to be z-up to x-up.
|
||
|
|
gltf.nodes.node_transform.matrix = Matrix4.pack(Axis.Z_UP_TO_X_UP, new Array(16));
|
||
|
|
|
||
|
|
return loadModelJson(gltf, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
upAxis : Axis.X
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.upAxis).toBe(Axis.X);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders y-up model', function() {
|
||
|
|
return Resource.fetchJson(boxEcefUrl).then(function(gltf) {
|
||
|
|
// Model data is z-up. Edit the transform to be z-up to y-up.
|
||
|
|
gltf.nodes.node_transform.matrix = Matrix4.pack(Axis.Z_UP_TO_Y_UP, new Array(16));
|
||
|
|
|
||
|
|
return loadModelJson(gltf, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
upAxis : Axis.Y
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.upAxis).toBe(Axis.Y);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders z-up model', function() {
|
||
|
|
return Resource.fetchJson(boxEcefUrl).then(function(gltf) {
|
||
|
|
// Model data is z-up. Edit the transform to be the identity.
|
||
|
|
gltf.nodes.node_transform.matrix = Matrix4.pack(Matrix4.IDENTITY, new Array(16));
|
||
|
|
|
||
|
|
return loadModelJson(gltf, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
upAxis : Axis.Z
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.upAxis).toBe(Axis.Z);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders x-forward model', function() {
|
||
|
|
return Resource.fetchJson(boxPbrUrl).then(function(gltf) {
|
||
|
|
return loadModelJson(gltf, {
|
||
|
|
forwardAxis : Axis.X
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.forwardAxis).toBe(Axis.X);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders z-forward model', function() {
|
||
|
|
return Resource.fetchJson(boxEcefUrl).then(function(gltf) {
|
||
|
|
return loadModelJson(gltf, {
|
||
|
|
forwardAxis : Axis.Z
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.forwardAxis).toBe(Axis.Z);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('detects glTF 1.0 models as x-forward', function() {
|
||
|
|
return Resource.fetchJson(boxEcefUrl).then(function(gltf) {
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.forwardAxis).toBe(Axis.X);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('detects glTF 2.0 models as z-forward', function() {
|
||
|
|
return Resource.fetchJson(boxPbrUrl).then(function(gltf) {
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(m.forwardAxis).toBe(Axis.Z);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('resolves readyPromise', function() {
|
||
|
|
return texturedBoxModel.readyPromise.then(function(model) {
|
||
|
|
verifyRender(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('rejects readyPromise on error', function() {
|
||
|
|
return Resource.fetchJson(boomBoxUrl).then(function(gltf) {
|
||
|
|
gltf.images[0].uri = 'invalid.png';
|
||
|
|
var model = primitives.add(new Model({
|
||
|
|
gltf : gltf
|
||
|
|
}));
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
return model.readyPromise.then(function(model) {
|
||
|
|
fail('should not resolve');
|
||
|
|
}).otherwise(function(error) {
|
||
|
|
expect(model.ready).toEqual(false);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders from glTF', function() {
|
||
|
|
// Simulate using procedural glTF as opposed to loading it from a file
|
||
|
|
return loadModelJson(texturedBoxModel.gltf).then(function(model) {
|
||
|
|
verifyRender(model);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Applies the right render state', function() {
|
||
|
|
spyOn(RenderState, 'fromCache').and.callThrough();
|
||
|
|
|
||
|
|
// Simulate using procedural glTF as opposed to loading it from a file
|
||
|
|
return loadModelJson(texturedBoxModel.gltf).then(function(model) {
|
||
|
|
var rs = {
|
||
|
|
cull : {
|
||
|
|
enabled : true
|
||
|
|
},
|
||
|
|
depthTest : {
|
||
|
|
enabled : true
|
||
|
|
},
|
||
|
|
depthMask : true,
|
||
|
|
blending : {
|
||
|
|
enabled : false,
|
||
|
|
equationRgb : WebGLConstants.FUNC_ADD,
|
||
|
|
equationAlpha : WebGLConstants.FUNC_ADD,
|
||
|
|
functionSourceRgb : WebGLConstants.ONE,
|
||
|
|
functionSourceAlpha : WebGLConstants.ONE,
|
||
|
|
functionDestinationRgb : WebGLConstants.ONE_MINUS_SRC_ALPHA,
|
||
|
|
functionDestinationAlpha : WebGLConstants.ONE_MINUS_SRC_ALPHA
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
expect(RenderState.fromCache).toHaveBeenCalledWith(rs);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders bounding volume', function() {
|
||
|
|
texturedBoxModel.debugShowBoundingVolume = true;
|
||
|
|
verifyRender(texturedBoxModel);
|
||
|
|
texturedBoxModel.debugShowBoundingVolume = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders in wireframe', function() {
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
texturedBoxModel.show = true;
|
||
|
|
texturedBoxModel.debugWireframe = true;
|
||
|
|
texturedBoxModel.zoomTo();
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
var commands = texturedBoxModel._nodeCommands;
|
||
|
|
var length = commands.length;
|
||
|
|
for (var i = 0; i < length; ++i) {
|
||
|
|
expect(commands[i].command.primitiveType).toEqual(PrimitiveType.LINES);
|
||
|
|
}
|
||
|
|
|
||
|
|
texturedBoxModel.show = false;
|
||
|
|
texturedBoxModel.debugWireframe = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with distance display condition', function() {
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
var center = Matrix4.getTranslation(texturedBoxModel.modelMatrix, new Cartesian3());
|
||
|
|
var near = 10.0;
|
||
|
|
var far = 100.0;
|
||
|
|
|
||
|
|
texturedBoxModel.show = true;
|
||
|
|
texturedBoxModel.distanceDisplayCondition = new DistanceDisplayCondition(near, far);
|
||
|
|
|
||
|
|
var frameState = scene.frameState;
|
||
|
|
var commands = frameState.commandList;
|
||
|
|
|
||
|
|
frameState.camera.lookAt(center, new HeadingPitchRange(0.0, 0.0, far + 10.0));
|
||
|
|
frameState.camera.lookAtTransform(Matrix4.IDENTITY);
|
||
|
|
frameState.commandList = [];
|
||
|
|
texturedBoxModel.update(frameState);
|
||
|
|
expect(frameState.commandList.length).toEqual(0);
|
||
|
|
|
||
|
|
frameState.camera.lookAt(center, new HeadingPitchRange(0.0, 0.0, (far + near) * 0.5));
|
||
|
|
frameState.camera.lookAtTransform(Matrix4.IDENTITY);
|
||
|
|
frameState.commandList = [];
|
||
|
|
texturedBoxModel.update(frameState);
|
||
|
|
expect(frameState.commandList.length).toBeGreaterThan(0);
|
||
|
|
|
||
|
|
frameState.camera.lookAt(center, new HeadingPitchRange(0.0, 0.0, near - 1.0));
|
||
|
|
frameState.camera.lookAtTransform(Matrix4.IDENTITY);
|
||
|
|
frameState.commandList = [];
|
||
|
|
texturedBoxModel.update(frameState);
|
||
|
|
expect(frameState.commandList.length).toEqual(0);
|
||
|
|
|
||
|
|
scene.frameState.commandList = commands;
|
||
|
|
texturedBoxModel.show = false;
|
||
|
|
texturedBoxModel.distanceDisplayCondition = undefined;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with spherical harmonics', function() {
|
||
|
|
if (!scene.highDynamicRangeSupported) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
return loadModel(boomBoxUrl).then(function(m) {
|
||
|
|
m.scale = 20.0; // Source model is very small, so scale up a bit
|
||
|
|
|
||
|
|
var L00 = new Cartesian3( 0.692622075009195, 0.454351600181900, 0.369101722992350); // L00, irradiance, pre-scaled base
|
||
|
|
var L1_1 = new Cartesian3( 0.289407068366422, 0.167893101626580, 0.106174907004792); // L1-1, irradiance, pre-scaled base
|
||
|
|
var L10 = new Cartesian3(-0.591502034778913, -0.281524323171190, 0.124647554708491); // L10, irradiance, pre-scaled base
|
||
|
|
var L11 = new Cartesian3( 0.349454581171260, 0.163273486841657, -0.030956435452070); // L11, irradiance, pre-scaled base
|
||
|
|
var L2_2 = new Cartesian3( 0.221711764474260, 0.117719918681220, 0.031381053430064); // L2-2, irradiance, pre-scaled base
|
||
|
|
var L2_1 = new Cartesian3(-0.348955284677868, -0.187256994042823, -0.026299717727617); // L2-1, irradiance, pre-scaled base
|
||
|
|
var L20 = new Cartesian3( 0.119982671127227, 0.076784552175028, 0.055517838847755); // L20, irradiance, pre-scaled base
|
||
|
|
var L21 = new Cartesian3(-0.545546043202299, -0.279787444030397, -0.086854000285261); // L21, irradiance, pre-scaled base
|
||
|
|
var L22 = new Cartesian3( 0.160417569726332, 0.120896423762313, 0.121102528320197); // L22, irradiance, pre-scaled base
|
||
|
|
m.sphericalHarmonicCoefficients = [L00, L1_1, L10, L11, L2_2, L2_1, L20, L21, L22];
|
||
|
|
|
||
|
|
scene.highDynamicRange = true;
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
scene.highDynamicRange = false;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with specular environment map', function() {
|
||
|
|
if (!scene.highDynamicRangeSupported) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
return loadModel(boomBoxUrl).then(function(m) {
|
||
|
|
m.scale = 20.0; // Source model is very small, so scale up a bit
|
||
|
|
m.specularEnvironmentMaps = './Data/EnvironmentMap/kiara_6_afternoon_2k_ibl.ktx';
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
scene.highDynamicRange = true;
|
||
|
|
scene.render();
|
||
|
|
scene.highDynamicRange = false;
|
||
|
|
return defined(m._specularEnvironmentMapAtlas) && m._specularEnvironmentMapAtlas.ready;
|
||
|
|
}).then(function() {
|
||
|
|
scene.highDynamicRange = true;
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
scene.highDynamicRange = false;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('distanceDisplayCondition throws when ner >= far', function() {
|
||
|
|
expect(function() {
|
||
|
|
texturedBoxModel.distanceDisplayCondition = new DistanceDisplayCondition(100.0, 10.0);
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getNode throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.getNode('gltf-node-name');
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getNode throws when name is not provided', function() {
|
||
|
|
expect(function() {
|
||
|
|
return texturedBoxModel.getNode();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getNode returns undefined when node does not exist', function() {
|
||
|
|
expect(texturedBoxModel.getNode('name-of-node-that-does-not-exist')).not.toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getNode returns a node', function() {
|
||
|
|
var node = texturedBoxModel.getNode('Mesh');
|
||
|
|
expect(node).toBeDefined();
|
||
|
|
expect(node.name).toEqual('Mesh');
|
||
|
|
expect(node.id).toEqual(0);
|
||
|
|
expect(node.show).toEqual(true);
|
||
|
|
|
||
|
|
// Change node transform and render
|
||
|
|
expect(texturedBoxModel._cesiumAnimationsDirty).toEqual(false);
|
||
|
|
node.matrix = Matrix4.fromUniformScale(1.01, new Matrix4());
|
||
|
|
expect(texturedBoxModel._cesiumAnimationsDirty).toEqual(true);
|
||
|
|
|
||
|
|
verifyRender(texturedBoxModel);
|
||
|
|
|
||
|
|
expect(texturedBoxModel._cesiumAnimationsDirty).toEqual(false);
|
||
|
|
|
||
|
|
node.matrix = Matrix4.fromUniformScale(1.0, new Matrix4());
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMesh throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.getMesh('gltf-mesh-name');
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMesh throws when name is not provided', function() {
|
||
|
|
expect(function() {
|
||
|
|
return texturedBoxModel.getMesh();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMesh returns undefined when mesh does not exist', function() {
|
||
|
|
expect(texturedBoxModel.getMesh('name-of-mesh-that-does-not-exist')).not.toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMesh returns a mesh', function() {
|
||
|
|
var mesh = texturedBoxModel.getMesh('Mesh');
|
||
|
|
expect(mesh).toBeDefined();
|
||
|
|
expect(mesh.name).toEqual('Mesh');
|
||
|
|
expect(mesh.id).toEqual(0);
|
||
|
|
expect(mesh.materials[0].name).toEqual('Texture');
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMaterial throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.getMaterial('gltf-material-name');
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMaterial throws when name is not provided', function() {
|
||
|
|
expect(function() {
|
||
|
|
return texturedBoxModel.getMaterial();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMaterial returns undefined when mesh does not exist', function() {
|
||
|
|
expect(texturedBoxModel.getMaterial('name-of-material-that-does-not-exist')).not.toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('getMaterial returns a material', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
expect(material).toBeDefined();
|
||
|
|
expect(material.name).toEqual('Texture');
|
||
|
|
expect(material.id).toEqual(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('ModelMaterial.setValue throws when name is not provided', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
expect(function() {
|
||
|
|
material.setValue();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('ModelMaterial.setValue sets a scalar uniform value', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
material.setValue('shininess', 12.34);
|
||
|
|
expect(material.getValue('shininess')).toEqual(12.34);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('ModelMaterial.setValue sets a Cartesian4 uniform value', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
var specular = new Cartesian4(0.25, 0.5, 0.75, 1.0);
|
||
|
|
material.setValue('specular', specular);
|
||
|
|
expect(material.getValue('specular')).toEqual(specular);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('ModelMaterial.getValue throws when name is not provided', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
expect(function() {
|
||
|
|
material.getValue();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('ModelMaterial.getValue returns undefined when uniform value does not exist', function() {
|
||
|
|
var material = texturedBoxModel.getMaterial('Texture');
|
||
|
|
expect(material.getValue('name-of-parameter-that-does-not-exist')).not.toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('boundingSphere throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.boundingSphere;
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('boundingSphere returns the bounding sphere', function() {
|
||
|
|
var boundingSphere = texturedBoxModel.boundingSphere;
|
||
|
|
expect(boundingSphere.center).toEqualEpsilon(new Cartesian3(0.0, 0.0, 0.0), CesiumMath.EPSILON3);
|
||
|
|
expect(boundingSphere.radius).toEqualEpsilon(0.866, CesiumMath.EPSILON3);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('boundingSphere returns the bounding sphere when scale property is set', function() {
|
||
|
|
var originalScale = texturedBoxModel.scale;
|
||
|
|
texturedBoxModel.scale = 10;
|
||
|
|
|
||
|
|
var boundingSphere = texturedBoxModel.boundingSphere;
|
||
|
|
expect(boundingSphere.center).toEqualEpsilon(new Cartesian3(0.0, 0.0, 0.0), CesiumMath.EPSILON3);
|
||
|
|
expect(boundingSphere.radius).toEqualEpsilon(8.66, CesiumMath.EPSILON3);
|
||
|
|
|
||
|
|
texturedBoxModel.scale = originalScale;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('boundingSphere returns the bounding sphere when maximumScale is reached', function() {
|
||
|
|
var originalScale = texturedBoxModel.scale;
|
||
|
|
var originalMaximumScale = texturedBoxModel.maximumScale;
|
||
|
|
texturedBoxModel.scale = 20;
|
||
|
|
texturedBoxModel.maximumScale = 10;
|
||
|
|
|
||
|
|
var boundingSphere = texturedBoxModel.boundingSphere;
|
||
|
|
expect(boundingSphere.center).toEqualEpsilon(new Cartesian3(0.0, 0.0, 0.0), CesiumMath.EPSILON3);
|
||
|
|
expect(boundingSphere.radius).toEqualEpsilon(8.66, CesiumMath.EPSILON3);
|
||
|
|
|
||
|
|
texturedBoxModel.scale = originalScale;
|
||
|
|
texturedBoxModel.maximumScale = originalMaximumScale;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('boundingSphere returns the bounding sphere when modelMatrix has non-uniform scale', function() {
|
||
|
|
var originalMatrix = Matrix4.clone(texturedBoxModel.modelMatrix);
|
||
|
|
Matrix4.multiplyByScale(texturedBoxModel.modelMatrix, new Cartesian3(2, 5, 10), texturedBoxModel.modelMatrix);
|
||
|
|
|
||
|
|
var boundingSphere = texturedBoxModel.boundingSphere;
|
||
|
|
expect(boundingSphere.center).toEqualEpsilon(new Cartesian3(0.0, 0.0, 0.0), CesiumMath.EPSILON3);
|
||
|
|
expect(boundingSphere.radius).toEqualEpsilon(8.66, CesiumMath.EPSILON3);
|
||
|
|
|
||
|
|
texturedBoxModel.modelMatrix = originalMatrix;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('destroys', function() {
|
||
|
|
return loadModel(boxUrl).then(function(m) {
|
||
|
|
expect(m.isDestroyed()).toEqual(false);
|
||
|
|
primitives.remove(m);
|
||
|
|
expect(m.isDestroyed()).toEqual(true);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('destroys attached ClippingPlaneCollections', function() {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
var clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
]
|
||
|
|
});
|
||
|
|
model.clippingPlanes = clippingPlanes;
|
||
|
|
expect(model.isDestroyed()).toEqual(false);
|
||
|
|
expect(clippingPlanes.isDestroyed()).toEqual(false);
|
||
|
|
primitives.remove(model);
|
||
|
|
expect(model.isDestroyed()).toEqual(true);
|
||
|
|
expect(clippingPlanes.isDestroyed()).toEqual(true);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('throws a DeveloperError when given a ClippingPlaneCollection attached to another Model', function() {
|
||
|
|
var clippingPlanes;
|
||
|
|
return loadModel(boxUrl).then(function(model1) {
|
||
|
|
clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
]
|
||
|
|
});
|
||
|
|
model1.clippingPlanes = clippingPlanes;
|
||
|
|
|
||
|
|
return loadModel(boxUrl);
|
||
|
|
})
|
||
|
|
.then(function(model2) {
|
||
|
|
expect(function() {
|
||
|
|
model2.clippingPlanes = clippingPlanes;
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('destroys ClippingPlaneCollections that are detached', function() {
|
||
|
|
var clippingPlanes;
|
||
|
|
return loadModel(boxUrl).then(function(model1) {
|
||
|
|
clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
]
|
||
|
|
});
|
||
|
|
model1.clippingPlanes = clippingPlanes;
|
||
|
|
expect(clippingPlanes.isDestroyed()).toBe(false);
|
||
|
|
|
||
|
|
model1.clippingPlanes = undefined;
|
||
|
|
expect(clippingPlanes.isDestroyed()).toBe(true);
|
||
|
|
|
||
|
|
primitives.remove(model1);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('rebuilds shaders when clipping planes change state', function() {
|
||
|
|
spyOn(Model, '_getClippingFunction').and.callThrough();
|
||
|
|
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
|
||
|
|
var clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
],
|
||
|
|
unionClippingRegions : false
|
||
|
|
});
|
||
|
|
model.clippingPlanes = clippingPlanes;
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(Model._getClippingFunction.calls.count()).toEqual(1);
|
||
|
|
|
||
|
|
clippingPlanes.unionClippingRegions = true;
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(Model._getClippingFunction.calls.count()).toEqual(2);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('rebuilds shaders when color requires coloring shader code', function() {
|
||
|
|
spyOn(Model, '_modifyShaderForColor').and.callThrough();
|
||
|
|
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
|
||
|
|
model.color = Color.LIME;
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(Model._modifyShaderForColor.calls.count()).toEqual(1);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
it('Throws because of invalid extension', function() {
|
||
|
|
return Resource.fetchJson(boxUrl).then(function(gltf) {
|
||
|
|
gltf.extensionsRequired = ['NOT_supported_extension'];
|
||
|
|
var model = primitives.add(new Model({
|
||
|
|
gltf : gltf
|
||
|
|
}));
|
||
|
|
|
||
|
|
expect(function() {
|
||
|
|
scene.renderForSpecs();
|
||
|
|
}).toThrowRuntimeError();
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Throws because of invalid extension', function() {
|
||
|
|
return Resource.fetchJson(boxUrl).then(function(gltf) {
|
||
|
|
gltf.extensionsRequired = ['CESIUM_binary_glTF'];
|
||
|
|
var model = primitives.add(new Model({
|
||
|
|
gltf : gltf
|
||
|
|
}));
|
||
|
|
|
||
|
|
expect(function() {
|
||
|
|
scene.renderForSpecs();
|
||
|
|
}).toThrowRuntimeError();
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF v0.8 model', function() {
|
||
|
|
return loadModel(cesiumAir_0_8Url, {
|
||
|
|
minimumPixelSize : 1
|
||
|
|
}).then(function(m) {
|
||
|
|
// Verify that the version has been updated
|
||
|
|
expect(m.gltf.asset.version).toEqual('2.0');
|
||
|
|
|
||
|
|
// Verify that rotation is converted from
|
||
|
|
// Axis-Angle (1,0,0,0) to Quaternion (0,0,0,1)
|
||
|
|
var rotation = m.gltf.nodes[2].rotation;
|
||
|
|
expect(rotation).toEqual([0.0, 0.0, 0.0, 1.0]);
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 model', function() {
|
||
|
|
return loadModel(boxGltf2Url).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
m.show = true;
|
||
|
|
m.luminanceAtZenith = undefined;
|
||
|
|
|
||
|
|
expect({
|
||
|
|
scene : scene,
|
||
|
|
time : JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'))
|
||
|
|
}).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).toEqualEpsilon([193, 17, 16, 255], 5); // Red
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 model with techniques_webgl extension', function() {
|
||
|
|
return loadModel(boxGltf2WithTechniquesUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
m.show = true;
|
||
|
|
expect(scene).toRender([204, 0, 0, 255]); // Red
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF model with unused material', function() {
|
||
|
|
return loadModel(boxWithUnusedMaterial).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF model that doesn\'t have a technique', function() {
|
||
|
|
return loadModel(boxNoTechniqueUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF model that doesn\'t have indices', function() {
|
||
|
|
return loadModel(boxNoIndicesUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders texturedBoxCustom (all uniform semantics)', function() {
|
||
|
|
return loadModel(texturedBoxCustomUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders a model with the KHR_binary_glTF extension', function() {
|
||
|
|
return loadModel(texturedBoxKhrBinaryUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a model with the KHR_binary_glTF extension as an ArrayBuffer using new Model', function() {
|
||
|
|
return Resource.fetchArrayBuffer(texturedBoxKhrBinaryUrl).then(function(arrayBuffer) {
|
||
|
|
return loadModelJson(arrayBuffer).then(function(model) {
|
||
|
|
verifyRender(model);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a model with the KHR_binary_glTF extension as an Uint8Array using new Model', function() {
|
||
|
|
return Resource.fetchArrayBuffer(texturedBoxKhrBinaryUrl).then(function(arrayBuffer) {
|
||
|
|
return loadModelJson(new Uint8Array(arrayBuffer)).then(function(model) {
|
||
|
|
verifyRender(model);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Throws because of an invalid Binary glTF header - magic', function() {
|
||
|
|
var arrayBuffer = new ArrayBuffer(20);
|
||
|
|
expect(function() {
|
||
|
|
return new Model({
|
||
|
|
gltf : arrayBuffer
|
||
|
|
});
|
||
|
|
}).toThrowRuntimeError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Throws because of an invalid Binary glTF header - version', function() {
|
||
|
|
var arrayBuffer = new ArrayBuffer(20);
|
||
|
|
var bytes = new Uint8Array(arrayBuffer);
|
||
|
|
bytes[0] = 'g'.charCodeAt(0);
|
||
|
|
bytes[1] = 'l'.charCodeAt(0);
|
||
|
|
bytes[2] = 'T'.charCodeAt(0);
|
||
|
|
bytes[3] = 'F'.charCodeAt(0);
|
||
|
|
|
||
|
|
expect(function() {
|
||
|
|
return new Model({
|
||
|
|
gltf : arrayBuffer
|
||
|
|
});
|
||
|
|
}).toThrowRuntimeError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders a model with the CESIUM_RTC extension', function() {
|
||
|
|
return loadModel(boxRtcUrl, {
|
||
|
|
modelMatrix : Matrix4.IDENTITY,
|
||
|
|
minimumPixelSize : 1
|
||
|
|
}).then(function(m) {
|
||
|
|
var bs = m.boundingSphere;
|
||
|
|
expect(bs.center.equalsEpsilon(new Cartesian3(6378137.0, 0.0, 0.0), CesiumMath.EPSILON14));
|
||
|
|
var radius = Math.sqrt(0.5 * 0.5 * 3);
|
||
|
|
expect(bs.radius).toEqualEpsilon(radius, CesiumMath.EPSILON14);
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with external resources: .glsl, .bin, and .png files', function() {
|
||
|
|
return loadModel(texturedBoxSeparateUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with external KTX texture', function() {
|
||
|
|
return loadModel(texturedBoxKTXUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with embedded binary KTX texture', function() {
|
||
|
|
return loadModel(texturedBoxKTXBinaryUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with embedded base64 encoded KTX texture', function() {
|
||
|
|
return loadModel(texturedBoxKTXEmbeddedUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with external CRN texture', function() {
|
||
|
|
if (!scene.context.s3tc) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return loadModel(texturedBoxCRNUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with embedded binary CRN texture', function() {
|
||
|
|
if (!scene.context.s3tc) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return loadModel(texturedBoxCRNBinaryUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders textured box with embedded base64 encoded CRN texture', function() {
|
||
|
|
if (!scene.context.s3tc) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
return loadModel(texturedBoxCRNEmbeddedUrl, {
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(Object.keys(m._rendererResources.textures).length).toBe(1);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
it('loads cesiumAir', function() {
|
||
|
|
expect(cesiumAirModel.minimumPixelSize).toEqual(1);
|
||
|
|
expect(cesiumAirModel.maximumScale).toEqual(200);
|
||
|
|
expect(cesiumAirModel.asynchronous).toEqual(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders cesiumAir (has translucency)', function() {
|
||
|
|
verifyRender(cesiumAirModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders cesiumAir with per-node show (root)', function() {
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
var commands = cesiumAirModel._nodeCommands;
|
||
|
|
var i;
|
||
|
|
var length;
|
||
|
|
|
||
|
|
cesiumAirModel.show = true;
|
||
|
|
cesiumAirModel.zoomTo();
|
||
|
|
|
||
|
|
cesiumAirModel.getNode('Cesium_Air').show = false;
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
length = commands.length;
|
||
|
|
for (i = 0; i < length; ++i) {
|
||
|
|
expect(commands[i].show).toEqual(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
cesiumAirModel.getNode('Cesium_Air').show = true;
|
||
|
|
expect(scene).notToRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
length = commands.length;
|
||
|
|
for (i = 0; i < length; ++i) {
|
||
|
|
expect(commands[i].show).toEqual(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
cesiumAirModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders cesiumAir with per-node show (non-root)', function() {
|
||
|
|
cesiumAirModel.show = true;
|
||
|
|
cesiumAirModel.zoomTo();
|
||
|
|
|
||
|
|
var commands = cesiumAirModel._nodeCommands;
|
||
|
|
var i;
|
||
|
|
var length;
|
||
|
|
|
||
|
|
var commandsPropFalse = 0;
|
||
|
|
var commandsPropTrue = 0;
|
||
|
|
|
||
|
|
cesiumAirModel.getNode('Prop').show = false;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
length = commands.length;
|
||
|
|
for (i = 0; i < length; ++i) {
|
||
|
|
commandsPropFalse += commands[i].show ? 1 : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
cesiumAirModel.getNode('Prop').show = true;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
length = commands.length;
|
||
|
|
for (i = 0; i < length; ++i) {
|
||
|
|
commandsPropTrue += commands[i].show ? 1 : 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
cesiumAirModel.show = false;
|
||
|
|
|
||
|
|
// Prop node has one mesh with two primitives
|
||
|
|
expect(commandsPropFalse).toEqual(commandsPropTrue - 2);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('picks cesiumAir', function() {
|
||
|
|
if (FeatureDetection.isInternetExplorer()) {
|
||
|
|
// Workaround IE 11.0.9. This test fails when all tests are ran without a breakpoint here.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
cesiumAirModel.show = true;
|
||
|
|
cesiumAirModel.zoomTo();
|
||
|
|
|
||
|
|
expect(scene).toPickAndCall(function(result) {
|
||
|
|
expect(result.primitive).toEqual(cesiumAirModel);
|
||
|
|
expect(result.id).toEqual(cesiumAirUrl);
|
||
|
|
expect(result.node).toBeDefined();
|
||
|
|
expect(result.mesh).toBeDefined();
|
||
|
|
});
|
||
|
|
|
||
|
|
cesiumAirModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('cesiumAir is picked with a new pick id', function() {
|
||
|
|
if (FeatureDetection.isInternetExplorer()) {
|
||
|
|
// Workaround IE 11.0.9. This test fails when all tests are ran without a breakpoint here.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var oldId = cesiumAirModel.id;
|
||
|
|
cesiumAirModel.id = 'id';
|
||
|
|
cesiumAirModel.show = true;
|
||
|
|
cesiumAirModel.zoomTo();
|
||
|
|
|
||
|
|
expect(scene).toPickAndCall(function(result) {
|
||
|
|
expect(result.primitive).toEqual(cesiumAirModel);
|
||
|
|
expect(result.id).toEqual('id');
|
||
|
|
});
|
||
|
|
|
||
|
|
cesiumAirModel.id = oldId;
|
||
|
|
cesiumAirModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('cesiumAir is not picked (show === false)', function() {
|
||
|
|
cesiumAirModel.zoomTo();
|
||
|
|
|
||
|
|
expect(scene).notToPick();
|
||
|
|
});
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
it('renders animBoxes without animation', function() {
|
||
|
|
verifyRender(animBoxesModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('adds and removes all animations', function() {
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
|
||
|
|
var spyAdd = jasmine.createSpy('listener');
|
||
|
|
animations.animationAdded.addEventListener(spyAdd);
|
||
|
|
var a = animations.addAll();
|
||
|
|
expect(animations.length).toEqual(2);
|
||
|
|
expect(spyAdd.calls.count()).toEqual(2);
|
||
|
|
expect(spyAdd.calls.argsFor(0)[0]).toBe(animBoxesModel);
|
||
|
|
expect(spyAdd.calls.argsFor(0)[1]).toBe(a[0]);
|
||
|
|
expect(spyAdd.calls.argsFor(1)[0]).toBe(animBoxesModel);
|
||
|
|
expect(spyAdd.calls.argsFor(1)[1]).toBe(a[1]);
|
||
|
|
animations.animationAdded.removeEventListener(spyAdd);
|
||
|
|
|
||
|
|
expect(animations.contains(a[0])).toEqual(true);
|
||
|
|
expect(animations.get(0)).toEqual(a[0]);
|
||
|
|
expect(animations.contains(a[1])).toEqual(true);
|
||
|
|
expect(animations.get(1)).toEqual(a[1]);
|
||
|
|
|
||
|
|
var spyRemove = jasmine.createSpy('listener');
|
||
|
|
animations.animationRemoved.addEventListener(spyRemove);
|
||
|
|
animations.removeAll();
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
expect(spyRemove.calls.count()).toEqual(2);
|
||
|
|
expect(spyRemove.calls.argsFor(0)[0]).toBe(animBoxesModel);
|
||
|
|
expect(spyRemove.calls.argsFor(0)[1]).toBe(a[0]);
|
||
|
|
expect(spyRemove.calls.argsFor(1)[0]).toBe(animBoxesModel);
|
||
|
|
expect(spyRemove.calls.argsFor(1)[1]).toBe(a[1]);
|
||
|
|
animations.animationRemoved.removeEventListener(spyRemove);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('addAll throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.addAll();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('addAll throws when multiplier is less than or equal to zero.', function() {
|
||
|
|
expect(function() {
|
||
|
|
return animBoxesModel.activeAnimations.addAll({
|
||
|
|
multiplier : 0.0
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('adds and removes an animation', function() {
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
|
||
|
|
var spyAdd = jasmine.createSpy('listener');
|
||
|
|
animations.animationAdded.addEventListener(spyAdd);
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1'
|
||
|
|
});
|
||
|
|
expect(a).toBeDefined();
|
||
|
|
expect(a.name).toEqual('animation_1');
|
||
|
|
expect(a.startTime).not.toBeDefined();
|
||
|
|
expect(a.delay).toEqual(0.0);
|
||
|
|
expect(a.stopTime).not.toBeDefined();
|
||
|
|
expect(a.removeOnStop).toEqual(false);
|
||
|
|
expect(a.multiplier).toEqual(1.0);
|
||
|
|
expect(a.reverse).toEqual(false);
|
||
|
|
expect(a.loop).toEqual(ModelAnimationLoop.NONE);
|
||
|
|
expect(a.start).toBeDefined();
|
||
|
|
expect(a.update).toBeDefined();
|
||
|
|
expect(a.stop).toBeDefined();
|
||
|
|
expect(spyAdd).toHaveBeenCalledWith(animBoxesModel, a);
|
||
|
|
animations.animationAdded.removeEventListener(spyAdd);
|
||
|
|
|
||
|
|
expect(animations.contains(a)).toEqual(true);
|
||
|
|
expect(animations.get(0)).toEqual(a);
|
||
|
|
|
||
|
|
var spyRemove = jasmine.createSpy('listener');
|
||
|
|
animations.animationRemoved.addEventListener(spyRemove);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
expect(animations.remove(a)).toEqual(false);
|
||
|
|
expect(animations.remove()).toEqual(false);
|
||
|
|
expect(animations.contains(a)).toEqual(false);
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
expect(spyRemove).toHaveBeenCalledWith(animBoxesModel, a);
|
||
|
|
animations.animationRemoved.removeEventListener(spyRemove);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('adds an animation by index', function() {
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
|
||
|
|
var spyAdd = jasmine.createSpy('listener');
|
||
|
|
animations.animationAdded.addEventListener(spyAdd);
|
||
|
|
var a = animations.add({
|
||
|
|
index : 1
|
||
|
|
});
|
||
|
|
expect(a).toBeDefined();
|
||
|
|
expect(a.name).toEqual('animation_1');
|
||
|
|
animations.remove(a);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('add throws when name and index are not defined', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.add();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('add throws when index is invalid', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.add({
|
||
|
|
index : -1
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.add({
|
||
|
|
index : 2
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('add throws when model is not loaded', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.add({
|
||
|
|
name : 'animation_1'
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('add throws when name is invalid.', function() {
|
||
|
|
expect(function() {
|
||
|
|
return animBoxesModel.activeAnimations.add({
|
||
|
|
name : 'animation-does-not-exist'
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('add throws when multiplier is less than or equal to zero.', function() {
|
||
|
|
expect(function() {
|
||
|
|
return animBoxesModel.activeAnimations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
multiplier : 0.0
|
||
|
|
});
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('get throws without an index', function() {
|
||
|
|
var m = new Model();
|
||
|
|
expect(function() {
|
||
|
|
return m.activeAnimations.get();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('contains(undefined) returns false', function() {
|
||
|
|
expect(animBoxesModel.activeAnimations.contains(undefined)).toEqual(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('raises animation start, update, and stop events when removeOnStop is true', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
removeOnStop : true
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyStart = jasmine.createSpy('listener');
|
||
|
|
a.start.addEventListener(spyStart);
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
var stopped = false;
|
||
|
|
a.stop.addEventListener(function(model, animation) {
|
||
|
|
stopped = true;
|
||
|
|
});
|
||
|
|
var spyStop = jasmine.createSpy('listener');
|
||
|
|
a.stop.addEventListener(spyStop);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
scene.renderForSpecs(time);
|
||
|
|
time = JulianDate.addSeconds(time, 1.0, time, new JulianDate());
|
||
|
|
return stopped;
|
||
|
|
}, { timeout : 10000 }).then(function() {
|
||
|
|
expect(spyStart).toHaveBeenCalledWith(animBoxesModel, a);
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(4);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[0]).toBe(animBoxesModel);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[1]).toBe(a);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(1.0, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(2)[2]).toEqualEpsilon(2.0, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(3)[2]).toEqualEpsilon(3.0, CesiumMath.EPSILON14);
|
||
|
|
|
||
|
|
expect(spyStop).toHaveBeenCalledWith(animBoxesModel, a);
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates with a delay', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
delay : 1.0
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyStart = jasmine.createSpy('listener');
|
||
|
|
a.start.addEventListener(spyStart);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
scene.renderForSpecs(time); // Does not fire start
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 1.0, new JulianDate()));
|
||
|
|
|
||
|
|
expect(spyStart.calls.count()).toEqual(1);
|
||
|
|
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates with an explicit stopTime', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var stopTime = JulianDate.fromDate(new Date('January 1, 2014 12:00:01 UTC'));
|
||
|
|
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
stopTime : stopTime
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
scene.renderForSpecs(time);
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 1.0, new JulianDate()));
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 2.0, new JulianDate())); // Does not fire update
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(2);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(1.0, CesiumMath.EPSILON14);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates with a multiplier', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
multiplier : 1.5
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
scene.renderForSpecs(time);
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 1.0, new JulianDate()));
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 2.0, new JulianDate()));
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(3);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(1.5, CesiumMath.EPSILON14);
|
||
|
|
expect(spyUpdate.calls.argsFor(2)[2]).toEqualEpsilon(3.0, CesiumMath.EPSILON14);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates in reverse', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
reverse : true
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
scene.renderForSpecs(time);
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 1.0, new JulianDate()));
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 2.0, new JulianDate()));
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, 3.0, new JulianDate()));
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(4);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(3.708, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(2.708, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(2)[2]).toEqualEpsilon(1.708, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(3)[2]).toEqualEpsilon(0.708, CesiumMath.EPSILON3);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates with REPEAT', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
loop : ModelAnimationLoop.REPEAT
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
for (var i = 0; i < 8; ++i) {
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, i, new JulianDate()));
|
||
|
|
}
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(8);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(1.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(2)[2]).toEqualEpsilon(2.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(3)[2]).toEqualEpsilon(3.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(4)[2]).toEqualEpsilon(0.291, CesiumMath.EPSILON3); // Repeat with duration of ~3.7
|
||
|
|
expect(spyUpdate.calls.argsFor(5)[2]).toEqualEpsilon(1.291, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(6)[2]).toEqualEpsilon(2.291, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(7)[2]).toEqualEpsilon(3.291, CesiumMath.EPSILON3);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates with MIRRORED_REPEAT', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time,
|
||
|
|
loop : ModelAnimationLoop.MIRRORED_REPEAT
|
||
|
|
});
|
||
|
|
|
||
|
|
var spyUpdate = jasmine.createSpy('listener');
|
||
|
|
a.update.addEventListener(spyUpdate);
|
||
|
|
|
||
|
|
animBoxesModel.show = true;
|
||
|
|
for (var i = 0; i < 8; ++i) {
|
||
|
|
scene.renderForSpecs(JulianDate.addSeconds(time, i, new JulianDate()));
|
||
|
|
}
|
||
|
|
|
||
|
|
expect(spyUpdate.calls.count()).toEqual(8);
|
||
|
|
expect(spyUpdate.calls.argsFor(0)[2]).toEqualEpsilon(0.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(1)[2]).toEqualEpsilon(1.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(2)[2]).toEqualEpsilon(2.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(3)[2]).toEqualEpsilon(3.0, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(4)[2]).toEqualEpsilon(3.416, CesiumMath.EPSILON3); // Mirror repeat with duration of 3.6
|
||
|
|
expect(spyUpdate.calls.argsFor(5)[2]).toEqualEpsilon(2.416, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(6)[2]).toEqualEpsilon(1.416, CesiumMath.EPSILON3);
|
||
|
|
expect(spyUpdate.calls.argsFor(7)[2]).toEqualEpsilon(0.416, CesiumMath.EPSILON3);
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
animBoxesModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Animates and renders', function() {
|
||
|
|
return loadModel(animBoxesUrl, {
|
||
|
|
scale : 2.0
|
||
|
|
}).then(function(m) {
|
||
|
|
var node = m.getNode('inner_box');
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = m.activeAnimations;
|
||
|
|
var a = animations.add({
|
||
|
|
name : 'animation_1',
|
||
|
|
startTime : time
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(node.matrix).toEqual(Matrix4.IDENTITY);
|
||
|
|
var previousMatrix = Matrix4.clone(node.matrix);
|
||
|
|
|
||
|
|
m.zoomTo();
|
||
|
|
|
||
|
|
for (var i = 1; i < 4; ++i) {
|
||
|
|
var t = JulianDate.addSeconds(time, i, new JulianDate());
|
||
|
|
expect({
|
||
|
|
scene : scene,
|
||
|
|
time : t
|
||
|
|
}).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
m.show = true;
|
||
|
|
expect({
|
||
|
|
scene : scene,
|
||
|
|
time : t
|
||
|
|
}).notToRender([0, 0, 0, 255]);
|
||
|
|
m.show = false;
|
||
|
|
|
||
|
|
expect(node.matrix).not.toEqual(previousMatrix);
|
||
|
|
previousMatrix = Matrix4.clone(node.matrix);
|
||
|
|
}
|
||
|
|
|
||
|
|
expect(animations.remove(a)).toEqual(true);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('does not animate when there are no animations', function() {
|
||
|
|
var animations = animBoxesModel.activeAnimations;
|
||
|
|
expect(animations.length).toEqual(0);
|
||
|
|
expect(animations.update()).toEqual(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('animates a single keyframe', function() {
|
||
|
|
return Resource.fetchJson(animBoxesUrl).then(function(gltf) {
|
||
|
|
gltf.accessors['animAccessor_0'].count = 1;
|
||
|
|
gltf.accessors['animAccessor_1'].count = 1;
|
||
|
|
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
m.show = true;
|
||
|
|
var node = m.getNode('inner_box');
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = m.activeAnimations;
|
||
|
|
animations.add({
|
||
|
|
name : 'animation_0',
|
||
|
|
startTime : time
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(node.matrix).toEqual(Matrix4.IDENTITY);
|
||
|
|
var previousMatrix = Matrix4.clone(node.matrix);
|
||
|
|
|
||
|
|
for (var i = 1; i < 4; ++i) {
|
||
|
|
var t = JulianDate.addSeconds(time, i, new JulianDate());
|
||
|
|
scene.renderForSpecs(t);
|
||
|
|
expect(node.matrix).toEqual(previousMatrix);
|
||
|
|
}
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
it('renders riggedFigure without animation', function() {
|
||
|
|
verifyRender(riggedFigureModel);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders riggedFigure with animation (skinning)', function() {
|
||
|
|
var time = JulianDate.fromDate(new Date('January 1, 2014 12:00:00 UTC'));
|
||
|
|
var animations = riggedFigureModel.activeAnimations;
|
||
|
|
animations.addAll({
|
||
|
|
startTime : time
|
||
|
|
});
|
||
|
|
|
||
|
|
riggedFigureModel.zoomTo();
|
||
|
|
|
||
|
|
for (var i = 0; i < 6; ++i) {
|
||
|
|
var t = JulianDate.addSeconds(time, 0.25 * i, new JulianDate());
|
||
|
|
expect({
|
||
|
|
scene : scene,
|
||
|
|
time : t
|
||
|
|
}).toRender([0, 0, 0, 255]);
|
||
|
|
|
||
|
|
riggedFigureModel.show = true;
|
||
|
|
expect({
|
||
|
|
scene : scene,
|
||
|
|
time : t
|
||
|
|
}).notToRender([0, 0, 0, 255]);
|
||
|
|
riggedFigureModel.show = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
animations.removeAll();
|
||
|
|
riggedFigureModel.show = false;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders riggedSimple', function() {
|
||
|
|
return loadModel(riggedSimpleUrl).then(function(m) {
|
||
|
|
expect(m).toBeDefined();
|
||
|
|
verifyRender(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('should load a model where WebGL shader optimizer removes an attribute (linux)', function() {
|
||
|
|
var url = './Data/Models/test-shader-optimize/test-shader-optimize.gltf';
|
||
|
|
return loadModel(url).then(function(m) {
|
||
|
|
expect(m).toBeDefined();
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('releaseGltfJson releases glTF JSON when constructed with fromGltf', function() {
|
||
|
|
return loadModel(boxUrl, {
|
||
|
|
releaseGltfJson : true
|
||
|
|
}).then(function(m) {
|
||
|
|
expect(m.releaseGltfJson).toEqual(true);
|
||
|
|
expect(m.gltf).not.toBeDefined();
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('releaseGltfJson releases glTF JSON when constructed with Model constructor function', function() {
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
releaseGltfJson : true,
|
||
|
|
incrementallyLoadTextures : false,
|
||
|
|
asynchronous : true
|
||
|
|
}).then(function(m) {
|
||
|
|
expect(m.releaseGltfJson).toEqual(true);
|
||
|
|
expect(m.gltf).not.toBeDefined();
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Models are cached with fromGltf (1/2)', function() {
|
||
|
|
var key = 'a-cache-key';
|
||
|
|
|
||
|
|
// This cache for this model is initially empty
|
||
|
|
var gltfCache = Model._gltfCache;
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
var modelRendererResourceCache = scene.context.cache.modelRendererResourceCache;
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
// Use a custom cache key to avoid conflicting with previous tests
|
||
|
|
var promise = loadModel(boxUrl, {
|
||
|
|
cacheKey : key
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(gltfCache[key]).toBeDefined();
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
expect(gltfCache[key].ready).toEqual(false);
|
||
|
|
|
||
|
|
// This is a cache hit, but the JSON request is still pending.
|
||
|
|
// In the test below, the cache hit occurs after the request completes.
|
||
|
|
var promise2 = loadModel(boxUrl, {
|
||
|
|
cacheKey : key
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(gltfCache[key].count).toEqual(2);
|
||
|
|
|
||
|
|
return when.all([promise, promise2], function(models) {
|
||
|
|
var m = models[0];
|
||
|
|
var m2 = models[1];
|
||
|
|
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
// glTF JSON cache set ready once the JSON was downloaded
|
||
|
|
expect(gltfCache[key].ready).toEqual(true);
|
||
|
|
|
||
|
|
expect(modelRendererResourceCache[key]).toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key].count).toEqual(2);
|
||
|
|
expect(modelRendererResourceCache[key].ready).toEqual(true);
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
verifyRender(m2);
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
expect(modelRendererResourceCache[key].count).toEqual(1);
|
||
|
|
|
||
|
|
primitives.remove(m2);
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Models are cached with fromGltf (2/2)', function() {
|
||
|
|
var key = 'a-cache-key';
|
||
|
|
|
||
|
|
// This cache for this model is initially empty
|
||
|
|
var gltfCache = Model._gltfCache;
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
// Use a custom cache key to avoid conflicting with previous tests
|
||
|
|
var promise = loadModel(boxUrl, {
|
||
|
|
cacheKey : key
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(gltfCache[key]).toBeDefined();
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
expect(gltfCache[key].ready).toEqual(false);
|
||
|
|
|
||
|
|
return promise.then(function(m) {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
// Cache hit after JSON request completed.
|
||
|
|
var m2;
|
||
|
|
loadModel(boxUrl, {
|
||
|
|
cacheKey : key
|
||
|
|
}).then(function(model) {
|
||
|
|
m2 = model;
|
||
|
|
});
|
||
|
|
|
||
|
|
expect(gltfCache[key].ready).toEqual(true);
|
||
|
|
expect(gltfCache[key].count).toEqual(2);
|
||
|
|
|
||
|
|
verifyRender(m);
|
||
|
|
verifyRender(m2);
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
|
||
|
|
primitives.remove(m2);
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Cache with a custom cacheKey the Model Constructor (1/2)', function() {
|
||
|
|
var key = 'a-cache-key';
|
||
|
|
|
||
|
|
// This cache for this model is initially empty
|
||
|
|
var gltfCache = Model._gltfCache;
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
var modelRendererResourceCache = scene.context.cache.modelRendererResourceCache;
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
var m = primitives.add(new Model({
|
||
|
|
gltf : texturedBoxModel.gltf,
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
show : false,
|
||
|
|
cacheKey : key,
|
||
|
|
incrementallyLoadTextures : false,
|
||
|
|
asynchronous : true
|
||
|
|
}));
|
||
|
|
addZoomTo(m);
|
||
|
|
|
||
|
|
expect(gltfCache[key]).toBeDefined();
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
expect(gltfCache[key].ready).toEqual(true);
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
expect(modelRendererResourceCache[key]).toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key].count).toEqual(1);
|
||
|
|
expect(modelRendererResourceCache[key].ready).toEqual(m.ready);
|
||
|
|
|
||
|
|
return m.ready;
|
||
|
|
}, { timeout : 10000 }).then(function() {
|
||
|
|
verifyRender(m);
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Cache with a custom cacheKey when using the Model Constructor (2/2)', function() {
|
||
|
|
var key = 'a-cache-key';
|
||
|
|
var key3 = 'another-cache-key';
|
||
|
|
|
||
|
|
// This cache for these keys is initially empty
|
||
|
|
var gltfCache = Model._gltfCache;
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
expect(gltfCache[key3]).not.toBeDefined();
|
||
|
|
|
||
|
|
var modelRendererResourceCache = scene.context.cache.modelRendererResourceCache;
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key3]).not.toBeDefined();
|
||
|
|
|
||
|
|
var m = primitives.add(new Model({
|
||
|
|
gltf : texturedBoxModel.gltf,
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
show : false,
|
||
|
|
cacheKey : key,
|
||
|
|
asynchronous : true
|
||
|
|
}));
|
||
|
|
addZoomTo(m);
|
||
|
|
|
||
|
|
expect(gltfCache[key]).toBeDefined();
|
||
|
|
expect(gltfCache[key].count).toEqual(1);
|
||
|
|
expect(gltfCache[key].ready).toEqual(true);
|
||
|
|
|
||
|
|
// Should be cache hit. Not need to provide glTF.
|
||
|
|
var m2 = primitives.add(new Model({
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
show : false,
|
||
|
|
cacheKey : key,
|
||
|
|
asynchronous : true
|
||
|
|
}));
|
||
|
|
addZoomTo(m2);
|
||
|
|
|
||
|
|
expect(gltfCache[key].count).toEqual(2);
|
||
|
|
|
||
|
|
// Should be cache miss.
|
||
|
|
var m3 = primitives.add(new Model({
|
||
|
|
gltf : texturedBoxModel.gltf,
|
||
|
|
modelMatrix : Transforms.eastNorthUpToFixedFrame(Cartesian3.fromDegrees(0.0, 0.0, 100.0)),
|
||
|
|
show : false,
|
||
|
|
cacheKey : key3,
|
||
|
|
asynchronous : true
|
||
|
|
}));
|
||
|
|
addZoomTo(m3);
|
||
|
|
|
||
|
|
expect(gltfCache[key3]).toBeDefined();
|
||
|
|
expect(gltfCache[key3].count).toEqual(1);
|
||
|
|
expect(gltfCache[key3].ready).toEqual(true);
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
if (m.ready && m2.ready && m3.ready) {
|
||
|
|
expect(modelRendererResourceCache[key]).toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key].count).toEqual(2);
|
||
|
|
|
||
|
|
expect(modelRendererResourceCache[key3]).toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key3].count).toEqual(1);
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}, { timeout : 10000 }).then(function() {
|
||
|
|
verifyRender(m);
|
||
|
|
verifyRender(m2);
|
||
|
|
verifyRender(m3);
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
primitives.remove(m2);
|
||
|
|
expect(gltfCache[key]).not.toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key]).not.toBeDefined();
|
||
|
|
|
||
|
|
primitives.remove(m3);
|
||
|
|
expect(gltfCache[key3]).not.toBeDefined();
|
||
|
|
expect(modelRendererResourceCache[key3]).not.toBeDefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Loads with incrementallyLoadTextures set to true', function() {
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
incrementallyLoadTextures : true,
|
||
|
|
show : true
|
||
|
|
}).then(function(m) {
|
||
|
|
// Get the rendered color of the model before textures are loaded
|
||
|
|
var loadedColor;
|
||
|
|
|
||
|
|
m.zoomTo();
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
loadedColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load textures
|
||
|
|
scene.renderForSpecs();
|
||
|
|
// Textures have finished loading
|
||
|
|
return (m.pendingTextureLoads === 0);
|
||
|
|
}, { timeout : 10000 }).then(function() {
|
||
|
|
expect(scene).notToRender(loadedColor);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Loads with incrementallyLoadTextures set to false', function() {
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
incrementallyLoadTextures : false,
|
||
|
|
show : true
|
||
|
|
}).then(function(m) {
|
||
|
|
// Get the rendered color of the model before textures are loaded
|
||
|
|
var loadedColor;
|
||
|
|
|
||
|
|
m.zoomTo();
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
loadedColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load textures (they should already be loaded)
|
||
|
|
scene.renderForSpecs();
|
||
|
|
// Textures have finished loading
|
||
|
|
return !defined(m._loadResources);
|
||
|
|
}, { timeout : 10000 }).then(function() {
|
||
|
|
expect(scene).toRender(loadedColor);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using the constant lighting model', function() {
|
||
|
|
return loadModel(boxConstantUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using the lambert lighting model', function() {
|
||
|
|
return loadModel(boxLambertUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using the blinn lighting model', function() {
|
||
|
|
return loadModel(boxBlinnUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using the phong lighting model', function() {
|
||
|
|
return loadModel(boxPhongUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using a black ambient/directional light', function() {
|
||
|
|
return loadModel(boxNoLightUrl).then(function(m) {
|
||
|
|
// Verify that we render a black model because lighting is completely off
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
m.show = true;
|
||
|
|
m.zoomTo();
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
m.show = false;
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using an ambient light', function() {
|
||
|
|
return loadModel(boxAmbientLightUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using a directional light', function() {
|
||
|
|
return loadModel(boxDirectionalLightUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using a point light', function() {
|
||
|
|
return loadModel(boxPointLightUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common using a spot light', function() {
|
||
|
|
return loadModel(boxSpotLightUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common that has skinning', function() {
|
||
|
|
return loadModel(CesiumManUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_materials_common that has transparency', function() {
|
||
|
|
return loadModel(boxTransparentUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes POSITION and NORMAL', function() {
|
||
|
|
return loadModel(boxQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes and accessor.normalized', function() {
|
||
|
|
return loadModel(boxQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
var gltf = m.gltf;
|
||
|
|
var accessors = gltf.accessors;
|
||
|
|
var normalAccessor = accessors[2];
|
||
|
|
var positionAccessor = accessors[1];
|
||
|
|
normalAccessor.normalized = true;
|
||
|
|
positionAccessor.normalized = true;
|
||
|
|
var decodeMatrixArray = normalAccessor.extensions.WEB3D_quantized_attributes.decodeMatrix;
|
||
|
|
var decodeMatrix = new Matrix4();
|
||
|
|
Matrix4.unpack(decodeMatrixArray, 0, decodeMatrix);
|
||
|
|
Matrix4.multiplyByUniformScale(decodeMatrix, 65535.0, decodeMatrix);
|
||
|
|
Matrix4.pack(decodeMatrix, decodeMatrixArray);
|
||
|
|
decodeMatrixArray = positionAccessor.extensions.WEB3D_quantized_attributes.decodeMatrix;
|
||
|
|
Matrix4.unpack(decodeMatrixArray, 0, decodeMatrix);
|
||
|
|
Matrix4.multiplyByUniformScale(decodeMatrix, 65535.0, decodeMatrix);
|
||
|
|
Matrix4.pack(decodeMatrix, decodeMatrixArray);
|
||
|
|
primitives.remove(m);
|
||
|
|
return loadModelJson(gltf, {}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes POSITION and NORMAL where primitives with different accessors use the same shader', function() {
|
||
|
|
return loadModel(milkTruckQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes POSITION, TEXCOORD and NORMAL where one primitive is quantized and the other is not, but both use the same shader', function() {
|
||
|
|
return loadModel(milkTruckQuantizedMismatchUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes TEXCOORD', function() {
|
||
|
|
return loadModel(duckQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with WEB3D_quantized_attributes JOINT and WEIGHT', function() {
|
||
|
|
return loadModel(riggedSimpleQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 without textures', function() {
|
||
|
|
return loadModel(boxPbrUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with textures', function() {
|
||
|
|
return loadModel(boomBoxUrl).then(function(m) {
|
||
|
|
m.scale = 20.0; // Source model is very small, so scale up a bit
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with node animation', function() {
|
||
|
|
return loadModel(boxAnimatedPbrUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with node animations set to unclamped', function() {
|
||
|
|
return loadModel(boxAnimatedPbrUrl, {
|
||
|
|
clampAnimations : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with skinning', function() {
|
||
|
|
return loadModel(riggedSimplePbrUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with morph targets', function() {
|
||
|
|
return loadModel(animatedMorphCubeUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with alphaMode set to OPAQUE', function() {
|
||
|
|
return Resource.fetchJson(boxPbrUrl).then(function(gltf) {
|
||
|
|
gltf.materials[0].alphaMode = 'OPAQUE';
|
||
|
|
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with alphaMode set to MASK', function() {
|
||
|
|
return Resource.fetchJson(boxPbrUrl).then(function(gltf) {
|
||
|
|
gltf.materials[0].alphaMode = 'MASK';
|
||
|
|
gltf.materials[0].alphaCutoff = 0.5;
|
||
|
|
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with alphaMode set to BLEND', function() {
|
||
|
|
return Resource.fetchJson(boxPbrUrl).then(function(gltf) {
|
||
|
|
gltf.materials[0].alphaMode = 'BLEND';
|
||
|
|
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with interleaved vertex attributes', function() {
|
||
|
|
return loadModel(boxInterleavedPbrUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
function checkDoubleSided(model, doubleSided) {
|
||
|
|
var camera = scene.camera;
|
||
|
|
var center = Matrix4.multiplyByPoint(model.modelMatrix, model.boundingSphere.center, new Cartesian3());
|
||
|
|
var range = 4.0 * model.boundingSphere.radius;
|
||
|
|
|
||
|
|
camera.lookAt(center, new HeadingPitchRange(0, -CesiumMath.PI_OVER_TWO, range));
|
||
|
|
expect(scene).notToRender([0, 0, 0, 255]);
|
||
|
|
camera.lookAt(center, new HeadingPitchRange(0, CesiumMath.PI_OVER_TWO, range));
|
||
|
|
if (doubleSided) {
|
||
|
|
expect(scene).notToRender([0, 0, 0, 255]);
|
||
|
|
} else {
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function checkVertexColors(model) {
|
||
|
|
model.zoomTo();
|
||
|
|
scene.camera.moveUp(0.1);
|
||
|
|
// Red
|
||
|
|
scene.camera.moveLeft(0.5);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeGreaterThan(20);
|
||
|
|
expect(rgba[1]).toBeLessThan(20);
|
||
|
|
expect(rgba[2]).toBeLessThan(20);
|
||
|
|
});
|
||
|
|
// Green
|
||
|
|
scene.camera.moveRight(0.5);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeLessThan(20);
|
||
|
|
expect(rgba[1]).toBeGreaterThan(20);
|
||
|
|
expect(rgba[2]).toBeLessThan(20);
|
||
|
|
});
|
||
|
|
// Blue
|
||
|
|
scene.camera.moveRight(0.5);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeLessThan(20);
|
||
|
|
expect(rgba[1]).toBeLessThan(20);
|
||
|
|
expect(rgba[2]).toBeGreaterThan(20);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with doubleSided set to false', function() {
|
||
|
|
return Resource.fetchJson(twoSidedPlaneUrl).then(function(gltf) {
|
||
|
|
gltf.materials[0].doubleSided = false;
|
||
|
|
return loadModelJson(gltf).then(function(m) {
|
||
|
|
m.show = true;
|
||
|
|
checkDoubleSided(m, false);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with doubleSided set to true', function() {
|
||
|
|
return loadModel(twoSidedPlaneUrl).then(function(m) {
|
||
|
|
m.show = true;
|
||
|
|
checkDoubleSided(m, true);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with vertex colors', function() {
|
||
|
|
return loadModel(vertexColorTestUrl, {
|
||
|
|
forwardAxis : Axis.X
|
||
|
|
}).then(function(m) {
|
||
|
|
m.show = true;
|
||
|
|
checkVertexColors(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF 2.0 with an emissive texture and no normals', function() {
|
||
|
|
return loadModel(emissiveUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
// Emissive texture is red
|
||
|
|
expect(rgba[0]).toBeGreaterThan(20);
|
||
|
|
expect(rgba[1]).toBeLessThan(20);
|
||
|
|
expect(rgba[2]).toBeLessThan(20);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
function testBoxSideColors(m) {
|
||
|
|
var rotateX = Matrix3.fromRotationX(CesiumMath.toRadians(90.0));
|
||
|
|
var rotateY = Matrix3.fromRotationY(CesiumMath.toRadians(90.0));
|
||
|
|
var rotateZ = Matrix3.fromRotationZ(CesiumMath.toRadians(90.0));
|
||
|
|
|
||
|
|
// Each side of the cube should be a different color
|
||
|
|
var oldPixelColor;
|
||
|
|
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
oldPixelColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
for(var i = 0; i < 6; i++) {
|
||
|
|
var rotate = rotateZ;
|
||
|
|
if (i % 3 === 0) {
|
||
|
|
rotate = rotateX;
|
||
|
|
}
|
||
|
|
else if ((i-1) % 3 === 0) {
|
||
|
|
rotate = rotateY;
|
||
|
|
}
|
||
|
|
Matrix4.multiplyByMatrix3(m.modelMatrix, rotate, m.modelMatrix);
|
||
|
|
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) { //eslint-disable-line no-loop-func
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
expect(rgba).not.toEqual(oldPixelColor);
|
||
|
|
oldPixelColor = rgba;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
it('loads a gltf with normalized color attributes', function() {
|
||
|
|
return loadModel(boxColorUrl).then(function(m) {
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
m.show = true;
|
||
|
|
m.zoomTo();
|
||
|
|
testBoxSideColors(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a gltf with uint32 indices', function() {
|
||
|
|
var context = scene.context;
|
||
|
|
if (context._elementIndexUint) {
|
||
|
|
return loadModel(boxUint32Indices).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('throws runtime error when loading a gltf with uint32 indices if OES_element_index_uint is disabled', function() {
|
||
|
|
var context = scene.context;
|
||
|
|
var uint32Supported = context._elementIndexUint;
|
||
|
|
context._elementIndexUint = false;
|
||
|
|
|
||
|
|
var model = primitives.add(Model.fromGltf({
|
||
|
|
url : boxUint32Indices
|
||
|
|
}));
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
// Render scene to progressively load the model
|
||
|
|
scene.renderForSpecs();
|
||
|
|
return model.ready;
|
||
|
|
}, { timeout: 10000 }).then(function() {
|
||
|
|
fail('should not resolve');
|
||
|
|
}).otherwise(function(e) {
|
||
|
|
expect(e).toBeDefined();
|
||
|
|
primitives.remove(model);
|
||
|
|
context._elementIndexUint = uint32Supported;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a gltf with WEB3D_quantized_attributes COLOR', function() {
|
||
|
|
return loadModel(boxColorQuantizedUrl).then(function(m) {
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
expect(scene).toRender([0, 0, 0, 255]);
|
||
|
|
m.show = true;
|
||
|
|
m.zoomTo();
|
||
|
|
testBoxSideColors(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a gltf with WEB3D_quantized_attributes SCALAR attribute', function() {
|
||
|
|
return loadModel(boxScalarQuantizedUrl).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads with custom vertex attributes, vertexShader, fragmentShader, and uniform map', function() {
|
||
|
|
function vertexShaderLoaded(vs) {
|
||
|
|
var renamedSource = ShaderSource.replaceMain(vs, 'czm_old_main');
|
||
|
|
var newMain =
|
||
|
|
'attribute vec4 a_color;\n' +
|
||
|
|
'varying vec4 v_color;\n' +
|
||
|
|
'void main()\n' +
|
||
|
|
'{\n' +
|
||
|
|
' czm_old_main();\n' +
|
||
|
|
' v_color = a_color;\n' +
|
||
|
|
'}';
|
||
|
|
return renamedSource + '\n' + newMain;
|
||
|
|
}
|
||
|
|
|
||
|
|
function fragmentShaderLoaded(fs) {
|
||
|
|
fs = 'uniform float u_value;\n' +
|
||
|
|
'varying vec4 v_color;\n' +
|
||
|
|
'void main()\n' +
|
||
|
|
'{\n' +
|
||
|
|
' gl_FragColor = u_value * v_color;\n' +
|
||
|
|
'}';
|
||
|
|
return fs;
|
||
|
|
}
|
||
|
|
|
||
|
|
function uniformMapLoaded(uniformMap) {
|
||
|
|
return combine(uniformMap, {
|
||
|
|
u_value : function() {
|
||
|
|
return 1.0;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
var precreatedAttributes = {
|
||
|
|
a_color : {
|
||
|
|
index : 0, // updated in Model
|
||
|
|
componentsPerAttribute : 4,
|
||
|
|
value : [1.0, 1.0, 1.0, 1.0]
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
var options = {
|
||
|
|
show : true,
|
||
|
|
precreatedAttributes : precreatedAttributes,
|
||
|
|
vertexShaderLoaded : vertexShaderLoaded,
|
||
|
|
fragmentShaderLoaded : fragmentShaderLoaded,
|
||
|
|
uniformMapLoaded : uniformMapLoaded
|
||
|
|
};
|
||
|
|
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, options).then(function(model) {
|
||
|
|
model.zoomTo();
|
||
|
|
expect(scene).toRender([255, 255, 255, 255]);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_draco_mesh_compression extension', function() {
|
||
|
|
return loadModel(dracoCompressedModelUrl, {
|
||
|
|
dequantizeInShader : false
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a glTF with KHR_draco_mesh_compression extension with integer attributes', function() {
|
||
|
|
return loadModel(dracoCompressedModelWithAnimationUrl, {
|
||
|
|
dequantizeInShader : false,
|
||
|
|
forwardAxis : Axis.X
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads multiple draco models from cache without decoding', function() {
|
||
|
|
var initialModel;
|
||
|
|
var decoder = DracoLoader._getDecoderTaskProcessor();
|
||
|
|
return loadModel(dracoCompressedModelUrl)
|
||
|
|
.then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
initialModel = m;
|
||
|
|
spyOn(decoder, 'scheduleTask');
|
||
|
|
return loadModel(dracoCompressedModelUrl);
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
expect(decoder.scheduleTask).not.toHaveBeenCalled();
|
||
|
|
primitives.remove(m);
|
||
|
|
primitives.remove(initialModel);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('error decoding a draco compressed glTF causes model loading to fail', function() {
|
||
|
|
var decoder = DracoLoader._getDecoderTaskProcessor();
|
||
|
|
spyOn(decoder, 'scheduleTask').and.returnValue(when.reject({message : 'my error'}));
|
||
|
|
|
||
|
|
var model = primitives.add(Model.fromGltf({
|
||
|
|
url : dracoCompressedModelUrl,
|
||
|
|
dequantizeInShader : false
|
||
|
|
}));
|
||
|
|
|
||
|
|
return pollToPromise(function() {
|
||
|
|
scene.renderForSpecs();
|
||
|
|
return model._state === 3; // FAILED
|
||
|
|
}, { timeout: 10000 }).then(function() {
|
||
|
|
model.readyPromise.then(function (e) {
|
||
|
|
fail('should not resolve');
|
||
|
|
}).otherwise(function(e) {
|
||
|
|
expect(e).toBeDefined();
|
||
|
|
expect(e.message).toEqual('Failed to load model: ./Data/Models/DracoCompression/CesiumMilkTruck/CesiumMilkTruck.gltf\nmy error');
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a draco compressed glTF and dequantizes in the shader', function() {
|
||
|
|
return loadModel(dracoCompressedModelUrl, {
|
||
|
|
dequantizeInShader : true
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
|
||
|
|
var atrributeData = m._decodedData['0.primitive.0'].attributes;
|
||
|
|
expect(atrributeData['POSITION'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['TEXCOORD_0'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['NORMAL'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['NORMAL'].quantization.octEncoded).toBe(true);
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('loads a draco compressed glTF and dequantizes in the shader, skipping generic attributes', function() {
|
||
|
|
return loadModel(dracoCompressedModelWithAnimationUrl, {
|
||
|
|
dequantizeInShader : true,
|
||
|
|
forwardAxis : Axis.X
|
||
|
|
}).then(function(m) {
|
||
|
|
verifyRender(m);
|
||
|
|
|
||
|
|
var atrributeData = m._decodedData['0.primitive.0'].attributes;
|
||
|
|
expect(atrributeData['POSITION'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['TEXCOORD_0'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['NORMAL'].quantization).toBeDefined();
|
||
|
|
expect(atrributeData['JOINTS_0'].quantization).toBeUndefined();
|
||
|
|
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('does not issue draw commands when ignoreCommands is true', function() {
|
||
|
|
return loadModel(texturedBoxUrl, {
|
||
|
|
ignoreCommands : true
|
||
|
|
}).then(function(m) {
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
m.show = true;
|
||
|
|
|
||
|
|
m.zoomTo();
|
||
|
|
m.update(scene.frameState);
|
||
|
|
expect(scene.frameState.commandList.length).toEqual(0);
|
||
|
|
|
||
|
|
m.show = false;
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('does not issue draw commands when the model is out of view and cull is true', function() {
|
||
|
|
return loadModel(texturedBoxUrl, {
|
||
|
|
cull : true
|
||
|
|
}).then(function(m) {
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
m.show = true;
|
||
|
|
|
||
|
|
// Look at the model
|
||
|
|
m.zoomTo();
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.frustumCommandsList.length).not.toEqual(0);
|
||
|
|
|
||
|
|
// Move the model out of view
|
||
|
|
m.modelMatrix = Matrix4.fromTranslation(new Cartesian3(100000.0, 0.0, 0.0));
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.frustumCommandsList.length).toEqual(0);
|
||
|
|
|
||
|
|
m.show = false;
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('issues draw commands when the model is out of view and cull is false', function() {
|
||
|
|
return loadModel(texturedBoxUrl, {
|
||
|
|
cull : false
|
||
|
|
}).then(function(m) {
|
||
|
|
expect(m.ready).toBe(true);
|
||
|
|
m.show = true;
|
||
|
|
|
||
|
|
// Look at the model
|
||
|
|
m.zoomTo();
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.frustumCommandsList.length).not.toEqual(0);
|
||
|
|
|
||
|
|
// Move the model out of view
|
||
|
|
m.modelMatrix = Matrix4.fromTranslation(new Cartesian3(10000000000.0, 0.0, 0.0));
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.frustumCommandsList.length).not.toEqual(0);
|
||
|
|
|
||
|
|
m.show = false;
|
||
|
|
primitives.remove(m);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with a color', function() {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
// Model is originally red
|
||
|
|
var sourceColor;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeGreaterThan(0);
|
||
|
|
expect(rgba[1]).toEqual(0);
|
||
|
|
sourceColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
// Check MIX
|
||
|
|
model.colorBlendMode = ColorBlendMode.MIX;
|
||
|
|
model.color = Color.LIME;
|
||
|
|
|
||
|
|
model.colorBlendAmount = 0.0;
|
||
|
|
expect(scene).toRender(sourceColor);
|
||
|
|
|
||
|
|
model.colorBlendAmount = 0.5;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeGreaterThan(0);
|
||
|
|
expect(rgba[1]).toBeGreaterThan(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
model.colorBlendAmount = 1.0;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toEqual(0);
|
||
|
|
expect(rgba[1]).toEqual(255);
|
||
|
|
});
|
||
|
|
|
||
|
|
// Check REPLACE
|
||
|
|
model.colorBlendMode = ColorBlendMode.REPLACE;
|
||
|
|
model.colorBlendAmount = 0.5; // Should have no effect
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toEqual(0);
|
||
|
|
expect(rgba[1]).toEqual(255);
|
||
|
|
});
|
||
|
|
|
||
|
|
// Check HIGHLIGHT
|
||
|
|
model.colorBlendMode = ColorBlendMode.HIGHLIGHT;
|
||
|
|
model.color = Color.DARKGRAY;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toBeGreaterThan(0);
|
||
|
|
expect(rgba[0]).toBeLessThan(255);
|
||
|
|
expect(rgba[1]).toEqual(0);
|
||
|
|
expect(rgba[2]).toEqual(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
// Check alpha
|
||
|
|
model.colorBlendMode = ColorBlendMode.REPLACE;
|
||
|
|
model.color = Color.fromAlpha(Color.LIME, 0.5);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toEqual(0);
|
||
|
|
expect(rgba[1]).toBeLessThan(255);
|
||
|
|
expect(rgba[1]).toBeGreaterThan(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
// No commands are issued when the alpha is 0.0
|
||
|
|
model.color = Color.fromAlpha(Color.LIME, 0.0);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
var commands = scene.frameState.commandList;
|
||
|
|
expect(commands.length).toBe(0);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with the KHR_materials_unlit extension', function() {
|
||
|
|
return loadModel(boxPbrUnlitUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
// We expect to see the base color when unlit
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba[0]).toEqual(0);
|
||
|
|
expect(rgba[1]).toEqual(255);
|
||
|
|
expect(rgba[2]).toEqual(0);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with the KHR_materials_pbrSpecularGlossiness extension', function() {
|
||
|
|
return loadModel(boomBoxPbrSpecularGlossinessUrl).then(function(model) {
|
||
|
|
model.show = false;
|
||
|
|
model.zoomTo(2.0);
|
||
|
|
|
||
|
|
var originalColor;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
originalColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
model.show = true;
|
||
|
|
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(originalColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with the KHR_materials_pbrSpecularGlossiness extension with defaults', function() {
|
||
|
|
return loadModel(boomBoxPbrSpecularGlossinessDefaultsUrl).then(function(model) {
|
||
|
|
model.show = false;
|
||
|
|
model.zoomTo(2.0);
|
||
|
|
|
||
|
|
var originalColor;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
originalColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
model.show = true;
|
||
|
|
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(originalColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with the KHR_materials_pbrSpecularGlossiness extension when no textures are found', function() {
|
||
|
|
return loadModel(boomBoxPbrSpecularGlossinessNoTextureUrl).then(function(model) {
|
||
|
|
model.show = false;
|
||
|
|
model.zoomTo(2.0);
|
||
|
|
|
||
|
|
var originalColor;
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
originalColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
model.show = true;
|
||
|
|
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(originalColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('silhouetteSupported', function() {
|
||
|
|
expect(Model.silhouetteSupported(scene)).toBe(true);
|
||
|
|
scene.context._stencilBits = 0;
|
||
|
|
expect(Model.silhouetteSupported(scene)).toBe(false);
|
||
|
|
scene.context._stencilBits = 8;
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with a silhouette', function() {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
var commands = scene.frameState.commandList;
|
||
|
|
|
||
|
|
// No silhouette
|
||
|
|
model.silhouetteSize = 0.0;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(1);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(false);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
|
||
|
|
// Opaque silhouette
|
||
|
|
model.silhouetteSize = 1.0;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.OPAQUE);
|
||
|
|
|
||
|
|
// Translucent silhouette
|
||
|
|
model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.5);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
|
||
|
|
// Invisible silhouette. The model is rendered normally.
|
||
|
|
model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.0);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(1);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(false);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
|
||
|
|
// Invisible model with no silhouette. No commands.
|
||
|
|
model.color = Color.fromAlpha(Color.WHITE, 0.0);
|
||
|
|
model.silhouetteColor = Color.GREEN;
|
||
|
|
model.silhouetteSize = 0.0;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(0);
|
||
|
|
|
||
|
|
// Invisible model with silhouette. Model command is stencil-only.
|
||
|
|
model.silhouetteSize = 1.0;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.colorMask).toEqual({
|
||
|
|
red : false,
|
||
|
|
green : false,
|
||
|
|
blue : false,
|
||
|
|
alpha : false
|
||
|
|
});
|
||
|
|
expect(commands[0].renderState.depthMask).toEqual(false);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.OPAQUE);
|
||
|
|
|
||
|
|
// Translucent model with opaque silhouette. Silhouette is placed in the translucent pass.
|
||
|
|
model.color = Color.fromAlpha(Color.WHITE, 0.5);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
|
||
|
|
// Model with translucent commands with silhouette
|
||
|
|
model.color = Color.WHITE;
|
||
|
|
model._nodeCommands[0].command.pass = Pass.TRANSLUCENT;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
model._nodeCommands[0].command.pass = Pass.OPAQUE; // Revert change
|
||
|
|
|
||
|
|
// Translucent model with translucent silhouette.
|
||
|
|
model.color = Color.fromAlpha(Color.WHITE, 0.5);
|
||
|
|
model.silhouetteColor = Color.fromAlpha(Color.GREEN, 0.5);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(2);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.TRANSLUCENT);
|
||
|
|
|
||
|
|
model.color = Color.WHITE;
|
||
|
|
model.silhouetteColor = Color.GREEN;
|
||
|
|
|
||
|
|
// Load a second model
|
||
|
|
return loadModel(boxUrl).then(function(model2) {
|
||
|
|
model2.show = true;
|
||
|
|
model2.silhouetteSize = 1.0;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(commands.length).toBe(4);
|
||
|
|
expect(commands[0].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[0].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[1].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[1].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[2].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[2].pass).toBe(Pass.OPAQUE);
|
||
|
|
expect(commands[3].renderState.stencilTest.enabled).toBe(true);
|
||
|
|
expect(commands[3].pass).toBe(Pass.OPAQUE);
|
||
|
|
|
||
|
|
var reference1 = commands[0].renderState.stencilTest.reference;
|
||
|
|
var reference2 = commands[2].renderState.stencilTest.reference;
|
||
|
|
expect(reference2).toEqual(reference1 + 1);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
primitives.remove(model2);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with imageBaseLightingFactor', function() {
|
||
|
|
return loadModel(boxPbrUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
model.imageBasedLightingFactor = new Cartesian2(0.0, 0.0);
|
||
|
|
expect(scene).notToRender(rgba);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('renders with lightColor', function() {
|
||
|
|
return loadModel(boxPbrUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual([0, 0, 0, 255]);
|
||
|
|
model.imageBasedLightingFactor = new Cartesian2(0.0, 0.0);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba2) {
|
||
|
|
expect(rgba2).not.toEqual(rgba);
|
||
|
|
model.lightColor = new Cartesian3(5.0, 5.0, 5.0);
|
||
|
|
expect(scene).notToRender(rgba2);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Updates clipping planes when clipping planes are enabled', function () {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
var gl = scene.frameState.context._gl;
|
||
|
|
spyOn(gl, 'texImage2D').and.callThrough();
|
||
|
|
|
||
|
|
scene.renderForSpecs();
|
||
|
|
var callsBeforeClipping = gl.texImage2D.calls.count();
|
||
|
|
|
||
|
|
expect(model._clippingPlaneModelViewMatrix).toEqual(Matrix4.IDENTITY);
|
||
|
|
|
||
|
|
model.clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
]
|
||
|
|
});
|
||
|
|
|
||
|
|
model.update(scene.frameState);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
// When clipping planes are created, we expect two calls to texImage2D
|
||
|
|
// (one for initial creation, and one for copying the data in)
|
||
|
|
// because clipping planes is stored inside a texture.
|
||
|
|
expect(gl.texImage2D.calls.count() - callsBeforeClipping).toEqual(2);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Clipping planes selectively disable rendering', function () {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
var modelColor;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
modelColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
var plane = new ClippingPlane(Cartesian3.UNIT_X, 0.0);
|
||
|
|
model.clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
plane
|
||
|
|
]
|
||
|
|
});
|
||
|
|
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(modelColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
plane.distance = 10.0;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).toEqual(modelColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Clipping planes apply edge styling', function () {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
var modelColor;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
modelColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
var plane = new ClippingPlane(Cartesian3.UNIT_X, 0.0);
|
||
|
|
model.clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
plane
|
||
|
|
],
|
||
|
|
edgeWidth : 5.0,
|
||
|
|
edgeColor : Color.BLUE
|
||
|
|
});
|
||
|
|
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(modelColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
plane.distance = 5.0;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).toEqual([0, 0, 255, 255]);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('Clipping planes union regions', function () {
|
||
|
|
return loadModel(boxUrl).then(function(model) {
|
||
|
|
model.show = true;
|
||
|
|
model.zoomTo();
|
||
|
|
|
||
|
|
var modelColor;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
modelColor = rgba;
|
||
|
|
});
|
||
|
|
|
||
|
|
model.clippingPlanes = new ClippingPlaneCollection({
|
||
|
|
planes : [
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_Z, 5.0),
|
||
|
|
new ClippingPlane(Cartesian3.UNIT_X, 0.0)
|
||
|
|
],
|
||
|
|
unionClippingRegions: true
|
||
|
|
});
|
||
|
|
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).not.toEqual(modelColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
model.clippingPlanes.unionClippingRegions = false;
|
||
|
|
model.update(scene.frameState);
|
||
|
|
expect(scene).toRenderAndCall(function(rgba) {
|
||
|
|
expect(rgba).toEqual(modelColor);
|
||
|
|
});
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('gets triangle count', function() {
|
||
|
|
expect(texturedBoxModel.trianglesLength).toBe(12);
|
||
|
|
expect(cesiumAirModel.trianglesLength).toBe(5984);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('gets memory usage', function() {
|
||
|
|
// Texture is originally 211*211 but is scaled up to 256*256 to support its minification filter and then is mipmapped
|
||
|
|
var expectedTextureMemory = Math.floor(256*256*4*(4/3));
|
||
|
|
var expectedGeometryMemory = 840;
|
||
|
|
var options = {
|
||
|
|
cacheKey : 'memory-usage-test',
|
||
|
|
incrementallyLoadTextures : false
|
||
|
|
};
|
||
|
|
return loadModel(texturedBoxUrl, options).then(function(model) {
|
||
|
|
// The first model owns the resources
|
||
|
|
expect(model.geometryByteLength).toBe(expectedGeometryMemory);
|
||
|
|
expect(model.texturesByteLength).toBe(expectedTextureMemory);
|
||
|
|
expect(model.cachedGeometryByteLength).toBe(0);
|
||
|
|
expect(model.cachedTexturesByteLength).toBe(0);
|
||
|
|
|
||
|
|
return loadModel(texturedBoxUrl, options).then(function(model) {
|
||
|
|
// The second model is sharing the resources, so its memory usage is reported as 0
|
||
|
|
expect(model.geometryByteLength).toBe(0);
|
||
|
|
expect(model.texturesByteLength).toBe(0);
|
||
|
|
expect(model.cachedGeometryByteLength).toBe(expectedGeometryMemory);
|
||
|
|
expect(model.cachedTexturesByteLength).toBe(expectedTextureMemory);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('height referenced model', function() {
|
||
|
|
function createMockGlobe() {
|
||
|
|
var globe = {
|
||
|
|
callback : undefined,
|
||
|
|
removedCallback : false,
|
||
|
|
ellipsoid : Ellipsoid.WGS84,
|
||
|
|
update : function() {},
|
||
|
|
render : function() {},
|
||
|
|
getHeight : function() {
|
||
|
|
return 0.0;
|
||
|
|
},
|
||
|
|
_surface : {
|
||
|
|
tileProvider : {
|
||
|
|
ready : true
|
||
|
|
},
|
||
|
|
_tileLoadQueueHigh : [],
|
||
|
|
_tileLoadQueueMedium : [],
|
||
|
|
_tileLoadQueueLow : [],
|
||
|
|
_debug : {
|
||
|
|
tilesWaitingForChildren : 0
|
||
|
|
}
|
||
|
|
},
|
||
|
|
tileLoadedEvent : new Event(),
|
||
|
|
imageryLayersUpdatedEvent : new Event(),
|
||
|
|
destroy : function() {}
|
||
|
|
};
|
||
|
|
|
||
|
|
globe.beginFrame = function() {
|
||
|
|
};
|
||
|
|
|
||
|
|
globe.endFrame = function() {
|
||
|
|
};
|
||
|
|
|
||
|
|
globe.terrainProviderChanged = new Event();
|
||
|
|
defineProperties(globe, {
|
||
|
|
terrainProvider : {
|
||
|
|
set : function(value) {
|
||
|
|
this.terrainProviderChanged.raiseEvent(value);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
globe._surface.updateHeight = function(position, callback) {
|
||
|
|
globe.callback = callback;
|
||
|
|
return function() {
|
||
|
|
globe.removedCallback = true;
|
||
|
|
globe.callback = undefined;
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
return globe;
|
||
|
|
}
|
||
|
|
|
||
|
|
it('explicitly constructs a model with height reference', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
scene : scene
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(model.heightReference).toEqual(HeightReference.CLAMP_TO_GROUND);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('set model height reference property', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
scene : scene
|
||
|
|
}).then(function(model) {
|
||
|
|
model.heightReference = HeightReference.CLAMP_TO_GROUND;
|
||
|
|
expect(model.heightReference).toEqual(HeightReference.CLAMP_TO_GROUND);
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('creating with a height reference creates a height update callback', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('set height reference property creates a height update callback', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
model.heightReference = HeightReference.CLAMP_TO_GROUND;
|
||
|
|
expect(model.heightReference).toEqual(HeightReference.CLAMP_TO_GROUND);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('updates the callback when the height reference changes', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
|
||
|
|
model.heightReference = HeightReference.RELATIVE_TO_GROUND;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.globe.removedCallback).toEqual(true);
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
|
||
|
|
scene.globe.removedCallback = false;
|
||
|
|
model.heightReference = HeightReference.NONE;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.globe.removedCallback).toEqual(true);
|
||
|
|
expect(scene.globe.callback).not.toBeDefined();
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('changing the position updates the callback', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
|
||
|
|
var matrix = Matrix4.clone(model.modelMatrix);
|
||
|
|
var position = Cartesian3.fromDegrees(-73.0, 40.0);
|
||
|
|
matrix[12] = position.x;
|
||
|
|
matrix[13] = position.y;
|
||
|
|
matrix[14] = position.z;
|
||
|
|
|
||
|
|
model.modelMatrix = matrix;
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
expect(scene.globe.removedCallback).toEqual(true);
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('callback updates the position', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
scene.globe.callback(Cartesian3.fromDegrees(-72.0, 40.0, 100.0));
|
||
|
|
var matrix = model._clampedModelMatrix;
|
||
|
|
var clampedPosition = new Cartesian3(matrix[12], matrix[13], matrix[14]);
|
||
|
|
var cartographic = scene.globe.ellipsoid.cartesianToCartographic(clampedPosition);
|
||
|
|
expect(cartographic.height).toEqualEpsilon(100.0, CesiumMath.EPSILON9);
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('removes the callback on destroy', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(scene.globe.callback).toBeDefined();
|
||
|
|
scene.renderForSpecs();
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
scene.renderForSpecs();
|
||
|
|
expect(scene.globe.callback).toBeUndefined();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('changing the terrain provider', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene
|
||
|
|
}).then(function(model) {
|
||
|
|
expect(model._heightChanged).toBe(false);
|
||
|
|
|
||
|
|
var terrainProvider = new CesiumTerrainProvider({
|
||
|
|
url : 'made/up/url',
|
||
|
|
requestVertexNormals : true
|
||
|
|
});
|
||
|
|
|
||
|
|
scene.terrainProvider = terrainProvider;
|
||
|
|
|
||
|
|
expect(model._heightChanged).toBe(true);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('height reference without a scene rejects', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
show : true
|
||
|
|
}).otherwise(function(error) {
|
||
|
|
expect(error.message).toEqual('Height reference is not supported without a scene and globe.');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('changing height reference without a scene throws DeveloperError', function() {
|
||
|
|
scene.globe = createMockGlobe();
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
model.heightReference = HeightReference.CLAMP_TO_GROUND;
|
||
|
|
|
||
|
|
expect(function () {
|
||
|
|
return scene.renderForSpecs();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('height reference without a globe rejects', function() {
|
||
|
|
scene.globe = undefined;
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
heightReference : HeightReference.CLAMP_TO_GROUND,
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
scene : scene,
|
||
|
|
show : true
|
||
|
|
}).otherwise(function(error) {
|
||
|
|
expect(error.message).toEqual('Height reference is not supported without a scene and globe.');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
it('changing height reference without a globe throws DeveloperError', function() {
|
||
|
|
scene.globe = undefined;
|
||
|
|
return loadModelJson(texturedBoxModel.gltf, {
|
||
|
|
position : Cartesian3.fromDegrees(-72.0, 40.0),
|
||
|
|
show : true
|
||
|
|
}).then(function(model) {
|
||
|
|
model.heightReference = HeightReference.CLAMP_TO_GROUND;
|
||
|
|
|
||
|
|
expect(function () {
|
||
|
|
return scene.renderForSpecs();
|
||
|
|
}).toThrowDeveloperError();
|
||
|
|
|
||
|
|
primitives.remove(model);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}, 'WebGL');
|