2022.1.6

15832144755

2022-01-06 7b4c8991dca9cf2a809a95e239d144697d3afb56

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import { BoundingRectangle } from "../../Source/Cesium.js";
import { Color } from "../../Source/Cesium.js";
import { Resource } from "../../Source/Cesium.js";
import { Texture } from "../../Source/Cesium.js";
import { Material } from "../../Source/Cesium.js";
import { ViewportQuad } from "../../Source/Cesium.js";
import createScene from "../createScene.js";
import pollToPromise from "../pollToPromise.js";
 
describe(
  "Scene/ViewportQuad",
  function () {
    var scene;
    var viewportQuad;
    var testImage;
 
    beforeAll(function () {
      scene = createScene();
      return Resource.fetchImage("./Data/Images/Red16x16.png").then(function (
        image
      ) {
        testImage = image;
      });
    });
 
    afterAll(function () {
      scene.destroyForSpecs();
    });
 
    beforeEach(function () {
      viewportQuad = new ViewportQuad();
      viewportQuad.rectangle = new BoundingRectangle(0, 0, 2, 2);
    });
 
    afterEach(function () {
      scene.primitives.removeAll();
    });
 
    it("constructs with a rectangle", function () {
      var rectangle = new BoundingRectangle(1.0, 2.0, 3.0, 4.0);
      var quad = new ViewportQuad(rectangle);
      expect(quad.rectangle).toEqual(rectangle);
    });
 
    it("constructs with a material", function () {
      var material = Material.fromType(Material.StripeType);
      var quad = new ViewportQuad(undefined, material);
      expect(quad.material.type).toEqual(material.type);
    });
 
    it("gets the default color", function () {
      expect(viewportQuad.material.uniforms.color).toEqual(
        new Color(1.0, 1.0, 1.0, 1.0)
      );
    });
 
    it("throws when rendered without a rectangle", function () {
      viewportQuad.rectangle = undefined;
      scene.primitives.add(viewportQuad);
 
      expect(function () {
        scene.renderForSpecs();
      }).toThrowDeveloperError();
    });
 
    it("throws when rendered without a material", function () {
      viewportQuad.material = undefined;
      scene.primitives.add(viewportQuad);
 
      expect(function () {
        scene.renderForSpecs();
      }).toThrowDeveloperError();
    });
 
    it("does not render when show is false", function () {
      viewportQuad.show = false;
      expect(scene).toRender([0, 0, 0, 255]);
      scene.primitives.add(viewportQuad);
      expect(scene).toRender([0, 0, 0, 255]);
    });
 
    it("renders material", function () {
      expect(scene).toRender([0, 0, 0, 255]);
      scene.primitives.add(viewportQuad);
      expect(scene).notToRender([0, 0, 0, 255]);
    });
 
    it("renders user created texture", function () {
      var texture = new Texture({
        context: scene.context,
        source: testImage,
      });
 
      viewportQuad.material = Material.fromType(Material.ImageType);
      viewportQuad.material.uniforms.image = texture;
 
      pollToPromise(function () {
        return viewportQuad.material._loadedImages.length !== 0;
      }).then(function () {
        expect(scene).toRender([0, 0, 0, 255]);
        scene.primitives.add(viewportQuad);
        expect(scene).toRender([255, 0, 0, 255]);
      });
    });
 
    it("updates rectangle", function () {
      var otherRectangle = new BoundingRectangle(0, 0, 4, 4);
 
      scene.primitives.add(viewportQuad);
      scene.renderForSpecs();
 
      viewportQuad.rectangle = otherRectangle;
      scene.renderForSpecs();
      expect(scene.frameState.commandList[0].renderState.viewport).toEqual(
        otherRectangle
      );
    });
 
    it("isDestroyed", function () {
      var boundRectangle = new BoundingRectangle(0, 0, 10, 10);
      var vq = new ViewportQuad(boundRectangle);
 
      expect(vq.isDestroyed()).toEqual(false);
      vq.destroy();
      expect(vq.isDestroyed()).toEqual(true);
    });
  },
  "WebGL"
);