import { Cartesian3, defined } from "../../Source/Cesium.js";
|
import { ComputeEngine } from "../../Source/Cesium.js";
|
import { Pass } from "../../Source/Cesium.js";
|
import { OctahedralProjectedCubeMap } from "../../Source/Cesium.js";
|
import createContext from "../createContext.js";
|
import createFrameState from "../createFrameState.js";
|
import pollToPromise from "../pollToPromise.js";
|
|
describe(
|
"Scene/OctahedralProjectedCubeMap",
|
function () {
|
var context;
|
var computeEngine;
|
var octahedralMap;
|
|
var environmentMapUrl =
|
"./Data/EnvironmentMap/kiara_6_afternoon_2k_ibl.ktx2";
|
var fsOctahedralMap =
|
"uniform sampler2D projectedMap;" +
|
"uniform vec2 textureSize;" +
|
"uniform vec3 direction;" +
|
"uniform float lod;" +
|
"uniform float maxLod;" +
|
"void main() {" +
|
" vec3 color = czm_sampleOctahedralProjection(projectedMap, textureSize, direction, lod, maxLod);" +
|
" gl_FragColor = vec4(color, 1.0);" +
|
"}";
|
|
var fsCubeMap =
|
"uniform samplerCube cubeMap;" +
|
"uniform vec3 direction;" +
|
"void main() {" +
|
" vec4 rgba = textureCube(cubeMap, direction);" +
|
" gl_FragColor = vec4(rgba.rgb, 1.0);" +
|
"}";
|
|
beforeAll(function () {
|
context = createContext();
|
computeEngine = new ComputeEngine(context);
|
});
|
|
afterAll(function () {
|
context.destroyForSpecs();
|
computeEngine.destroy();
|
});
|
|
afterEach(function () {
|
octahedralMap = octahedralMap && octahedralMap.destroy();
|
context.textureCache.destroyReleasedTextures();
|
});
|
|
function executeCommands(frameState) {
|
var length = frameState.commandList.length;
|
for (var i = 0; i < length; ++i) {
|
var command = frameState.commandList[i];
|
if (command.pass === Pass.COMPUTE) {
|
command.execute(computeEngine);
|
} else {
|
command.execute(context);
|
}
|
}
|
frameState.commandList.length = 0;
|
}
|
|
function sampleOctahedralMap(octahedralMap, direction, lod, callback) {
|
expect({
|
context: context,
|
fragmentShader: fsOctahedralMap,
|
uniformMap: {
|
projectedMap: function () {
|
return octahedralMap.texture;
|
},
|
textureSize: function () {
|
return octahedralMap.texture.dimensions;
|
},
|
direction: function () {
|
return direction;
|
},
|
lod: function () {
|
return lod;
|
},
|
maxLod: function () {
|
return octahedralMap.maximumMipmapLevel;
|
},
|
},
|
}).contextToRenderAndCall(callback);
|
}
|
|
function sampleCubeMap(cubeMap, direction, callback) {
|
expect({
|
context: context,
|
fragmentShader: fsCubeMap,
|
uniformMap: {
|
cubeMap: function () {
|
return cubeMap;
|
},
|
direction: function () {
|
return direction;
|
},
|
},
|
}).contextToRenderAndCall(callback);
|
}
|
|
function expectCubeMapAndOctahedralMapEqual(octahedralMap, direction, lod) {
|
return sampleCubeMap(octahedralMap._cubeMaps[lod], direction, function (
|
cubeMapColor
|
) {
|
var directionFlipY = direction.clone();
|
directionFlipY.y *= -1;
|
|
sampleOctahedralMap(octahedralMap, directionFlipY, lod, function (
|
octahedralMapColor
|
) {
|
return expect(cubeMapColor).toEqualEpsilon(octahedralMapColor, 6);
|
});
|
});
|
}
|
|
it("creates a packed texture with the right dimensions", function () {
|
if (!OctahedralProjectedCubeMap.isSupported(context)) {
|
return;
|
}
|
|
octahedralMap = new OctahedralProjectedCubeMap(environmentMapUrl);
|
var frameState = createFrameState(context);
|
|
return pollToPromise(function () {
|
octahedralMap.update(frameState);
|
return octahedralMap.ready;
|
}).then(function () {
|
expect(octahedralMap.texture.width).toEqual(770);
|
expect(octahedralMap.texture.height).toEqual(512);
|
expect(octahedralMap.maximumMipmapLevel).toEqual(5);
|
});
|
});
|
|
it("correctly projects the given cube map and all mip levels", function () {
|
if (!OctahedralProjectedCubeMap.isSupported(context)) {
|
return;
|
}
|
|
octahedralMap = new OctahedralProjectedCubeMap(environmentMapUrl);
|
var frameState = createFrameState(context);
|
|
return pollToPromise(function () {
|
// We manually call update and execute the commands
|
// because calling scene.renderForSpecs does not
|
// actually execute these commands, and we need
|
// to get the output of the texture.
|
octahedralMap.update(frameState);
|
executeCommands(frameState);
|
|
return octahedralMap.ready;
|
}).then(function () {
|
var directions = {
|
positiveX: new Cartesian3(1, 0, 0),
|
negativeX: new Cartesian3(-1, 0, 0),
|
positiveY: new Cartesian3(0, 1, 0),
|
negativeY: new Cartesian3(0, -1, 0),
|
positiveZ: new Cartesian3(0, 0, 1),
|
negativeZ: new Cartesian3(0, 0, -1),
|
};
|
|
for (
|
var mipLevel = 0;
|
mipLevel < octahedralMap.maximumMipmapLevel;
|
mipLevel++
|
) {
|
for (var key in directions) {
|
if (directions.hasOwnProperty(key)) {
|
var direction = directions[key];
|
|
expectCubeMapAndOctahedralMapEqual(
|
octahedralMap,
|
direction,
|
mipLevel
|
);
|
}
|
}
|
}
|
});
|
});
|
|
it("caches projected textures", function () {
|
if (!OctahedralProjectedCubeMap.isSupported(context)) {
|
return;
|
}
|
|
var projection = new OctahedralProjectedCubeMap(environmentMapUrl);
|
var frameState = createFrameState(context);
|
|
return pollToPromise(function () {
|
projection.update(frameState);
|
return projection.ready;
|
})
|
.then(function () {
|
var projection2 = new OctahedralProjectedCubeMap(environmentMapUrl);
|
projection2.update(frameState);
|
expect(projection2.ready).toEqual(true);
|
expect(projection.texture).toEqual(projection2.texture);
|
projection2.destroy();
|
})
|
.always(function () {
|
projection.destroy();
|
});
|
});
|
|
it("rejects when environment map fails to load.", function () {
|
if (!OctahedralProjectedCubeMap.isSupported(context)) {
|
return;
|
}
|
|
var projection = new OctahedralProjectedCubeMap("http://invalid.url");
|
var frameState = createFrameState(context);
|
var error;
|
|
projection.readyPromise
|
.then(function () {
|
fail("Should not resolve.");
|
})
|
.otherwise(function (e) {
|
error = e;
|
expect(error).toBeDefined();
|
expect(projection.ready).toEqual(false);
|
});
|
|
return pollToPromise(function () {
|
projection.update(frameState);
|
return defined(error);
|
});
|
});
|
},
|
"WebGL"
|
);
|
