洪水淹没

guoshilong

2023-02-27 4d8c6dd77427e8e581fda17b6b65ba86bfb7a815

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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
import BoundingSphere from '../Core/BoundingSphere.js';
import Cartesian3 from '../Core/Cartesian3.js';
import Check from '../Core/Check.js';
import ColorGeometryInstanceAttribute from '../Core/ColorGeometryInstanceAttribute.js';
import GeometryInstance from '../Core/GeometryInstance.js';
import CesiumMath from '../Core/Math.js';
import Matrix4 from '../Core/Matrix4.js';
import SphereOutlineGeometry from '../Core/SphereOutlineGeometry.js';
import PerInstanceColorAppearance from './PerInstanceColorAppearance.js';
import Primitive from './Primitive.js';
 
    /**
     * A tile bounding volume specified as a sphere.
     * @alias TileBoundingSphere
     * @constructor
     *
     * @param {Cartesian3} [center=Cartesian3.ZERO] The center of the bounding sphere.
     * @param {Number} [radius=0.0] The radius of the bounding sphere.
     *
     * @private
     */
    function TileBoundingSphere(center, radius) {
        if (radius === 0) {
            radius = CesiumMath.EPSILON7;
        }
        this._boundingSphere = new BoundingSphere(center, radius);
    }
 
    Object.defineProperties(TileBoundingSphere.prototype, {
        /**
         * The center of the bounding sphere
         *
         * @memberof TileBoundingSphere.prototype
         *
         * @type {Cartesian3}
         * @readonly
         */
        center : {
            get : function() {
                return this._boundingSphere.center;
            }
        },
 
        /**
         * The radius of the bounding sphere
         *
         * @memberof TileBoundingSphere.prototype
         *
         * @type {Number}
         * @readonly
         */
        radius : {
            get : function() {
                return this._boundingSphere.radius;
            }
        },
 
        /**
         * The underlying bounding volume
         *
         * @memberof TileBoundingSphere.prototype
         *
         * @type {Object}
         * @readonly
         */
        boundingVolume : {
            get : function() {
                return this._boundingSphere;
            }
        },
        /**
         * The underlying bounding sphere
         *
         * @memberof TileBoundingSphere.prototype
         *
         * @type {BoundingSphere}
         * @readonly
         */
        boundingSphere : {
            get : function() {
                return this._boundingSphere;
            }
        }
    });
 
    /**
     * Computes the distance between this bounding sphere and the camera attached to frameState.
     *
     * @param {FrameState} frameState The frameState to which the camera is attached.
     * @returns {Number} The distance between the camera and the bounding sphere in meters. Returns 0 if the camera is inside the bounding volume.
     *
     */
    TileBoundingSphere.prototype.distanceToCamera = function(frameState) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('frameState', frameState);
        //>>includeEnd('debug');
        var boundingSphere = this._boundingSphere;
        return Math.max(0.0, Cartesian3.distance(boundingSphere.center, frameState.camera.positionWC) - boundingSphere.radius);
    };
 
    /**
     * Determines which side of a plane this sphere is located.
     *
     * @param {Plane} plane The plane to test against.
     * @returns {Intersect} {@link Intersect.INSIDE} if the entire sphere is on the side of the plane
     *                      the normal is pointing, {@link Intersect.OUTSIDE} if the entire sphere is
     *                      on the opposite side, and {@link Intersect.INTERSECTING} if the sphere
     *                      intersects the plane.
     */
    TileBoundingSphere.prototype.intersectPlane = function(plane) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('plane', plane);
        //>>includeEnd('debug');
        return BoundingSphere.intersectPlane(this._boundingSphere, plane);
    };
 
    /**
     * Update the bounding sphere after the tile is transformed.
     *
     * @param {Cartesian3} center The center of the bounding sphere.
     * @param {Number} radius The radius of the bounding sphere.
     */
    TileBoundingSphere.prototype.update = function(center, radius) {
        Cartesian3.clone(center, this._boundingSphere.center);
        this._boundingSphere.radius = radius;
    };
 
    /**
     * Creates a debug primitive that shows the outline of the sphere.
     *
     * @param {Color} color The desired color of the primitive's mesh
     * @return {Primitive}
     */
    TileBoundingSphere.prototype.createDebugVolume = function(color) {
        //>>includeStart('debug', pragmas.debug);
        Check.defined('color', color);
        //>>includeEnd('debug');
        var geometry = new SphereOutlineGeometry({
            radius: this.radius
        });
        var modelMatrix = Matrix4.fromTranslation(this.center, new Matrix4.clone(Matrix4.IDENTITY));
        var instance = new GeometryInstance({
            geometry : geometry,
            id : 'outline',
            modelMatrix : modelMatrix,
            attributes : {
                color : ColorGeometryInstanceAttribute.fromColor(color)
            }
        });
 
        return new Primitive({
            geometryInstances : instance,
            appearance : new PerInstanceColorAppearance({
                translucent : false,
                flat : true
            }),
            asynchronous : false
        });
    };
export default TileBoundingSphere;