478 lines
15 KiB
JavaScript
478 lines
15 KiB
JavaScript
import {
|
|
colorDecodeId,
|
|
colorEncodeId,
|
|
getBlankImageData,
|
|
writeLineSegmentToBuffers,
|
|
writePointFeatureToBuffers,
|
|
writePolygonTrianglesToBuffers,
|
|
} from '../../../../../../src/ol/render/webgl/utils.js';
|
|
import {
|
|
compose as composeTransform,
|
|
create as createTransform,
|
|
makeInverse as makeInverseTransform,
|
|
} from '../../../../../../src/ol/transform.js';
|
|
|
|
describe('webgl render utils', function () {
|
|
describe('writePointFeatureToBuffers', function () {
|
|
let vertexBuffer, indexBuffer, instructions;
|
|
|
|
beforeEach(function () {
|
|
vertexBuffer = new Float32Array(100);
|
|
indexBuffer = new Uint32Array(100);
|
|
instructions = new Float32Array(100);
|
|
|
|
instructions.set([0, 0, 0, 0, 10, 11]);
|
|
});
|
|
|
|
it('writes correctly to the buffers (without custom attributes)', function () {
|
|
const stride = 3;
|
|
const positions = writePointFeatureToBuffers(
|
|
instructions,
|
|
4,
|
|
vertexBuffer,
|
|
indexBuffer,
|
|
0
|
|
);
|
|
|
|
expect(vertexBuffer[0]).to.eql(10);
|
|
expect(vertexBuffer[1]).to.eql(11);
|
|
expect(vertexBuffer[2]).to.eql(0);
|
|
|
|
expect(vertexBuffer[stride + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride + 2]).to.eql(1);
|
|
|
|
expect(vertexBuffer[stride * 2 + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride * 2 + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride * 2 + 2]).to.eql(2);
|
|
|
|
expect(vertexBuffer[stride * 3 + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride * 3 + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride * 3 + 2]).to.eql(3);
|
|
|
|
expect(indexBuffer[0]).to.eql(0);
|
|
expect(indexBuffer[1]).to.eql(1);
|
|
expect(indexBuffer[2]).to.eql(3);
|
|
expect(indexBuffer[3]).to.eql(1);
|
|
expect(indexBuffer[4]).to.eql(2);
|
|
expect(indexBuffer[5]).to.eql(3);
|
|
|
|
expect(positions.indexPosition).to.eql(6);
|
|
expect(positions.vertexPosition).to.eql(stride * 4);
|
|
});
|
|
|
|
it('writes correctly to the buffers (with 2 custom attributes)', function () {
|
|
instructions.set([0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13]);
|
|
const stride = 5;
|
|
const positions = writePointFeatureToBuffers(
|
|
instructions,
|
|
8,
|
|
vertexBuffer,
|
|
indexBuffer,
|
|
2
|
|
);
|
|
|
|
expect(vertexBuffer[0]).to.eql(10);
|
|
expect(vertexBuffer[1]).to.eql(11);
|
|
expect(vertexBuffer[2]).to.eql(0);
|
|
expect(vertexBuffer[3]).to.eql(12);
|
|
expect(vertexBuffer[4]).to.eql(13);
|
|
|
|
expect(vertexBuffer[stride + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride + 2]).to.eql(1);
|
|
expect(vertexBuffer[stride + 3]).to.eql(12);
|
|
expect(vertexBuffer[stride + 4]).to.eql(13);
|
|
|
|
expect(vertexBuffer[stride * 2 + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride * 2 + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride * 2 + 2]).to.eql(2);
|
|
expect(vertexBuffer[stride * 2 + 3]).to.eql(12);
|
|
expect(vertexBuffer[stride * 2 + 4]).to.eql(13);
|
|
|
|
expect(vertexBuffer[stride * 3 + 0]).to.eql(10);
|
|
expect(vertexBuffer[stride * 3 + 1]).to.eql(11);
|
|
expect(vertexBuffer[stride * 3 + 2]).to.eql(3);
|
|
expect(vertexBuffer[stride * 3 + 3]).to.eql(12);
|
|
expect(vertexBuffer[stride * 3 + 4]).to.eql(13);
|
|
|
|
expect(indexBuffer[0]).to.eql(0);
|
|
expect(indexBuffer[1]).to.eql(1);
|
|
expect(indexBuffer[2]).to.eql(3);
|
|
expect(indexBuffer[3]).to.eql(1);
|
|
expect(indexBuffer[4]).to.eql(2);
|
|
expect(indexBuffer[5]).to.eql(3);
|
|
|
|
expect(positions.indexPosition).to.eql(6);
|
|
expect(positions.vertexPosition).to.eql(stride * 4);
|
|
});
|
|
|
|
it('correctly chains buffer writes', function () {
|
|
instructions.set([10, 11, 20, 21, 30, 31]);
|
|
const stride = 3;
|
|
let positions = writePointFeatureToBuffers(
|
|
instructions,
|
|
0,
|
|
vertexBuffer,
|
|
indexBuffer,
|
|
0
|
|
);
|
|
positions = writePointFeatureToBuffers(
|
|
instructions,
|
|
2,
|
|
vertexBuffer,
|
|
indexBuffer,
|
|
0,
|
|
positions
|
|
);
|
|
positions = writePointFeatureToBuffers(
|
|
instructions,
|
|
4,
|
|
vertexBuffer,
|
|
indexBuffer,
|
|
0,
|
|
positions
|
|
);
|
|
|
|
expect(vertexBuffer[0]).to.eql(10);
|
|
expect(vertexBuffer[1]).to.eql(11);
|
|
expect(vertexBuffer[2]).to.eql(0);
|
|
|
|
expect(vertexBuffer[stride * 4 + 0]).to.eql(20);
|
|
expect(vertexBuffer[stride * 4 + 1]).to.eql(21);
|
|
expect(vertexBuffer[stride * 4 + 2]).to.eql(0);
|
|
|
|
expect(vertexBuffer[stride * 8 + 0]).to.eql(30);
|
|
expect(vertexBuffer[stride * 8 + 1]).to.eql(31);
|
|
expect(vertexBuffer[stride * 8 + 2]).to.eql(0);
|
|
|
|
expect(indexBuffer[6 + 0]).to.eql(4);
|
|
expect(indexBuffer[6 + 1]).to.eql(5);
|
|
expect(indexBuffer[6 + 2]).to.eql(7);
|
|
expect(indexBuffer[6 + 3]).to.eql(5);
|
|
expect(indexBuffer[6 + 4]).to.eql(6);
|
|
expect(indexBuffer[6 + 5]).to.eql(7);
|
|
|
|
expect(indexBuffer[6 * 2 + 0]).to.eql(8);
|
|
expect(indexBuffer[6 * 2 + 1]).to.eql(9);
|
|
expect(indexBuffer[6 * 2 + 2]).to.eql(11);
|
|
expect(indexBuffer[6 * 2 + 3]).to.eql(9);
|
|
expect(indexBuffer[6 * 2 + 4]).to.eql(10);
|
|
expect(indexBuffer[6 * 2 + 5]).to.eql(11);
|
|
|
|
expect(positions.indexPosition).to.eql(6 * 3);
|
|
expect(positions.vertexPosition).to.eql(stride * 4 * 3);
|
|
});
|
|
});
|
|
|
|
describe('writeLineSegmentToBuffers', function () {
|
|
let vertexArray, indexArray, instructions;
|
|
let instructionsTransform, invertInstructionsTransform;
|
|
|
|
beforeEach(function () {
|
|
vertexArray = [];
|
|
indexArray = [];
|
|
|
|
instructions = new Float32Array(100);
|
|
|
|
instructionsTransform = createTransform();
|
|
invertInstructionsTransform = createTransform();
|
|
composeTransform(instructionsTransform, 0, 0, 10, 20, 0, -50, 200);
|
|
makeInverseTransform(invertInstructionsTransform, instructionsTransform);
|
|
});
|
|
|
|
describe('isolated segment', function () {
|
|
beforeEach(function () {
|
|
instructions.set([0, 0, 0, 2, 5, 5, 25, 5]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
4,
|
|
6,
|
|
null,
|
|
null,
|
|
vertexArray,
|
|
indexArray,
|
|
[],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('generates a quad for the segment', function () {
|
|
expect(vertexArray).to.have.length(20);
|
|
expect(vertexArray).to.eql([
|
|
5, 5, 25, 5, 0, 5, 5, 25, 5, 100000000, 5, 5, 25, 5, 200000000, 5, 5,
|
|
25, 5, 300000000,
|
|
]);
|
|
expect(indexArray).to.have.length(6);
|
|
expect(indexArray).to.eql([0, 1, 2, 1, 3, 2]);
|
|
});
|
|
});
|
|
|
|
describe('isolated segment with custom attributes', function () {
|
|
beforeEach(function () {
|
|
instructions.set([888, 999, 2, 5, 5, 25, 5]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
3,
|
|
5,
|
|
null,
|
|
null,
|
|
vertexArray,
|
|
indexArray,
|
|
[888, 999],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('adds custom attributes in the vertices buffer', function () {
|
|
expect(vertexArray).to.have.length(28);
|
|
expect(vertexArray).to.eql([
|
|
5, 5, 25, 5, 0, 888, 999, 5, 5, 25, 5, 100000000, 888, 999, 5, 5, 25,
|
|
5, 200000000, 888, 999, 5, 5, 25, 5, 300000000, 888, 999,
|
|
]);
|
|
});
|
|
it('does not impact indices array', function () {
|
|
expect(indexArray).to.have.length(6);
|
|
});
|
|
});
|
|
|
|
describe('segment with a point coming before it, join angle < PI', function () {
|
|
beforeEach(function () {
|
|
instructions.set([2, 5, 5, 25, 5, 5, 20]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
1,
|
|
3,
|
|
5,
|
|
null,
|
|
vertexArray,
|
|
indexArray,
|
|
[],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('generate the correct amount of vertices', () => {
|
|
expect(vertexArray).to.have.length(20);
|
|
});
|
|
it('correctly encodes the join angle', () => {
|
|
expect(vertexArray[4]).to.eql(2356);
|
|
expect(vertexArray[9]).to.eql(100002356);
|
|
expect(vertexArray[14]).to.eql(200002356);
|
|
expect(vertexArray[19]).to.eql(300002356);
|
|
});
|
|
it('does not impact indices array', function () {
|
|
expect(indexArray).to.have.length(6);
|
|
});
|
|
});
|
|
|
|
describe('segment with a point coming before it, join angle > PI', function () {
|
|
beforeEach(function () {
|
|
instructions.set([2, 5, 5, 25, 5, 5, -10]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
1,
|
|
3,
|
|
5,
|
|
null,
|
|
vertexArray,
|
|
indexArray,
|
|
[],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('generate the correct amount of vertices', () => {
|
|
expect(vertexArray).to.have.length(20);
|
|
});
|
|
it('correctly encodes the join angle', () => {
|
|
expect(vertexArray[4]).to.eql(7069);
|
|
expect(vertexArray[9]).to.eql(100007069);
|
|
expect(vertexArray[14]).to.eql(200007069);
|
|
expect(vertexArray[19]).to.eql(300007069);
|
|
});
|
|
it('does not impact indices array', function () {
|
|
expect(indexArray).to.have.length(6);
|
|
});
|
|
});
|
|
|
|
describe('segment with a point coming after it, join angle < PI', function () {
|
|
beforeEach(function () {
|
|
instructions.set([2, 5, 5, 25, 5, 5, 20]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
1,
|
|
3,
|
|
null,
|
|
5,
|
|
vertexArray,
|
|
indexArray,
|
|
[],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('generate the correct amount of vertices', () => {
|
|
expect(vertexArray).to.have.length(20);
|
|
});
|
|
it('correctly encodes the join angle', () => {
|
|
expect(vertexArray[4]).to.eql(88870000);
|
|
expect(vertexArray[9]).to.eql(188870000);
|
|
expect(vertexArray[14]).to.eql(288870000);
|
|
expect(vertexArray[19]).to.eql(388870000);
|
|
});
|
|
it('does not impact indices array', function () {
|
|
expect(indexArray).to.have.length(6);
|
|
});
|
|
});
|
|
|
|
describe('segment with a point coming after it, join angle > PI', function () {
|
|
beforeEach(function () {
|
|
instructions.set([2, 5, 5, 25, 5, 25, -10]);
|
|
writeLineSegmentToBuffers(
|
|
instructions,
|
|
1,
|
|
3,
|
|
null,
|
|
5,
|
|
vertexArray,
|
|
indexArray,
|
|
[],
|
|
instructionsTransform,
|
|
invertInstructionsTransform
|
|
);
|
|
});
|
|
it('generate the correct amount of vertices', () => {
|
|
expect(vertexArray).to.have.length(20);
|
|
});
|
|
it('correctly encodes join angles', () => {
|
|
expect(vertexArray[4]).to.eql(23560000);
|
|
expect(vertexArray[9]).to.eql(123560000);
|
|
expect(vertexArray[14]).to.eql(223560000);
|
|
expect(vertexArray[19]).to.eql(323560000);
|
|
});
|
|
it('does not impact indices array', function () {
|
|
expect(indexArray).to.have.length(6);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('writePolygonTrianglesToBuffers', function () {
|
|
let vertexArray, indexArray, instructions, newIndex;
|
|
|
|
beforeEach(function () {
|
|
vertexArray = [];
|
|
indexArray = [];
|
|
instructions = new Float32Array(100);
|
|
});
|
|
|
|
describe('polygon with a hole', function () {
|
|
beforeEach(function () {
|
|
instructions.set([
|
|
0, 0, 0, 2, 6, 5, 0, 0, 10, 0, 15, 6, 10, 12, 0, 12, 0, 0, 3, 3, 5, 1,
|
|
7, 3, 5, 5, 3, 3,
|
|
]);
|
|
newIndex = writePolygonTrianglesToBuffers(
|
|
instructions,
|
|
3,
|
|
vertexArray,
|
|
indexArray,
|
|
0
|
|
);
|
|
});
|
|
it('generates triangles correctly', function () {
|
|
expect(vertexArray).to.have.length(22);
|
|
expect(vertexArray).to.eql([
|
|
0, 0, 10, 0, 15, 6, 10, 12, 0, 12, 0, 0, 3, 3, 5, 1, 7, 3, 5, 5, 3, 3,
|
|
]);
|
|
expect(indexArray).to.have.length(24);
|
|
expect(indexArray).to.eql([
|
|
4, 0, 9, 7, 10, 0, 1, 2, 3, 3, 4, 9, 7, 0, 1, 3, 9, 8, 8, 7, 1, 1, 3,
|
|
8,
|
|
]);
|
|
});
|
|
it('correctly returns the new index', function () {
|
|
expect(newIndex).to.eql(28);
|
|
});
|
|
});
|
|
|
|
describe('polygon with a hole and custom attributes', function () {
|
|
beforeEach(function () {
|
|
instructions.set([
|
|
0, 0, 0, 1234, 2, 6, 5, 0, 0, 10, 0, 15, 6, 10, 12, 0, 12, 0, 0, 3, 3,
|
|
5, 1, 7, 3, 5, 5, 3, 3,
|
|
]);
|
|
newIndex = writePolygonTrianglesToBuffers(
|
|
instructions,
|
|
3,
|
|
vertexArray,
|
|
indexArray,
|
|
1
|
|
);
|
|
});
|
|
it('generates triangles correctly', function () {
|
|
expect(vertexArray).to.have.length(33);
|
|
expect(vertexArray).to.eql([
|
|
0, 0, 1234, 10, 0, 1234, 15, 6, 1234, 10, 12, 1234, 0, 12, 1234, 0, 0,
|
|
1234, 3, 3, 1234, 5, 1, 1234, 7, 3, 1234, 5, 5, 1234, 3, 3, 1234,
|
|
]);
|
|
expect(indexArray).to.have.length(24);
|
|
expect(indexArray).to.eql([
|
|
4, 0, 9, 7, 10, 0, 1, 2, 3, 3, 4, 9, 7, 0, 1, 3, 9, 8, 8, 7, 1, 1, 3,
|
|
8,
|
|
]);
|
|
});
|
|
it('correctly returns the new index', function () {
|
|
expect(newIndex).to.eql(29);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('getBlankImageData', function () {
|
|
it('creates a 1x1 white texture', function () {
|
|
const texture = getBlankImageData();
|
|
expect(texture.height).to.eql(1);
|
|
expect(texture.width).to.eql(1);
|
|
expect(texture.data[0]).to.eql(255);
|
|
expect(texture.data[1]).to.eql(255);
|
|
expect(texture.data[2]).to.eql(255);
|
|
expect(texture.data[3]).to.eql(255);
|
|
});
|
|
});
|
|
|
|
describe('colorEncodeId and colorDecodeId', function () {
|
|
it('correctly encodes and decodes ids', function () {
|
|
expect(colorDecodeId(colorEncodeId(0))).to.eql(0);
|
|
expect(colorDecodeId(colorEncodeId(1))).to.eql(1);
|
|
expect(colorDecodeId(colorEncodeId(123))).to.eql(123);
|
|
expect(colorDecodeId(colorEncodeId(12345))).to.eql(12345);
|
|
expect(colorDecodeId(colorEncodeId(123456))).to.eql(123456);
|
|
expect(colorDecodeId(colorEncodeId(91612))).to.eql(91612);
|
|
expect(colorDecodeId(colorEncodeId(1234567890))).to.eql(1234567890);
|
|
});
|
|
|
|
it('correctly reuses array', function () {
|
|
const arr = [];
|
|
expect(colorEncodeId(123, arr)).to.be(arr);
|
|
});
|
|
|
|
it('is compatible with Uint8Array storage', function () {
|
|
const encoded = colorEncodeId(91612);
|
|
const typed = Uint8Array.of(
|
|
encoded[0] * 255,
|
|
encoded[1] * 255,
|
|
encoded[2] * 255,
|
|
encoded[3] * 255
|
|
);
|
|
const arr = [
|
|
typed[0] / 255,
|
|
typed[1] / 255,
|
|
typed[2] / 255,
|
|
typed[3] / 255,
|
|
];
|
|
const decoded = colorDecodeId(arr);
|
|
expect(decoded).to.eql(91612);
|
|
});
|
|
});
|
|
});
|