import {
|
Cartesian2,
|
Cartesian3,
|
combine,
|
DequantizationPipelineStage,
|
GltfLoader,
|
Math as CesiumMath,
|
Resource,
|
ResourceCache,
|
ShaderBuilder,
|
} from "../../../Source/Cesium.js";
|
import createScene from "../../createScene.js";
|
import waitForLoaderProcess from "../../waitForLoaderProcess.js";
|
import ShaderBuilderTester from "../../ShaderBuilderTester.js";
|
|
describe("Scene/ModelExperimental/DequantizationPipelineStage", function () {
|
var boxUncompressed =
|
"./Data/Models/GltfLoader/BoxTextured/glTF-Binary/BoxTextured.glb";
|
var boxWithLines =
|
"./Data/Models/DracoCompression/BoxWithLines/BoxWithLines.gltf";
|
var milkTruck =
|
"./Data/Models/DracoCompression/CesiumMilkTruck/CesiumMilkTruck.gltf";
|
|
var scene;
|
var gltfLoaders = [];
|
|
beforeAll(function () {
|
scene = createScene();
|
});
|
|
afterAll(function () {
|
scene.destroyForSpecs();
|
});
|
|
afterEach(function () {
|
var gltfLoadersLength = gltfLoaders.length;
|
for (var i = 0; i < gltfLoadersLength; ++i) {
|
var gltfLoader = gltfLoaders[i];
|
if (!gltfLoader.isDestroyed()) {
|
gltfLoader.destroy();
|
}
|
}
|
gltfLoaders.length = 0;
|
ResourceCache.clearForSpecs();
|
});
|
|
function getOptions(gltfPath, options) {
|
var resource = new Resource({
|
url: gltfPath,
|
});
|
|
return combine(options, {
|
gltfResource: resource,
|
incrementallyLoadTextures: false, // Default to false if not supplied
|
});
|
}
|
|
function loadGltf(gltfPath, options) {
|
var gltfLoader = new GltfLoader(getOptions(gltfPath, options));
|
gltfLoaders.push(gltfLoader);
|
gltfLoader.load();
|
|
return waitForLoaderProcess(gltfLoader, scene);
|
}
|
|
it("adds a dequantization function", function () {
|
var uniformMap = {};
|
var shaderBuilder = new ShaderBuilder();
|
var renderResources = {
|
uniformMap: uniformMap,
|
shaderBuilder: shaderBuilder,
|
};
|
return loadGltf(boxWithLines).then(function (gltfLoader) {
|
var components = gltfLoader.components;
|
var primitive = components.nodes[1].primitives[0];
|
DequantizationPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
|
"USE_DEQUANTIZATION",
|
]);
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
|
DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS,
|
[
|
" attributes.normalMC = czm_octDecode(a_quantized_normalMC, model_normalizationRange_normalMC).zxy;",
|
" attributes.positionMC = model_quantizedVolumeOffset_positionMC + a_quantized_positionMC * model_quantizedVolumeStepSize_positionMC;",
|
]
|
);
|
ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, []);
|
expect(shaderBuilder._fragmentShaderParts.functionIds).toEqual([]);
|
});
|
});
|
|
it("adds dequantization uniforms", function () {
|
var uniformMap = {};
|
var shaderBuilder = new ShaderBuilder();
|
var renderResources = {
|
uniformMap: uniformMap,
|
shaderBuilder: shaderBuilder,
|
};
|
|
return loadGltf(milkTruck).then(function (gltfLoader) {
|
var components = gltfLoader.components;
|
var primitive = components.nodes[0].primitives[0];
|
DequantizationPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexUniforms(shaderBuilder, [
|
"uniform float model_normalizationRange_normalMC;",
|
"uniform vec2 model_quantizedVolumeOffset_texCoord_0;",
|
"uniform vec2 model_quantizedVolumeStepSize_texCoord_0;",
|
"uniform vec3 model_quantizedVolumeOffset_positionMC;",
|
"uniform vec3 model_quantizedVolumeStepSize_positionMC;",
|
]);
|
ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, []);
|
|
var uniformValues = {
|
normalRange: uniformMap.model_normalizationRange_normalMC(),
|
positionOffset: uniformMap.model_quantizedVolumeOffset_positionMC(),
|
positionStepSize: uniformMap.model_quantizedVolumeStepSize_positionMC(),
|
texCoordOffset: uniformMap.model_quantizedVolumeOffset_texCoord_0(),
|
texCoordStepSize: uniformMap.model_quantizedVolumeStepSize_texCoord_0(),
|
};
|
|
var expected = {
|
normalRange: 1023,
|
positionOffset: new Cartesian3(
|
-2.430910110473633,
|
0.2667999863624573,
|
-1.3960000276565552
|
),
|
positionStepSize: new Cartesian3(
|
0.0002971928118058615,
|
0.0002971928118058615,
|
0.0002971928118058615
|
),
|
texCoordOffset: new Cartesian2(
|
0.0029563899151980877,
|
0.015672028064727783
|
),
|
texCoordStepSize: new Cartesian2(
|
0.0002397004064622816,
|
0.0002397004064622816
|
),
|
};
|
|
expect(uniformValues).toEqualEpsilon(expected, CesiumMath.EPSILON15);
|
});
|
});
|
|
it("skips non-quantized attributes", function () {
|
var uniformMap = {};
|
var shaderBuilder = new ShaderBuilder();
|
var renderResources = {
|
uniformMap: uniformMap,
|
shaderBuilder: shaderBuilder,
|
};
|
|
return loadGltf(boxUncompressed).then(function (gltfLoader) {
|
var components = gltfLoader.components;
|
var primitive = components.nodes[1].primitives[0];
|
DequantizationPipelineStage.process(renderResources, primitive);
|
|
ShaderBuilderTester.expectHasVertexUniforms(shaderBuilder, []);
|
ShaderBuilderTester.expectHasFragmentUniforms(shaderBuilder, []);
|
expect(uniformMap).toEqual({});
|
|
ShaderBuilderTester.expectHasVertexDefines(shaderBuilder, [
|
"USE_DEQUANTIZATION",
|
]);
|
ShaderBuilderTester.expectHasVertexFunction(
|
shaderBuilder,
|
DequantizationPipelineStage.FUNCTION_ID_DEQUANTIZATION_STAGE_VS,
|
DequantizationPipelineStage.FUNCTION_SIGNATURE_DEQUANTIZATION_STAGE_VS,
|
[]
|
);
|
ShaderBuilderTester.expectHasFragmentDefines(shaderBuilder, []);
|
expect(shaderBuilder._fragmentShaderParts.functionIds).toEqual([]);
|
});
|
});
|
});
|
